1 /* tc-alpha.c - Processor-specific code for the DEC Alpha AXP CPU.
2 Copyright 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
5 Contributed by Carnegie Mellon University, 1993.
6 Written by Alessandro Forin, based on earlier gas-1.38 target CPU files.
7 Modified by Ken Raeburn for gas-2.x and ECOFF support.
8 Modified by Richard Henderson for ELF support.
9 Modified by Klaus K"ampf for EVAX (OpenVMS/Alpha) support.
11 This file is part of GAS, the GNU Assembler.
13 GAS is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 3, or (at your option)
18 GAS is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with GAS; see the file COPYING. If not, write to the Free
25 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
28 /* Mach Operating System
29 Copyright (c) 1993 Carnegie Mellon University
32 Permission to use, copy, modify and distribute this software and its
33 documentation is hereby granted, provided that both the copyright
34 notice and this permission notice appear in all copies of the
35 software, derivative works or modified versions, and any portions
36 thereof, and that both notices appear in supporting documentation.
38 CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
39 CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
40 ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
42 Carnegie Mellon requests users of this software to return to
44 Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
45 School of Computer Science
46 Carnegie Mellon University
47 Pittsburgh PA 15213-3890
49 any improvements or extensions that they make and grant Carnegie the
50 rights to redistribute these changes. */
54 #include "struc-symbol.h"
57 #include "opcode/alpha.h"
60 #include "elf/alpha.h"
68 #include "dwarf2dbg.h"
69 #include "dw2gencfi.h"
70 #include "safe-ctype.h"
74 #define TOKENIZE_ERROR -1
75 #define TOKENIZE_ERROR_REPORT -2
76 #define MAX_INSN_FIXUPS 2
77 #define MAX_INSN_ARGS 5
79 /* Used since new relocation types are introduced in this
80 file (DUMMY_RELOC_LITUSE_*) */
81 typedef int extended_bfd_reloc_code_real_type;
86 /* bfd_reloc_code_real_type reloc; */
87 extended_bfd_reloc_code_real_type reloc;
89 /* The symbol of the item in the linkage section. */
92 /* The symbol of the procedure descriptor. */
101 struct alpha_fixup fixups[MAX_INSN_FIXUPS];
119 void (*emit) (const expressionS *, int, const void *);
121 enum alpha_macro_arg argsets[16];
124 /* Extra expression types. */
126 #define O_pregister O_md1 /* O_register, in parentheses. */
127 #define O_cpregister O_md2 /* + a leading comma. */
129 /* The alpha_reloc_op table below depends on the ordering of these. */
130 #define O_literal O_md3 /* !literal relocation. */
131 #define O_lituse_addr O_md4 /* !lituse_addr relocation. */
132 #define O_lituse_base O_md5 /* !lituse_base relocation. */
133 #define O_lituse_bytoff O_md6 /* !lituse_bytoff relocation. */
134 #define O_lituse_jsr O_md7 /* !lituse_jsr relocation. */
135 #define O_lituse_tlsgd O_md8 /* !lituse_tlsgd relocation. */
136 #define O_lituse_tlsldm O_md9 /* !lituse_tlsldm relocation. */
137 #define O_lituse_jsrdirect O_md10 /* !lituse_jsrdirect relocation. */
138 #define O_gpdisp O_md11 /* !gpdisp relocation. */
139 #define O_gprelhigh O_md12 /* !gprelhigh relocation. */
140 #define O_gprellow O_md13 /* !gprellow relocation. */
141 #define O_gprel O_md14 /* !gprel relocation. */
142 #define O_samegp O_md15 /* !samegp relocation. */
143 #define O_tlsgd O_md16 /* !tlsgd relocation. */
144 #define O_tlsldm O_md17 /* !tlsldm relocation. */
145 #define O_gotdtprel O_md18 /* !gotdtprel relocation. */
146 #define O_dtprelhi O_md19 /* !dtprelhi relocation. */
147 #define O_dtprello O_md20 /* !dtprello relocation. */
148 #define O_dtprel O_md21 /* !dtprel relocation. */
149 #define O_gottprel O_md22 /* !gottprel relocation. */
150 #define O_tprelhi O_md23 /* !tprelhi relocation. */
151 #define O_tprello O_md24 /* !tprello relocation. */
152 #define O_tprel O_md25 /* !tprel relocation. */
154 #define DUMMY_RELOC_LITUSE_ADDR (BFD_RELOC_UNUSED + 1)
155 #define DUMMY_RELOC_LITUSE_BASE (BFD_RELOC_UNUSED + 2)
156 #define DUMMY_RELOC_LITUSE_BYTOFF (BFD_RELOC_UNUSED + 3)
157 #define DUMMY_RELOC_LITUSE_JSR (BFD_RELOC_UNUSED + 4)
158 #define DUMMY_RELOC_LITUSE_TLSGD (BFD_RELOC_UNUSED + 5)
159 #define DUMMY_RELOC_LITUSE_TLSLDM (BFD_RELOC_UNUSED + 6)
160 #define DUMMY_RELOC_LITUSE_JSRDIRECT (BFD_RELOC_UNUSED + 7)
162 #define USER_RELOC_P(R) ((R) >= O_literal && (R) <= O_tprel)
164 /* Macros for extracting the type and number of encoded register tokens. */
166 #define is_ir_num(x) (((x) & 32) == 0)
167 #define is_fpr_num(x) (((x) & 32) != 0)
168 #define regno(x) ((x) & 31)
170 /* Something odd inherited from the old assembler. */
172 #define note_gpreg(R) (alpha_gprmask |= (1 << (R)))
173 #define note_fpreg(R) (alpha_fprmask |= (1 << (R)))
175 /* Predicates for 16- and 32-bit ranges */
176 /* XXX: The non-shift version appears to trigger a compiler bug when
177 cross-assembling from x86 w/ gcc 2.7.2. */
180 #define range_signed_16(x) \
181 (((offsetT) (x) >> 15) == 0 || ((offsetT) (x) >> 15) == -1)
182 #define range_signed_32(x) \
183 (((offsetT) (x) >> 31) == 0 || ((offsetT) (x) >> 31) == -1)
185 #define range_signed_16(x) ((offsetT) (x) >= -(offsetT) 0x8000 && \
186 (offsetT) (x) <= (offsetT) 0x7FFF)
187 #define range_signed_32(x) ((offsetT) (x) >= -(offsetT) 0x80000000 && \
188 (offsetT) (x) <= (offsetT) 0x7FFFFFFF)
191 /* Macros for sign extending from 16- and 32-bits. */
192 /* XXX: The cast macros will work on all the systems that I care about,
193 but really a predicate should be found to use the non-cast forms. */
196 #define sign_extend_16(x) ((short) (x))
197 #define sign_extend_32(x) ((int) (x))
199 #define sign_extend_16(x) ((offsetT) (((x) & 0xFFFF) ^ 0x8000) - 0x8000)
200 #define sign_extend_32(x) ((offsetT) (((x) & 0xFFFFFFFF) \
201 ^ 0x80000000) - 0x80000000)
204 /* Macros to build tokens. */
206 #define set_tok_reg(t, r) (memset (&(t), 0, sizeof (t)), \
207 (t).X_op = O_register, \
208 (t).X_add_number = (r))
209 #define set_tok_preg(t, r) (memset (&(t), 0, sizeof (t)), \
210 (t).X_op = O_pregister, \
211 (t).X_add_number = (r))
212 #define set_tok_cpreg(t, r) (memset (&(t), 0, sizeof (t)), \
213 (t).X_op = O_cpregister, \
214 (t).X_add_number = (r))
215 #define set_tok_freg(t, r) (memset (&(t), 0, sizeof (t)), \
216 (t).X_op = O_register, \
217 (t).X_add_number = (r) + 32)
218 #define set_tok_sym(t, s, a) (memset (&(t), 0, sizeof (t)), \
219 (t).X_op = O_symbol, \
220 (t).X_add_symbol = (s), \
221 (t).X_add_number = (a))
222 #define set_tok_const(t, n) (memset (&(t), 0, sizeof (t)), \
223 (t).X_op = O_constant, \
224 (t).X_add_number = (n))
226 /* Generic assembler global variables which must be defined by all
229 /* Characters which always start a comment. */
230 const char comment_chars[] = "#";
232 /* Characters which start a comment at the beginning of a line. */
233 const char line_comment_chars[] = "#";
235 /* Characters which may be used to separate multiple commands on a
237 const char line_separator_chars[] = ";";
239 /* Characters which are used to indicate an exponent in a floating
241 const char EXP_CHARS[] = "eE";
243 /* Characters which mean that a number is a floating point constant,
245 /* XXX: Do all of these really get used on the alpha?? */
246 char FLT_CHARS[] = "rRsSfFdDxXpP";
249 const char *md_shortopts = "Fm:g+1h:HG:";
251 const char *md_shortopts = "Fm:gG:";
254 struct option md_longopts[] =
256 #define OPTION_32ADDR (OPTION_MD_BASE)
257 { "32addr", no_argument, NULL, OPTION_32ADDR },
258 #define OPTION_RELAX (OPTION_32ADDR + 1)
259 { "relax", no_argument, NULL, OPTION_RELAX },
261 #define OPTION_MDEBUG (OPTION_RELAX + 1)
262 #define OPTION_NO_MDEBUG (OPTION_MDEBUG + 1)
263 { "mdebug", no_argument, NULL, OPTION_MDEBUG },
264 { "no-mdebug", no_argument, NULL, OPTION_NO_MDEBUG },
267 #define OPTION_REPLACE (OPTION_RELAX + 1)
268 #define OPTION_NOREPLACE (OPTION_REPLACE+1)
269 { "replace", no_argument, NULL, OPTION_REPLACE },
270 { "noreplace", no_argument, NULL, OPTION_NOREPLACE },
272 { NULL, no_argument, NULL, 0 }
275 size_t md_longopts_size = sizeof (md_longopts);
279 #define AXP_REG_R16 16
280 #define AXP_REG_R17 17
282 #define AXP_REG_T9 22
284 #define AXP_REG_T10 23
286 #define AXP_REG_T11 24
288 #define AXP_REG_T12 25
289 #define AXP_REG_AI 25
291 #define AXP_REG_FP 29
294 #define AXP_REG_GP AXP_REG_PV
296 #endif /* OBJ_EVAX */
298 /* The cpu for which we are generating code. */
299 static unsigned alpha_target = AXP_OPCODE_BASE;
300 static const char *alpha_target_name = "<all>";
302 /* The hash table of instruction opcodes. */
303 static struct hash_control *alpha_opcode_hash;
305 /* The hash table of macro opcodes. */
306 static struct hash_control *alpha_macro_hash;
309 /* The $gp relocation symbol. */
310 static symbolS *alpha_gp_symbol;
312 /* XXX: what is this, and why is it exported? */
313 valueT alpha_gp_value;
316 /* The current $gp register. */
317 static int alpha_gp_register = AXP_REG_GP;
319 /* A table of the register symbols. */
320 static symbolS *alpha_register_table[64];
322 /* Constant sections, or sections of constants. */
324 static segT alpha_lita_section;
327 segT alpha_link_section;
330 static segT alpha_lit8_section;
333 /* Symbols referring to said sections. */
335 static symbolS *alpha_lita_symbol;
338 static symbolS *alpha_link_symbol;
341 static symbolS *alpha_lit8_symbol;
344 /* Literal for .litX+0x8000 within .lita. */
346 static offsetT alpha_lit8_literal;
349 /* Is the assembler not allowed to use $at? */
350 static int alpha_noat_on = 0;
352 /* Are macros enabled? */
353 static int alpha_macros_on = 1;
355 /* Are floats disabled? */
356 static int alpha_nofloats_on = 0;
358 /* Are addresses 32 bit? */
359 static int alpha_addr32_on = 0;
361 /* Symbol labelling the current insn. When the Alpha gas sees
364 and the section happens to not be on an eight byte boundary, it
365 will align both the symbol and the .quad to an eight byte boundary. */
366 static symbolS *alpha_insn_label;
367 #if defined(OBJ_ELF) || defined (OBJ_EVAX)
368 static symbolS *alpha_prologue_label;
372 /* Symbol associate with the current jsr instruction. */
373 static symbolS *alpha_linkage_symbol;
376 /* Whether we should automatically align data generation pseudo-ops.
377 .align 0 will turn this off. */
378 static int alpha_auto_align_on = 1;
380 /* The known current alignment of the current section. */
381 static int alpha_current_align;
383 /* These are exported to ECOFF code. */
384 unsigned long alpha_gprmask, alpha_fprmask;
386 /* Whether the debugging option was seen. */
387 static int alpha_debug;
390 /* Whether we are emitting an mdebug section. */
391 int alpha_flag_mdebug = -1;
395 /* Whether to perform the VMS procedure call optimization. */
396 int alpha_flag_replace = 1;
399 /* Don't fully resolve relocations, allowing code movement in the linker. */
400 static int alpha_flag_relax;
402 /* What value to give to bfd_set_gp_size. */
403 static int g_switch_value = 8;
406 /* Collect information about current procedure here. */
407 struct alpha_evax_procs
409 symbolS *symbol; /* Proc pdesc symbol. */
411 int framereg; /* Register for frame pointer. */
412 int framesize; /* Size of frame. */
424 /* Linked list of .linkage fixups. */
425 struct alpha_linkage_fixups *alpha_linkage_fixup_root;
426 static struct alpha_linkage_fixups *alpha_linkage_fixup_tail;
428 /* Current procedure descriptor. */
429 static struct alpha_evax_procs *alpha_evax_proc;
430 static struct alpha_evax_procs alpha_evax_proc_data;
432 static int alpha_flag_hash_long_names = 0; /* -+ */
433 static int alpha_flag_show_after_trunc = 0; /* -H */
435 /* If the -+ switch is given, then a hash is appended to any name that is
436 longer than 64 characters, else longer symbol names are truncated. */
441 /* A table to map the spelling of a relocation operand into an appropriate
442 bfd_reloc_code_real_type type. The table is assumed to be ordered such
443 that op-O_literal indexes into it. */
445 #define ALPHA_RELOC_TABLE(op) \
446 (&alpha_reloc_op[ ((!USER_RELOC_P (op)) \
448 : (int) (op) - (int) O_literal) ])
450 #define DEF(NAME, RELOC, REQ, ALLOW) \
451 { #NAME, sizeof(#NAME)-1, O_##NAME, RELOC, REQ, ALLOW}
453 static const struct alpha_reloc_op_tag
455 const char *name; /* String to lookup. */
456 size_t length; /* Size of the string. */
457 operatorT op; /* Which operator to use. */
458 extended_bfd_reloc_code_real_type reloc;
459 unsigned int require_seq : 1; /* Require a sequence number. */
460 unsigned int allow_seq : 1; /* Allow a sequence number. */
464 DEF (literal, BFD_RELOC_ALPHA_ELF_LITERAL, 0, 1),
465 DEF (lituse_addr, DUMMY_RELOC_LITUSE_ADDR, 1, 1),
466 DEF (lituse_base, DUMMY_RELOC_LITUSE_BASE, 1, 1),
467 DEF (lituse_bytoff, DUMMY_RELOC_LITUSE_BYTOFF, 1, 1),
468 DEF (lituse_jsr, DUMMY_RELOC_LITUSE_JSR, 1, 1),
469 DEF (lituse_tlsgd, DUMMY_RELOC_LITUSE_TLSGD, 1, 1),
470 DEF (lituse_tlsldm, DUMMY_RELOC_LITUSE_TLSLDM, 1, 1),
471 DEF (lituse_jsrdirect, DUMMY_RELOC_LITUSE_JSRDIRECT, 1, 1),
472 DEF (gpdisp, BFD_RELOC_ALPHA_GPDISP, 1, 1),
473 DEF (gprelhigh, BFD_RELOC_ALPHA_GPREL_HI16, 0, 0),
474 DEF (gprellow, BFD_RELOC_ALPHA_GPREL_LO16, 0, 0),
475 DEF (gprel, BFD_RELOC_GPREL16, 0, 0),
476 DEF (samegp, BFD_RELOC_ALPHA_BRSGP, 0, 0),
477 DEF (tlsgd, BFD_RELOC_ALPHA_TLSGD, 0, 1),
478 DEF (tlsldm, BFD_RELOC_ALPHA_TLSLDM, 0, 1),
479 DEF (gotdtprel, BFD_RELOC_ALPHA_GOTDTPREL16, 0, 0),
480 DEF (dtprelhi, BFD_RELOC_ALPHA_DTPREL_HI16, 0, 0),
481 DEF (dtprello, BFD_RELOC_ALPHA_DTPREL_LO16, 0, 0),
482 DEF (dtprel, BFD_RELOC_ALPHA_DTPREL16, 0, 0),
483 DEF (gottprel, BFD_RELOC_ALPHA_GOTTPREL16, 0, 0),
484 DEF (tprelhi, BFD_RELOC_ALPHA_TPREL_HI16, 0, 0),
485 DEF (tprello, BFD_RELOC_ALPHA_TPREL_LO16, 0, 0),
486 DEF (tprel, BFD_RELOC_ALPHA_TPREL16, 0, 0),
491 static const int alpha_num_reloc_op
492 = sizeof (alpha_reloc_op) / sizeof (*alpha_reloc_op);
493 #endif /* RELOC_OP_P */
495 /* Maximum # digits needed to hold the largest sequence #. */
496 #define ALPHA_RELOC_DIGITS 25
498 /* Structure to hold explicit sequence information. */
499 struct alpha_reloc_tag
501 fixS *master; /* The literal reloc. */
503 struct symbol *sym; /* Linkage section item symbol. */
504 struct symbol *psym; /* Pdesc symbol. */
506 fixS *slaves; /* Head of linked list of lituses. */
507 segT segment; /* Segment relocs are in or undefined_section. */
508 long sequence; /* Sequence #. */
509 unsigned n_master; /* # of literals. */
510 unsigned n_slaves; /* # of lituses. */
511 unsigned saw_tlsgd : 1; /* True if ... */
512 unsigned saw_tlsldm : 1;
513 unsigned saw_lu_tlsgd : 1;
514 unsigned saw_lu_tlsldm : 1;
515 unsigned multi_section_p : 1; /* True if more than one section was used. */
516 char string[1]; /* Printable form of sequence to hash with. */
519 /* Hash table to link up literals with the appropriate lituse. */
520 static struct hash_control *alpha_literal_hash;
522 /* Sequence numbers for internal use by macros. */
523 static long next_sequence_num = -1;
525 /* A table of CPU names and opcode sets. */
527 static const struct cpu_type
534 /* Ad hoc convention: cpu number gets palcode, process code doesn't.
535 This supports usage under DU 4.0b that does ".arch ev4", and
536 usage in MILO that does -m21064. Probably something more
537 specific like -m21064-pal should be used, but oh well. */
539 { "21064", AXP_OPCODE_BASE|AXP_OPCODE_EV4 },
540 { "21064a", AXP_OPCODE_BASE|AXP_OPCODE_EV4 },
541 { "21066", AXP_OPCODE_BASE|AXP_OPCODE_EV4 },
542 { "21068", AXP_OPCODE_BASE|AXP_OPCODE_EV4 },
543 { "21164", AXP_OPCODE_BASE|AXP_OPCODE_EV5 },
544 { "21164a", AXP_OPCODE_BASE|AXP_OPCODE_EV5|AXP_OPCODE_BWX },
545 { "21164pc", (AXP_OPCODE_BASE|AXP_OPCODE_EV5|AXP_OPCODE_BWX
547 { "21264", (AXP_OPCODE_BASE|AXP_OPCODE_EV6|AXP_OPCODE_BWX
548 |AXP_OPCODE_MAX|AXP_OPCODE_CIX) },
549 { "21264a", (AXP_OPCODE_BASE|AXP_OPCODE_EV6|AXP_OPCODE_BWX
550 |AXP_OPCODE_MAX|AXP_OPCODE_CIX) },
551 { "21264b", (AXP_OPCODE_BASE|AXP_OPCODE_EV6|AXP_OPCODE_BWX
552 |AXP_OPCODE_MAX|AXP_OPCODE_CIX) },
554 { "ev4", AXP_OPCODE_BASE },
555 { "ev45", AXP_OPCODE_BASE },
556 { "lca45", AXP_OPCODE_BASE },
557 { "ev5", AXP_OPCODE_BASE },
558 { "ev56", AXP_OPCODE_BASE|AXP_OPCODE_BWX },
559 { "pca56", AXP_OPCODE_BASE|AXP_OPCODE_BWX|AXP_OPCODE_MAX },
560 { "ev6", AXP_OPCODE_BASE|AXP_OPCODE_BWX|AXP_OPCODE_MAX|AXP_OPCODE_CIX },
561 { "ev67", AXP_OPCODE_BASE|AXP_OPCODE_BWX|AXP_OPCODE_MAX|AXP_OPCODE_CIX },
562 { "ev68", AXP_OPCODE_BASE|AXP_OPCODE_BWX|AXP_OPCODE_MAX|AXP_OPCODE_CIX },
564 { "all", AXP_OPCODE_BASE },
568 /* Some instruction sets indexed by lg(size). */
569 static const char * const sextX_op[] = { "sextb", "sextw", "sextl", NULL };
570 static const char * const insXl_op[] = { "insbl", "inswl", "insll", "insql" };
571 static const char * const insXh_op[] = { NULL, "inswh", "inslh", "insqh" };
572 static const char * const extXl_op[] = { "extbl", "extwl", "extll", "extql" };
573 static const char * const extXh_op[] = { NULL, "extwh", "extlh", "extqh" };
574 static const char * const mskXl_op[] = { "mskbl", "mskwl", "mskll", "mskql" };
575 static const char * const mskXh_op[] = { NULL, "mskwh", "msklh", "mskqh" };
576 static const char * const stX_op[] = { "stb", "stw", "stl", "stq" };
577 static const char * const ldXu_op[] = { "ldbu", "ldwu", NULL, NULL };
579 static void assemble_insn (const struct alpha_opcode *, const expressionS *, int, struct alpha_insn *, extended_bfd_reloc_code_real_type);
580 static void emit_insn (struct alpha_insn *);
581 static void assemble_tokens (const char *, const expressionS *, int, int);
583 static char *s_alpha_section_name (void);
584 static symbolS *add_to_link_pool (symbolS *, offsetT);
587 static struct alpha_reloc_tag *
588 get_alpha_reloc_tag (long sequence)
590 char buffer[ALPHA_RELOC_DIGITS];
591 struct alpha_reloc_tag *info;
593 sprintf (buffer, "!%ld", sequence);
595 info = (struct alpha_reloc_tag *) hash_find (alpha_literal_hash, buffer);
598 size_t len = strlen (buffer);
601 info = (struct alpha_reloc_tag *)
602 xcalloc (sizeof (struct alpha_reloc_tag) + len, 1);
604 info->segment = now_seg;
605 info->sequence = sequence;
606 strcpy (info->string, buffer);
607 errmsg = hash_insert (alpha_literal_hash, info->string, (void *) info);
609 as_fatal ("%s", errmsg);
622 alpha_adjust_relocs (bfd *abfd ATTRIBUTE_UNUSED,
624 void * ptr ATTRIBUTE_UNUSED)
626 segment_info_type *seginfo = seg_info (sec);
632 /* If seginfo is NULL, we did not create this section; don't do
633 anything with it. By using a pointer to a pointer, we can update
634 the links in place. */
638 /* If there are no relocations, skip the section. */
639 if (! seginfo->fix_root)
642 /* First rebuild the fixup chain without the explicit lituse and
643 gpdisp_lo16 relocs. */
644 prevP = &seginfo->fix_root;
645 for (fixp = seginfo->fix_root; fixp; fixp = next)
647 next = fixp->fx_next;
648 fixp->fx_next = (fixS *) 0;
650 switch (fixp->fx_r_type)
652 case BFD_RELOC_ALPHA_LITUSE:
653 if (fixp->tc_fix_data.info->n_master == 0)
654 as_bad_where (fixp->fx_file, fixp->fx_line,
655 _("No !literal!%ld was found"),
656 fixp->tc_fix_data.info->sequence);
658 if (fixp->fx_offset == LITUSE_ALPHA_TLSGD)
660 if (! fixp->tc_fix_data.info->saw_tlsgd)
661 as_bad_where (fixp->fx_file, fixp->fx_line,
662 _("No !tlsgd!%ld was found"),
663 fixp->tc_fix_data.info->sequence);
665 else if (fixp->fx_offset == LITUSE_ALPHA_TLSLDM)
667 if (! fixp->tc_fix_data.info->saw_tlsldm)
668 as_bad_where (fixp->fx_file, fixp->fx_line,
669 _("No !tlsldm!%ld was found"),
670 fixp->tc_fix_data.info->sequence);
675 case BFD_RELOC_ALPHA_GPDISP_LO16:
676 if (fixp->tc_fix_data.info->n_master == 0)
677 as_bad_where (fixp->fx_file, fixp->fx_line,
678 _("No ldah !gpdisp!%ld was found"),
679 fixp->tc_fix_data.info->sequence);
682 case BFD_RELOC_ALPHA_ELF_LITERAL:
683 if (fixp->tc_fix_data.info
684 && (fixp->tc_fix_data.info->saw_tlsgd
685 || fixp->tc_fix_data.info->saw_tlsldm))
691 prevP = &fixp->fx_next;
696 /* Go back and re-chain dependent relocations. They are currently
697 linked through the next_reloc field in reverse order, so as we
698 go through the next_reloc chain, we effectively reverse the chain
701 Except if there is more than one !literal for a given sequence
702 number. In that case, the programmer and/or compiler is not sure
703 how control flows from literal to lituse, and we can't be sure to
704 get the relaxation correct.
706 ??? Well, actually we could, if there are enough lituses such that
707 we can make each literal have at least one of each lituse type
708 present. Not implemented.
710 Also suppress the optimization if the !literals/!lituses are spread
711 in different segments. This can happen with "intersting" uses of
712 inline assembly; examples are present in the Linux kernel semaphores. */
714 for (fixp = seginfo->fix_root; fixp; fixp = next)
716 next = fixp->fx_next;
717 switch (fixp->fx_r_type)
719 case BFD_RELOC_ALPHA_TLSGD:
720 case BFD_RELOC_ALPHA_TLSLDM:
721 if (!fixp->tc_fix_data.info)
723 if (fixp->tc_fix_data.info->n_master == 0)
725 else if (fixp->tc_fix_data.info->n_master > 1)
727 as_bad_where (fixp->fx_file, fixp->fx_line,
728 _("too many !literal!%ld for %s"),
729 fixp->tc_fix_data.info->sequence,
730 (fixp->fx_r_type == BFD_RELOC_ALPHA_TLSGD
731 ? "!tlsgd" : "!tlsldm"));
735 fixp->tc_fix_data.info->master->fx_next = fixp->fx_next;
736 fixp->fx_next = fixp->tc_fix_data.info->master;
737 fixp = fixp->fx_next;
740 case BFD_RELOC_ALPHA_ELF_LITERAL:
741 if (fixp->tc_fix_data.info
742 && fixp->tc_fix_data.info->n_master == 1
743 && ! fixp->tc_fix_data.info->multi_section_p)
745 for (slave = fixp->tc_fix_data.info->slaves;
747 slave = slave->tc_fix_data.next_reloc)
749 slave->fx_next = fixp->fx_next;
750 fixp->fx_next = slave;
755 case BFD_RELOC_ALPHA_GPDISP_HI16:
756 if (fixp->tc_fix_data.info->n_slaves == 0)
757 as_bad_where (fixp->fx_file, fixp->fx_line,
758 _("No lda !gpdisp!%ld was found"),
759 fixp->tc_fix_data.info->sequence);
762 slave = fixp->tc_fix_data.info->slaves;
763 slave->fx_next = next;
764 fixp->fx_next = slave;
774 /* Before the relocations are written, reorder them, so that user
775 supplied !lituse relocations follow the appropriate !literal
776 relocations, and similarly for !gpdisp relocations. */
779 alpha_before_fix (void)
781 if (alpha_literal_hash)
782 bfd_map_over_sections (stdoutput, alpha_adjust_relocs, NULL);
789 debug_exp (expressionS tok[], int ntok)
793 fprintf (stderr, "debug_exp: %d tokens", ntok);
794 for (i = 0; i < ntok; i++)
796 expressionS *t = &tok[i];
801 default: name = "unknown"; break;
802 case O_illegal: name = "O_illegal"; break;
803 case O_absent: name = "O_absent"; break;
804 case O_constant: name = "O_constant"; break;
805 case O_symbol: name = "O_symbol"; break;
806 case O_symbol_rva: name = "O_symbol_rva"; break;
807 case O_register: name = "O_register"; break;
808 case O_big: name = "O_big"; break;
809 case O_uminus: name = "O_uminus"; break;
810 case O_bit_not: name = "O_bit_not"; break;
811 case O_logical_not: name = "O_logical_not"; break;
812 case O_multiply: name = "O_multiply"; break;
813 case O_divide: name = "O_divide"; break;
814 case O_modulus: name = "O_modulus"; break;
815 case O_left_shift: name = "O_left_shift"; break;
816 case O_right_shift: name = "O_right_shift"; break;
817 case O_bit_inclusive_or: name = "O_bit_inclusive_or"; break;
818 case O_bit_or_not: name = "O_bit_or_not"; break;
819 case O_bit_exclusive_or: name = "O_bit_exclusive_or"; break;
820 case O_bit_and: name = "O_bit_and"; break;
821 case O_add: name = "O_add"; break;
822 case O_subtract: name = "O_subtract"; break;
823 case O_eq: name = "O_eq"; break;
824 case O_ne: name = "O_ne"; break;
825 case O_lt: name = "O_lt"; break;
826 case O_le: name = "O_le"; break;
827 case O_ge: name = "O_ge"; break;
828 case O_gt: name = "O_gt"; break;
829 case O_logical_and: name = "O_logical_and"; break;
830 case O_logical_or: name = "O_logical_or"; break;
831 case O_index: name = "O_index"; break;
832 case O_pregister: name = "O_pregister"; break;
833 case O_cpregister: name = "O_cpregister"; break;
834 case O_literal: name = "O_literal"; break;
835 case O_lituse_addr: name = "O_lituse_addr"; break;
836 case O_lituse_base: name = "O_lituse_base"; break;
837 case O_lituse_bytoff: name = "O_lituse_bytoff"; break;
838 case O_lituse_jsr: name = "O_lituse_jsr"; break;
839 case O_lituse_tlsgd: name = "O_lituse_tlsgd"; break;
840 case O_lituse_tlsldm: name = "O_lituse_tlsldm"; break;
841 case O_lituse_jsrdirect: name = "O_lituse_jsrdirect"; break;
842 case O_gpdisp: name = "O_gpdisp"; break;
843 case O_gprelhigh: name = "O_gprelhigh"; break;
844 case O_gprellow: name = "O_gprellow"; break;
845 case O_gprel: name = "O_gprel"; break;
846 case O_samegp: name = "O_samegp"; break;
847 case O_tlsgd: name = "O_tlsgd"; break;
848 case O_tlsldm: name = "O_tlsldm"; break;
849 case O_gotdtprel: name = "O_gotdtprel"; break;
850 case O_dtprelhi: name = "O_dtprelhi"; break;
851 case O_dtprello: name = "O_dtprello"; break;
852 case O_dtprel: name = "O_dtprel"; break;
853 case O_gottprel: name = "O_gottprel"; break;
854 case O_tprelhi: name = "O_tprelhi"; break;
855 case O_tprello: name = "O_tprello"; break;
856 case O_tprel: name = "O_tprel"; break;
859 fprintf (stderr, ", %s(%s, %s, %d)", name,
860 (t->X_add_symbol) ? S_GET_NAME (t->X_add_symbol) : "--",
861 (t->X_op_symbol) ? S_GET_NAME (t->X_op_symbol) : "--",
862 (int) t->X_add_number);
864 fprintf (stderr, "\n");
869 /* Parse the arguments to an opcode. */
872 tokenize_arguments (char *str,
876 expressionS *end_tok = tok + ntok;
877 char *old_input_line_pointer;
878 int saw_comma = 0, saw_arg = 0;
880 expressionS *orig_tok = tok;
884 const struct alpha_reloc_op_tag *r;
887 int reloc_found_p = 0;
890 memset (tok, 0, sizeof (*tok) * ntok);
892 /* Save and restore input_line_pointer around this function. */
893 old_input_line_pointer = input_line_pointer;
894 input_line_pointer = str;
897 /* ??? Wrest control of ! away from the regular expression parser. */
898 is_end_of_line[(unsigned char) '!'] = 1;
901 while (tok < end_tok && *input_line_pointer)
904 switch (*input_line_pointer)
911 /* A relocation operand can be placed after the normal operand on an
912 assembly language statement, and has the following form:
913 !relocation_type!sequence_number. */
916 /* Only support one relocation op per insn. */
917 as_bad (_("More than one relocation op per insn"));
924 ++input_line_pointer;
926 p = input_line_pointer;
927 c = get_symbol_end ();
929 /* Parse !relocation_type. */
930 len = input_line_pointer - p;
933 as_bad (_("No relocation operand"));
937 r = &alpha_reloc_op[0];
938 for (i = alpha_num_reloc_op - 1; i >= 0; i--, r++)
939 if (len == r->length && memcmp (p, r->name, len) == 0)
943 as_bad (_("Unknown relocation operand: !%s"), p);
947 *input_line_pointer = c;
949 if (*input_line_pointer != '!')
953 as_bad (_("no sequence number after !%s"), p);
957 tok->X_add_number = 0;
963 as_bad (_("!%s does not use a sequence number"), p);
967 input_line_pointer++;
969 /* Parse !sequence_number. */
971 if (tok->X_op != O_constant || tok->X_add_number <= 0)
973 as_bad (_("Bad sequence number: !%s!%s"),
974 r->name, input_line_pointer);
983 #endif /* RELOC_OP_P */
986 ++input_line_pointer;
987 if (saw_comma || !saw_arg)
994 char *hold = input_line_pointer++;
996 /* First try for parenthesized register ... */
998 if (*input_line_pointer == ')' && tok->X_op == O_register)
1000 tok->X_op = (saw_comma ? O_cpregister : O_pregister);
1003 ++input_line_pointer;
1008 /* ... then fall through to plain expression. */
1009 input_line_pointer = hold;
1013 if (saw_arg && !saw_comma)
1017 if (tok->X_op == O_illegal || tok->X_op == O_absent)
1030 input_line_pointer = old_input_line_pointer;
1033 debug_exp (orig_tok, ntok - (end_tok - tok));
1036 is_end_of_line[(unsigned char) '!'] = 0;
1039 return ntok - (end_tok - tok);
1043 is_end_of_line[(unsigned char) '!'] = 0;
1045 input_line_pointer = old_input_line_pointer;
1046 return TOKENIZE_ERROR;
1050 is_end_of_line[(unsigned char) '!'] = 0;
1052 input_line_pointer = old_input_line_pointer;
1053 return TOKENIZE_ERROR_REPORT;
1056 /* Search forward through all variants of an opcode looking for a
1059 static const struct alpha_opcode *
1060 find_opcode_match (const struct alpha_opcode *first_opcode,
1061 const expressionS *tok,
1065 const struct alpha_opcode *opcode = first_opcode;
1067 int got_cpu_match = 0;
1071 const unsigned char *opidx;
1074 /* Don't match opcodes that don't exist on this architecture. */
1075 if (!(opcode->flags & alpha_target))
1080 for (opidx = opcode->operands; *opidx; ++opidx)
1082 const struct alpha_operand *operand = &alpha_operands[*opidx];
1084 /* Only take input from real operands. */
1085 if (operand->flags & AXP_OPERAND_FAKE)
1088 /* When we expect input, make sure we have it. */
1091 if ((operand->flags & AXP_OPERAND_OPTIONAL_MASK) == 0)
1096 /* Match operand type with expression type. */
1097 switch (operand->flags & AXP_OPERAND_TYPECHECK_MASK)
1099 case AXP_OPERAND_IR:
1100 if (tok[tokidx].X_op != O_register
1101 || !is_ir_num (tok[tokidx].X_add_number))
1104 case AXP_OPERAND_FPR:
1105 if (tok[tokidx].X_op != O_register
1106 || !is_fpr_num (tok[tokidx].X_add_number))
1109 case AXP_OPERAND_IR | AXP_OPERAND_PARENS:
1110 if (tok[tokidx].X_op != O_pregister
1111 || !is_ir_num (tok[tokidx].X_add_number))
1114 case AXP_OPERAND_IR | AXP_OPERAND_PARENS | AXP_OPERAND_COMMA:
1115 if (tok[tokidx].X_op != O_cpregister
1116 || !is_ir_num (tok[tokidx].X_add_number))
1120 case AXP_OPERAND_RELATIVE:
1121 case AXP_OPERAND_SIGNED:
1122 case AXP_OPERAND_UNSIGNED:
1123 switch (tok[tokidx].X_op)
1138 /* Everything else should have been fake. */
1144 /* Possible match -- did we use all of our input? */
1153 while (++opcode - alpha_opcodes < (int) alpha_num_opcodes
1154 && !strcmp (opcode->name, first_opcode->name));
1157 *pcpumatch = got_cpu_match;
1162 /* Given an opcode name and a pre-tokenized set of arguments, assemble
1163 the insn, but do not emit it.
1165 Note that this implies no macros allowed, since we can't store more
1166 than one insn in an insn structure. */
1169 assemble_tokens_to_insn (const char *opname,
1170 const expressionS *tok,
1172 struct alpha_insn *insn)
1174 const struct alpha_opcode *opcode;
1176 /* Search opcodes. */
1177 opcode = (const struct alpha_opcode *) hash_find (alpha_opcode_hash, opname);
1181 opcode = find_opcode_match (opcode, tok, &ntok, &cpumatch);
1184 assemble_insn (opcode, tok, ntok, insn, BFD_RELOC_UNUSED);
1188 as_bad (_("inappropriate arguments for opcode `%s'"), opname);
1190 as_bad (_("opcode `%s' not supported for target %s"), opname,
1194 as_bad (_("unknown opcode `%s'"), opname);
1197 /* Build a BFD section with its flags set appropriately for the .lita,
1198 .lit8, or .lit4 sections. */
1201 create_literal_section (const char *name,
1205 segT current_section = now_seg;
1206 int current_subsec = now_subseg;
1209 *secp = new_sec = subseg_new (name, 0);
1210 subseg_set (current_section, current_subsec);
1211 bfd_set_section_alignment (stdoutput, new_sec, 4);
1212 bfd_set_section_flags (stdoutput, new_sec,
1213 SEC_RELOC | SEC_ALLOC | SEC_LOAD | SEC_READONLY
1216 S_CLEAR_EXTERNAL (*symp = section_symbol (new_sec));
1219 /* Load a (partial) expression into a target register.
1221 If poffset is not null, after the call it will either contain
1222 O_constant 0, or a 16-bit offset appropriate for any MEM format
1223 instruction. In addition, pbasereg will be modified to point to
1224 the base register to use in that MEM format instruction.
1226 In any case, *pbasereg should contain a base register to add to the
1227 expression. This will normally be either AXP_REG_ZERO or
1228 alpha_gp_register. Symbol addresses will always be loaded via $gp,
1229 so "foo($0)" is interpreted as adding the address of foo to $0;
1230 i.e. "ldq $targ, LIT($gp); addq $targ, $0, $targ". Odd, perhaps,
1231 but this is what OSF/1 does.
1233 If explicit relocations of the form !literal!<number> are allowed,
1234 and used, then explicit_reloc with be an expression pointer.
1236 Finally, the return value is nonzero if the calling macro may emit
1237 a LITUSE reloc if otherwise appropriate; the return value is the
1238 sequence number to use. */
1241 load_expression (int targreg,
1242 const expressionS *exp,
1244 expressionS *poffset,
1247 long emit_lituse = 0;
1248 offsetT addend = exp->X_add_number;
1249 int basereg = *pbasereg;
1250 struct alpha_insn insn;
1251 expressionS newtok[3];
1260 /* Attempt to reduce .lit load by splitting the offset from
1261 its symbol when possible, but don't create a situation in
1263 if (!range_signed_32 (addend) &&
1264 (alpha_noat_on || targreg == AXP_REG_AT))
1266 lit = add_to_literal_pool (exp->X_add_symbol, addend,
1267 alpha_lita_section, 8);
1271 lit = add_to_literal_pool (exp->X_add_symbol, 0,
1272 alpha_lita_section, 8);
1275 as_fatal (_("overflow in literal (.lita) table"));
1277 /* Emit "ldq r, lit(gp)". */
1279 if (basereg != alpha_gp_register && targreg == basereg)
1282 as_bad (_("macro requires $at register while noat in effect"));
1283 if (targreg == AXP_REG_AT)
1284 as_bad (_("macro requires $at while $at in use"));
1286 set_tok_reg (newtok[0], AXP_REG_AT);
1289 set_tok_reg (newtok[0], targreg);
1291 set_tok_sym (newtok[1], alpha_lita_symbol, lit);
1292 set_tok_preg (newtok[2], alpha_gp_register);
1294 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1296 gas_assert (insn.nfixups == 1);
1297 insn.fixups[0].reloc = BFD_RELOC_ALPHA_LITERAL;
1298 insn.sequence = emit_lituse = next_sequence_num--;
1299 #endif /* OBJ_ECOFF */
1301 /* Emit "ldq r, gotoff(gp)". */
1303 if (basereg != alpha_gp_register && targreg == basereg)
1306 as_bad (_("macro requires $at register while noat in effect"));
1307 if (targreg == AXP_REG_AT)
1308 as_bad (_("macro requires $at while $at in use"));
1310 set_tok_reg (newtok[0], AXP_REG_AT);
1313 set_tok_reg (newtok[0], targreg);
1315 /* XXX: Disable this .got minimizing optimization so that we can get
1316 better instruction offset knowledge in the compiler. This happens
1317 very infrequently anyway. */
1319 || (!range_signed_32 (addend)
1320 && (alpha_noat_on || targreg == AXP_REG_AT)))
1326 set_tok_sym (newtok[1], exp->X_add_symbol, 0);
1328 set_tok_preg (newtok[2], alpha_gp_register);
1330 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1332 gas_assert (insn.nfixups == 1);
1333 insn.fixups[0].reloc = BFD_RELOC_ALPHA_ELF_LITERAL;
1334 insn.sequence = emit_lituse = next_sequence_num--;
1335 #endif /* OBJ_ELF */
1337 /* Find symbol or symbol pointer in link section. */
1339 if (exp->X_add_symbol == alpha_evax_proc->symbol)
1341 /* Linkage-relative expression. */
1342 set_tok_reg (newtok[0], targreg);
1344 if (range_signed_16 (addend))
1346 set_tok_const (newtok[1], addend);
1351 set_tok_const (newtok[1], 0);
1353 set_tok_preg (newtok[2], basereg);
1354 assemble_tokens_to_insn ("lda", newtok, 3, &insn);
1358 const char *symname = S_GET_NAME (exp->X_add_symbol);
1359 const char *ptr1, *ptr2;
1360 int symlen = strlen (symname);
1363 strcmp (ptr2 = &symname [symlen - 4], "..lk") == 0))
1365 /* Access to an item whose address is stored in the linkage
1366 section. Just read the address. */
1367 set_tok_reg (newtok[0], targreg);
1370 newtok[1].X_op = O_subtract;
1371 newtok[1].X_op_symbol = alpha_evax_proc->symbol;
1373 set_tok_preg (newtok[2], basereg);
1374 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1375 alpha_linkage_symbol = exp->X_add_symbol;
1378 set_tok_const (*poffset, 0);
1380 if (alpha_flag_replace && targreg == 26)
1382 /* Add a NOP fixup for 'ldX $26,YYY..NAME..lk'. */
1386 /* Build the entry name as 'NAME..en'. */
1387 ptr1 = strstr (symname, "..") + 2;
1390 ensymname = (char *) alloca (ptr2 - ptr1 + 5);
1391 memcpy (ensymname, ptr1, ptr2 - ptr1);
1392 memcpy (ensymname + (ptr2 - ptr1), "..en", 5);
1394 gas_assert (insn.nfixups + 1 <= MAX_INSN_FIXUPS);
1395 insn.fixups[insn.nfixups].reloc = BFD_RELOC_ALPHA_NOP;
1396 ensym = symbol_find_or_make (ensymname);
1398 /* The fixup must be the same as the BFD_RELOC_ALPHA_BOH
1399 case in emit_jsrjmp. See B.4.5.2 of the OpenVMS Linker
1401 insn.fixups[insn.nfixups].exp.X_op = O_symbol;
1402 insn.fixups[insn.nfixups].exp.X_add_symbol = ensym;
1403 insn.fixups[insn.nfixups].exp.X_add_number = 0;
1404 insn.fixups[insn.nfixups].xtrasym = alpha_linkage_symbol;
1405 insn.fixups[insn.nfixups].procsym = alpha_evax_proc->symbol;
1408 /* ??? Force bsym to be instantiated now, as it will be
1409 too late to do so in tc_gen_reloc. */
1410 symbol_get_bfdsym (exp->X_add_symbol);
1412 else if (alpha_flag_replace && targreg == 27)
1414 /* Add a lda fixup for 'ldX $27,YYY.NAME..lk+8'. */
1419 ptr1 = strstr (symname, "..") + 2;
1422 psymname = (char *) alloca (ptr2 - ptr1 + 1);
1423 memcpy (psymname, ptr1, ptr2 - ptr1);
1424 psymname [ptr2 - ptr1] = 0;
1426 gas_assert (insn.nfixups + 1 <= MAX_INSN_FIXUPS);
1427 insn.fixups[insn.nfixups].reloc = BFD_RELOC_ALPHA_LDA;
1428 psym = symbol_find_or_make (psymname);
1430 insn.fixups[insn.nfixups].exp.X_op = O_subtract;
1431 insn.fixups[insn.nfixups].exp.X_add_symbol = psym;
1432 insn.fixups[insn.nfixups].exp.X_op_symbol = alpha_evax_proc->symbol;
1433 insn.fixups[insn.nfixups].exp.X_add_number = 0;
1434 insn.fixups[insn.nfixups].xtrasym = alpha_linkage_symbol;
1435 insn.fixups[insn.nfixups].procsym = alpha_evax_proc->symbol;
1444 /* Not in the linkage section. Put the value into the linkage
1448 if (!range_signed_32 (addend))
1449 addend = sign_extend_32 (addend);
1450 linkexp = add_to_link_pool (exp->X_add_symbol, 0);
1451 set_tok_reg (newtok[0], targreg);
1452 set_tok_sym (newtok[1], linkexp, 0);
1453 set_tok_preg (newtok[2], basereg);
1454 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1457 #endif /* OBJ_EVAX */
1462 if (basereg != alpha_gp_register && basereg != AXP_REG_ZERO)
1464 /* Emit "addq r, base, r". */
1466 set_tok_reg (newtok[1], basereg);
1467 set_tok_reg (newtok[2], targreg);
1468 assemble_tokens ("addq", newtok, 3, 0);
1479 /* Assume that this difference expression will be resolved to an
1480 absolute value and that that value will fit in 16 bits. */
1482 set_tok_reg (newtok[0], targreg);
1484 set_tok_preg (newtok[2], basereg);
1485 assemble_tokens (opname, newtok, 3, 0);
1488 set_tok_const (*poffset, 0);
1492 if (exp->X_add_number > 0)
1493 as_bad (_("bignum invalid; zero assumed"));
1495 as_bad (_("floating point number invalid; zero assumed"));
1500 as_bad (_("can't handle expression"));
1505 if (!range_signed_32 (addend))
1511 long seq_num = next_sequence_num--;
1514 /* For 64-bit addends, just put it in the literal pool. */
1516 /* Emit "ldq targreg, lit(basereg)". */
1517 litexp = add_to_link_pool (section_symbol (absolute_section), addend);
1518 set_tok_reg (newtok[0], targreg);
1519 set_tok_sym (newtok[1], litexp, 0);
1520 set_tok_preg (newtok[2], alpha_gp_register);
1521 assemble_tokens ("ldq", newtok, 3, 0);
1524 if (alpha_lit8_section == NULL)
1526 create_literal_section (".lit8",
1527 &alpha_lit8_section,
1528 &alpha_lit8_symbol);
1531 alpha_lit8_literal = add_to_literal_pool (alpha_lit8_symbol, 0x8000,
1532 alpha_lita_section, 8);
1533 if (alpha_lit8_literal >= 0x8000)
1534 as_fatal (_("overflow in literal (.lita) table"));
1538 lit = add_to_literal_pool (NULL, addend, alpha_lit8_section, 8) - 0x8000;
1540 as_fatal (_("overflow in literal (.lit8) table"));
1542 /* Emit "lda litreg, .lit8+0x8000". */
1544 if (targreg == basereg)
1547 as_bad (_("macro requires $at register while noat in effect"));
1548 if (targreg == AXP_REG_AT)
1549 as_bad (_("macro requires $at while $at in use"));
1551 set_tok_reg (newtok[0], AXP_REG_AT);
1554 set_tok_reg (newtok[0], targreg);
1556 set_tok_sym (newtok[1], alpha_lita_symbol, alpha_lit8_literal);
1559 set_tok_sym (newtok[1], alpha_lit8_symbol, 0x8000);
1561 set_tok_preg (newtok[2], alpha_gp_register);
1563 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1565 gas_assert (insn.nfixups == 1);
1567 insn.fixups[0].reloc = BFD_RELOC_ALPHA_LITERAL;
1570 insn.fixups[0].reloc = BFD_RELOC_ALPHA_ELF_LITERAL;
1572 insn.sequence = seq_num;
1576 /* Emit "ldq litreg, lit(litreg)". */
1578 set_tok_const (newtok[1], lit);
1579 set_tok_preg (newtok[2], newtok[0].X_add_number);
1581 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1583 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
1584 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
1585 insn.fixups[insn.nfixups].exp.X_op = O_absent;
1587 insn.sequence = seq_num;
1592 /* Emit "addq litreg, base, target". */
1594 if (basereg != AXP_REG_ZERO)
1596 set_tok_reg (newtok[1], basereg);
1597 set_tok_reg (newtok[2], targreg);
1598 assemble_tokens ("addq", newtok, 3, 0);
1600 #endif /* !OBJ_EVAX */
1603 set_tok_const (*poffset, 0);
1604 *pbasereg = targreg;
1608 offsetT low, high, extra, tmp;
1610 /* For 32-bit operands, break up the addend. */
1612 low = sign_extend_16 (addend);
1614 high = sign_extend_16 (tmp >> 16);
1616 if (tmp - (high << 16))
1620 high = sign_extend_16 (tmp >> 16);
1625 set_tok_reg (newtok[0], targreg);
1626 set_tok_preg (newtok[2], basereg);
1630 /* Emit "ldah r, extra(r). */
1631 set_tok_const (newtok[1], extra);
1632 assemble_tokens ("ldah", newtok, 3, 0);
1633 set_tok_preg (newtok[2], basereg = targreg);
1638 /* Emit "ldah r, high(r). */
1639 set_tok_const (newtok[1], high);
1640 assemble_tokens ("ldah", newtok, 3, 0);
1642 set_tok_preg (newtok[2], basereg);
1645 if ((low && !poffset) || (!poffset && basereg != targreg))
1647 /* Emit "lda r, low(base)". */
1648 set_tok_const (newtok[1], low);
1649 assemble_tokens ("lda", newtok, 3, 0);
1655 set_tok_const (*poffset, low);
1656 *pbasereg = basereg;
1662 /* The lda macro differs from the lda instruction in that it handles
1663 most simple expressions, particularly symbol address loads and
1667 emit_lda (const expressionS *tok,
1669 const void * unused ATTRIBUTE_UNUSED)
1674 basereg = (tok[1].X_op == O_constant ? AXP_REG_ZERO : alpha_gp_register);
1676 basereg = tok[2].X_add_number;
1678 (void) load_expression (tok[0].X_add_number, &tok[1], &basereg, NULL, "lda");
1681 /* The ldah macro differs from the ldah instruction in that it has $31
1682 as an implied base register. */
1685 emit_ldah (const expressionS *tok,
1686 int ntok ATTRIBUTE_UNUSED,
1687 const void * unused ATTRIBUTE_UNUSED)
1689 expressionS newtok[3];
1693 set_tok_preg (newtok[2], AXP_REG_ZERO);
1695 assemble_tokens ("ldah", newtok, 3, 0);
1698 /* Called internally to handle all alignment needs. This takes care
1699 of eliding calls to frag_align if'n the cached current alignment
1700 says we've already got it, as well as taking care of the auto-align
1701 feature wrt labels. */
1707 int force ATTRIBUTE_UNUSED)
1709 if (alpha_current_align >= n)
1714 if (subseg_text_p (now_seg))
1715 frag_align_code (n, 0);
1717 frag_align (n, 0, 0);
1720 frag_align (n, *pfill, 0);
1722 alpha_current_align = n;
1724 if (label != NULL && S_GET_SEGMENT (label) == now_seg)
1726 symbol_set_frag (label, frag_now);
1727 S_SET_VALUE (label, (valueT) frag_now_fix ());
1730 record_alignment (now_seg, n);
1732 /* ??? If alpha_flag_relax && force && elf, record the requested alignment
1733 in a reloc for the linker to see. */
1736 /* Actually output an instruction with its fixup. */
1739 emit_insn (struct alpha_insn *insn)
1744 /* Take care of alignment duties. */
1745 if (alpha_auto_align_on && alpha_current_align < 2)
1746 alpha_align (2, (char *) NULL, alpha_insn_label, 0);
1747 if (alpha_current_align > 2)
1748 alpha_current_align = 2;
1749 alpha_insn_label = NULL;
1751 /* Write out the instruction. */
1753 md_number_to_chars (f, insn->insn, 4);
1756 dwarf2_emit_insn (4);
1759 /* Apply the fixups in order. */
1760 for (i = 0; i < insn->nfixups; ++i)
1762 const struct alpha_operand *operand = (const struct alpha_operand *) 0;
1763 struct alpha_fixup *fixup = &insn->fixups[i];
1764 struct alpha_reloc_tag *info = NULL;
1768 /* Some fixups are only used internally and so have no howto. */
1769 if ((int) fixup->reloc < 0)
1771 operand = &alpha_operands[-(int) fixup->reloc];
1773 pcrel = ((operand->flags & AXP_OPERAND_RELATIVE) != 0);
1775 else if (fixup->reloc > BFD_RELOC_UNUSED
1776 || fixup->reloc == BFD_RELOC_ALPHA_GPDISP_HI16
1777 || fixup->reloc == BFD_RELOC_ALPHA_GPDISP_LO16)
1784 reloc_howto_type *reloc_howto =
1785 bfd_reloc_type_lookup (stdoutput,
1786 (bfd_reloc_code_real_type) fixup->reloc);
1787 gas_assert (reloc_howto);
1789 size = bfd_get_reloc_size (reloc_howto);
1791 switch (fixup->reloc)
1794 case BFD_RELOC_ALPHA_NOP:
1795 case BFD_RELOC_ALPHA_BSR:
1796 case BFD_RELOC_ALPHA_LDA:
1797 case BFD_RELOC_ALPHA_BOH:
1801 gas_assert (size >= 1 && size <= 4);
1804 pcrel = reloc_howto->pc_relative;
1807 fixP = fix_new_exp (frag_now, f - frag_now->fr_literal, size,
1808 &fixup->exp, pcrel, (bfd_reloc_code_real_type) fixup->reloc);
1810 /* Turn off complaints that the addend is too large for some fixups,
1811 and copy in the sequence number for the explicit relocations. */
1812 switch (fixup->reloc)
1814 case BFD_RELOC_ALPHA_HINT:
1815 case BFD_RELOC_GPREL32:
1816 case BFD_RELOC_GPREL16:
1817 case BFD_RELOC_ALPHA_GPREL_HI16:
1818 case BFD_RELOC_ALPHA_GPREL_LO16:
1819 case BFD_RELOC_ALPHA_GOTDTPREL16:
1820 case BFD_RELOC_ALPHA_DTPREL_HI16:
1821 case BFD_RELOC_ALPHA_DTPREL_LO16:
1822 case BFD_RELOC_ALPHA_DTPREL16:
1823 case BFD_RELOC_ALPHA_GOTTPREL16:
1824 case BFD_RELOC_ALPHA_TPREL_HI16:
1825 case BFD_RELOC_ALPHA_TPREL_LO16:
1826 case BFD_RELOC_ALPHA_TPREL16:
1827 fixP->fx_no_overflow = 1;
1830 case BFD_RELOC_ALPHA_GPDISP_HI16:
1831 fixP->fx_no_overflow = 1;
1832 fixP->fx_addsy = section_symbol (now_seg);
1833 fixP->fx_offset = 0;
1835 info = get_alpha_reloc_tag (insn->sequence);
1836 if (++info->n_master > 1)
1837 as_bad (_("too many ldah insns for !gpdisp!%ld"), insn->sequence);
1838 if (info->segment != now_seg)
1839 as_bad (_("both insns for !gpdisp!%ld must be in the same section"),
1841 fixP->tc_fix_data.info = info;
1844 case BFD_RELOC_ALPHA_GPDISP_LO16:
1845 fixP->fx_no_overflow = 1;
1847 info = get_alpha_reloc_tag (insn->sequence);
1848 if (++info->n_slaves > 1)
1849 as_bad (_("too many lda insns for !gpdisp!%ld"), insn->sequence);
1850 if (info->segment != now_seg)
1851 as_bad (_("both insns for !gpdisp!%ld must be in the same section"),
1853 fixP->tc_fix_data.info = info;
1854 info->slaves = fixP;
1857 case BFD_RELOC_ALPHA_LITERAL:
1858 case BFD_RELOC_ALPHA_ELF_LITERAL:
1859 fixP->fx_no_overflow = 1;
1861 if (insn->sequence == 0)
1863 info = get_alpha_reloc_tag (insn->sequence);
1864 info->master = fixP;
1866 if (info->segment != now_seg)
1867 info->multi_section_p = 1;
1868 fixP->tc_fix_data.info = info;
1872 case DUMMY_RELOC_LITUSE_ADDR:
1873 fixP->fx_offset = LITUSE_ALPHA_ADDR;
1875 case DUMMY_RELOC_LITUSE_BASE:
1876 fixP->fx_offset = LITUSE_ALPHA_BASE;
1878 case DUMMY_RELOC_LITUSE_BYTOFF:
1879 fixP->fx_offset = LITUSE_ALPHA_BYTOFF;
1881 case DUMMY_RELOC_LITUSE_JSR:
1882 fixP->fx_offset = LITUSE_ALPHA_JSR;
1884 case DUMMY_RELOC_LITUSE_TLSGD:
1885 fixP->fx_offset = LITUSE_ALPHA_TLSGD;
1887 case DUMMY_RELOC_LITUSE_TLSLDM:
1888 fixP->fx_offset = LITUSE_ALPHA_TLSLDM;
1890 case DUMMY_RELOC_LITUSE_JSRDIRECT:
1891 fixP->fx_offset = LITUSE_ALPHA_JSRDIRECT;
1894 fixP->fx_addsy = section_symbol (now_seg);
1895 fixP->fx_r_type = BFD_RELOC_ALPHA_LITUSE;
1897 info = get_alpha_reloc_tag (insn->sequence);
1898 if (fixup->reloc == DUMMY_RELOC_LITUSE_TLSGD)
1899 info->saw_lu_tlsgd = 1;
1900 else if (fixup->reloc == DUMMY_RELOC_LITUSE_TLSLDM)
1901 info->saw_lu_tlsldm = 1;
1902 if (++info->n_slaves > 1)
1904 if (info->saw_lu_tlsgd)
1905 as_bad (_("too many lituse insns for !lituse_tlsgd!%ld"),
1907 else if (info->saw_lu_tlsldm)
1908 as_bad (_("too many lituse insns for !lituse_tlsldm!%ld"),
1911 fixP->tc_fix_data.info = info;
1912 fixP->tc_fix_data.next_reloc = info->slaves;
1913 info->slaves = fixP;
1914 if (info->segment != now_seg)
1915 info->multi_section_p = 1;
1918 case BFD_RELOC_ALPHA_TLSGD:
1919 fixP->fx_no_overflow = 1;
1921 if (insn->sequence == 0)
1923 info = get_alpha_reloc_tag (insn->sequence);
1924 if (info->saw_tlsgd)
1925 as_bad (_("duplicate !tlsgd!%ld"), insn->sequence);
1926 else if (info->saw_tlsldm)
1927 as_bad (_("sequence number in use for !tlsldm!%ld"),
1930 info->saw_tlsgd = 1;
1931 fixP->tc_fix_data.info = info;
1934 case BFD_RELOC_ALPHA_TLSLDM:
1935 fixP->fx_no_overflow = 1;
1937 if (insn->sequence == 0)
1939 info = get_alpha_reloc_tag (insn->sequence);
1940 if (info->saw_tlsldm)
1941 as_bad (_("duplicate !tlsldm!%ld"), insn->sequence);
1942 else if (info->saw_tlsgd)
1943 as_bad (_("sequence number in use for !tlsgd!%ld"),
1946 info->saw_tlsldm = 1;
1947 fixP->tc_fix_data.info = info;
1951 case BFD_RELOC_ALPHA_NOP:
1952 case BFD_RELOC_ALPHA_LDA:
1953 case BFD_RELOC_ALPHA_BSR:
1954 case BFD_RELOC_ALPHA_BOH:
1955 info = get_alpha_reloc_tag (next_sequence_num--);
1956 fixP->tc_fix_data.info = info;
1957 fixP->tc_fix_data.info->sym = fixup->xtrasym;
1958 fixP->tc_fix_data.info->psym = fixup->procsym;
1963 if ((int) fixup->reloc < 0)
1965 if (operand->flags & AXP_OPERAND_NOOVERFLOW)
1966 fixP->fx_no_overflow = 1;
1973 /* Insert an operand value into an instruction. */
1976 insert_operand (unsigned insn,
1977 const struct alpha_operand *operand,
1982 if (operand->bits != 32 && !(operand->flags & AXP_OPERAND_NOOVERFLOW))
1986 if (operand->flags & AXP_OPERAND_SIGNED)
1988 max = (1 << (operand->bits - 1)) - 1;
1989 min = -(1 << (operand->bits - 1));
1993 max = (1 << operand->bits) - 1;
1997 if (val < min || val > max)
1998 as_warn_value_out_of_range (_("operand"), val, min, max, file, line);
2001 if (operand->insert)
2003 const char *errmsg = NULL;
2005 insn = (*operand->insert) (insn, val, &errmsg);
2007 as_warn ("%s", errmsg);
2010 insn |= ((val & ((1 << operand->bits) - 1)) << operand->shift);
2015 /* Turn an opcode description and a set of arguments into
2016 an instruction and a fixup. */
2019 assemble_insn (const struct alpha_opcode *opcode,
2020 const expressionS *tok,
2022 struct alpha_insn *insn,
2023 extended_bfd_reloc_code_real_type reloc)
2025 const struct alpha_operand *reloc_operand = NULL;
2026 const expressionS *reloc_exp = NULL;
2027 const unsigned char *argidx;
2031 memset (insn, 0, sizeof (*insn));
2032 image = opcode->opcode;
2034 for (argidx = opcode->operands; *argidx; ++argidx)
2036 const struct alpha_operand *operand = &alpha_operands[*argidx];
2037 const expressionS *t = (const expressionS *) 0;
2039 if (operand->flags & AXP_OPERAND_FAKE)
2041 /* Fake operands take no value and generate no fixup. */
2042 image = insert_operand (image, operand, 0, NULL, 0);
2048 switch (operand->flags & AXP_OPERAND_OPTIONAL_MASK)
2050 case AXP_OPERAND_DEFAULT_FIRST:
2053 case AXP_OPERAND_DEFAULT_SECOND:
2056 case AXP_OPERAND_DEFAULT_ZERO:
2058 static expressionS zero_exp;
2060 zero_exp.X_op = O_constant;
2061 zero_exp.X_unsigned = 1;
2076 image = insert_operand (image, operand, regno (t->X_add_number),
2081 image = insert_operand (image, operand, t->X_add_number, NULL, 0);
2082 gas_assert (reloc_operand == NULL);
2083 reloc_operand = operand;
2088 /* This is only 0 for fields that should contain registers,
2089 which means this pattern shouldn't have matched. */
2090 if (operand->default_reloc == 0)
2093 /* There is one special case for which an insn receives two
2094 relocations, and thus the user-supplied reloc does not
2095 override the operand reloc. */
2096 if (operand->default_reloc == BFD_RELOC_ALPHA_HINT)
2098 struct alpha_fixup *fixup;
2100 if (insn->nfixups >= MAX_INSN_FIXUPS)
2101 as_fatal (_("too many fixups"));
2103 fixup = &insn->fixups[insn->nfixups++];
2105 fixup->reloc = BFD_RELOC_ALPHA_HINT;
2109 if (reloc == BFD_RELOC_UNUSED)
2110 reloc = operand->default_reloc;
2112 gas_assert (reloc_operand == NULL);
2113 reloc_operand = operand;
2120 if (reloc != BFD_RELOC_UNUSED)
2122 struct alpha_fixup *fixup;
2124 if (insn->nfixups >= MAX_INSN_FIXUPS)
2125 as_fatal (_("too many fixups"));
2127 /* ??? My but this is hacky. But the OSF/1 assembler uses the same
2128 relocation tag for both ldah and lda with gpdisp. Choose the
2129 correct internal relocation based on the opcode. */
2130 if (reloc == BFD_RELOC_ALPHA_GPDISP)
2132 if (strcmp (opcode->name, "ldah") == 0)
2133 reloc = BFD_RELOC_ALPHA_GPDISP_HI16;
2134 else if (strcmp (opcode->name, "lda") == 0)
2135 reloc = BFD_RELOC_ALPHA_GPDISP_LO16;
2137 as_bad (_("invalid relocation for instruction"));
2140 /* If this is a real relocation (as opposed to a lituse hint), then
2141 the relocation width should match the operand width.
2142 Take care of -MDISP in operand table. */
2143 else if (reloc < BFD_RELOC_UNUSED && reloc > 0)
2145 reloc_howto_type *reloc_howto
2146 = bfd_reloc_type_lookup (stdoutput,
2147 (bfd_reloc_code_real_type) reloc);
2148 if (reloc_operand == NULL
2149 || reloc_howto->bitsize != reloc_operand->bits)
2151 as_bad (_("invalid relocation for field"));
2156 fixup = &insn->fixups[insn->nfixups++];
2158 fixup->exp = *reloc_exp;
2160 fixup->exp.X_op = O_absent;
2161 fixup->reloc = reloc;
2167 /* Handle all "simple" integer register loads -- ldq, ldq_l, ldq_u,
2168 etc. They differ from the real instructions in that they do simple
2169 expressions like the lda macro. */
2172 emit_ir_load (const expressionS *tok,
2174 const void * opname)
2178 expressionS newtok[3];
2179 struct alpha_insn insn;
2181 = tok[1].X_add_symbol ? S_GET_NAME (tok[1].X_add_symbol): "";
2182 int symlen = strlen (symname);
2185 basereg = (tok[1].X_op == O_constant ? AXP_REG_ZERO : alpha_gp_register);
2187 basereg = tok[2].X_add_number;
2189 lituse = load_expression (tok[0].X_add_number, &tok[1],
2190 &basereg, &newtok[1], (const char *) opname);
2192 if (basereg == alpha_gp_register &&
2193 (symlen > 4 && strcmp (&symname [symlen - 4], "..lk") == 0))
2197 set_tok_preg (newtok[2], basereg);
2199 assemble_tokens_to_insn ((const char *) opname, newtok, 3, &insn);
2203 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2204 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2205 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2207 insn.sequence = lituse;
2213 /* Handle fp register loads, and both integer and fp register stores.
2214 Again, we handle simple expressions. */
2217 emit_loadstore (const expressionS *tok,
2219 const void * opname)
2223 expressionS newtok[3];
2224 struct alpha_insn insn;
2227 basereg = (tok[1].X_op == O_constant ? AXP_REG_ZERO : alpha_gp_register);
2229 basereg = tok[2].X_add_number;
2231 if (tok[1].X_op != O_constant || !range_signed_16 (tok[1].X_add_number))
2234 as_bad (_("macro requires $at register while noat in effect"));
2236 lituse = load_expression (AXP_REG_AT, &tok[1],
2237 &basereg, &newtok[1], (const char *) opname);
2246 set_tok_preg (newtok[2], basereg);
2248 assemble_tokens_to_insn ((const char *) opname, newtok, 3, &insn);
2252 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2253 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2254 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2256 insn.sequence = lituse;
2262 /* Load a half-word or byte as an unsigned value. */
2265 emit_ldXu (const expressionS *tok,
2267 const void * vlgsize)
2269 if (alpha_target & AXP_OPCODE_BWX)
2270 emit_ir_load (tok, ntok, ldXu_op[(long) vlgsize]);
2273 expressionS newtok[3];
2274 struct alpha_insn insn;
2279 as_bad (_("macro requires $at register while noat in effect"));
2282 basereg = (tok[1].X_op == O_constant
2283 ? AXP_REG_ZERO : alpha_gp_register);
2285 basereg = tok[2].X_add_number;
2287 /* Emit "lda $at, exp". */
2288 lituse = load_expression (AXP_REG_AT, &tok[1], &basereg, NULL, "lda");
2290 /* Emit "ldq_u targ, 0($at)". */
2292 set_tok_const (newtok[1], 0);
2293 set_tok_preg (newtok[2], basereg);
2294 assemble_tokens_to_insn ("ldq_u", newtok, 3, &insn);
2298 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2299 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2300 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2302 insn.sequence = lituse;
2307 /* Emit "extXl targ, $at, targ". */
2308 set_tok_reg (newtok[1], basereg);
2309 newtok[2] = newtok[0];
2310 assemble_tokens_to_insn (extXl_op[(long) vlgsize], newtok, 3, &insn);
2314 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2315 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BYTOFF;
2316 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2318 insn.sequence = lituse;
2325 /* Load a half-word or byte as a signed value. */
2328 emit_ldX (const expressionS *tok,
2330 const void * vlgsize)
2332 emit_ldXu (tok, ntok, vlgsize);
2333 assemble_tokens (sextX_op[(long) vlgsize], tok, 1, 1);
2336 /* Load an integral value from an unaligned address as an unsigned
2340 emit_uldXu (const expressionS *tok,
2342 const void * vlgsize)
2344 long lgsize = (long) vlgsize;
2345 expressionS newtok[3];
2348 as_bad (_("macro requires $at register while noat in effect"));
2350 /* Emit "lda $at, exp". */
2351 memcpy (newtok, tok, sizeof (expressionS) * ntok);
2352 newtok[0].X_add_number = AXP_REG_AT;
2353 assemble_tokens ("lda", newtok, ntok, 1);
2355 /* Emit "ldq_u $t9, 0($at)". */
2356 set_tok_reg (newtok[0], AXP_REG_T9);
2357 set_tok_const (newtok[1], 0);
2358 set_tok_preg (newtok[2], AXP_REG_AT);
2359 assemble_tokens ("ldq_u", newtok, 3, 1);
2361 /* Emit "ldq_u $t10, size-1($at)". */
2362 set_tok_reg (newtok[0], AXP_REG_T10);
2363 set_tok_const (newtok[1], (1 << lgsize) - 1);
2364 assemble_tokens ("ldq_u", newtok, 3, 1);
2366 /* Emit "extXl $t9, $at, $t9". */
2367 set_tok_reg (newtok[0], AXP_REG_T9);
2368 set_tok_reg (newtok[1], AXP_REG_AT);
2369 set_tok_reg (newtok[2], AXP_REG_T9);
2370 assemble_tokens (extXl_op[lgsize], newtok, 3, 1);
2372 /* Emit "extXh $t10, $at, $t10". */
2373 set_tok_reg (newtok[0], AXP_REG_T10);
2374 set_tok_reg (newtok[2], AXP_REG_T10);
2375 assemble_tokens (extXh_op[lgsize], newtok, 3, 1);
2377 /* Emit "or $t9, $t10, targ". */
2378 set_tok_reg (newtok[0], AXP_REG_T9);
2379 set_tok_reg (newtok[1], AXP_REG_T10);
2381 assemble_tokens ("or", newtok, 3, 1);
2384 /* Load an integral value from an unaligned address as a signed value.
2385 Note that quads should get funneled to the unsigned load since we
2386 don't have to do the sign extension. */
2389 emit_uldX (const expressionS *tok,
2391 const void * vlgsize)
2393 emit_uldXu (tok, ntok, vlgsize);
2394 assemble_tokens (sextX_op[(long) vlgsize], tok, 1, 1);
2397 /* Implement the ldil macro. */
2400 emit_ldil (const expressionS *tok,
2402 const void * unused ATTRIBUTE_UNUSED)
2404 expressionS newtok[2];
2406 memcpy (newtok, tok, sizeof (newtok));
2407 newtok[1].X_add_number = sign_extend_32 (tok[1].X_add_number);
2409 assemble_tokens ("lda", newtok, ntok, 1);
2412 /* Store a half-word or byte. */
2415 emit_stX (const expressionS *tok,
2417 const void * vlgsize)
2419 int lgsize = (int) (long) vlgsize;
2421 if (alpha_target & AXP_OPCODE_BWX)
2422 emit_loadstore (tok, ntok, stX_op[lgsize]);
2425 expressionS newtok[3];
2426 struct alpha_insn insn;
2431 as_bad (_("macro requires $at register while noat in effect"));
2434 basereg = (tok[1].X_op == O_constant
2435 ? AXP_REG_ZERO : alpha_gp_register);
2437 basereg = tok[2].X_add_number;
2439 /* Emit "lda $at, exp". */
2440 lituse = load_expression (AXP_REG_AT, &tok[1], &basereg, NULL, "lda");
2442 /* Emit "ldq_u $t9, 0($at)". */
2443 set_tok_reg (newtok[0], AXP_REG_T9);
2444 set_tok_const (newtok[1], 0);
2445 set_tok_preg (newtok[2], basereg);
2446 assemble_tokens_to_insn ("ldq_u", newtok, 3, &insn);
2450 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2451 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2452 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2454 insn.sequence = lituse;
2459 /* Emit "insXl src, $at, $t10". */
2461 set_tok_reg (newtok[1], basereg);
2462 set_tok_reg (newtok[2], AXP_REG_T10);
2463 assemble_tokens_to_insn (insXl_op[lgsize], newtok, 3, &insn);
2467 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2468 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BYTOFF;
2469 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2471 insn.sequence = lituse;
2476 /* Emit "mskXl $t9, $at, $t9". */
2477 set_tok_reg (newtok[0], AXP_REG_T9);
2478 newtok[2] = newtok[0];
2479 assemble_tokens_to_insn (mskXl_op[lgsize], newtok, 3, &insn);
2483 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2484 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BYTOFF;
2485 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2487 insn.sequence = lituse;
2492 /* Emit "or $t9, $t10, $t9". */
2493 set_tok_reg (newtok[1], AXP_REG_T10);
2494 assemble_tokens ("or", newtok, 3, 1);
2496 /* Emit "stq_u $t9, 0($at). */
2497 set_tok_const(newtok[1], 0);
2498 set_tok_preg (newtok[2], AXP_REG_AT);
2499 assemble_tokens_to_insn ("stq_u", newtok, 3, &insn);
2503 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2504 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2505 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2507 insn.sequence = lituse;
2514 /* Store an integer to an unaligned address. */
2517 emit_ustX (const expressionS *tok,
2519 const void * vlgsize)
2521 int lgsize = (int) (long) vlgsize;
2522 expressionS newtok[3];
2524 /* Emit "lda $at, exp". */
2525 memcpy (newtok, tok, sizeof (expressionS) * ntok);
2526 newtok[0].X_add_number = AXP_REG_AT;
2527 assemble_tokens ("lda", newtok, ntok, 1);
2529 /* Emit "ldq_u $9, 0($at)". */
2530 set_tok_reg (newtok[0], AXP_REG_T9);
2531 set_tok_const (newtok[1], 0);
2532 set_tok_preg (newtok[2], AXP_REG_AT);
2533 assemble_tokens ("ldq_u", newtok, 3, 1);
2535 /* Emit "ldq_u $10, size-1($at)". */
2536 set_tok_reg (newtok[0], AXP_REG_T10);
2537 set_tok_const (newtok[1], (1 << lgsize) - 1);
2538 assemble_tokens ("ldq_u", newtok, 3, 1);
2540 /* Emit "insXl src, $at, $t11". */
2542 set_tok_reg (newtok[1], AXP_REG_AT);
2543 set_tok_reg (newtok[2], AXP_REG_T11);
2544 assemble_tokens (insXl_op[lgsize], newtok, 3, 1);
2546 /* Emit "insXh src, $at, $t12". */
2547 set_tok_reg (newtok[2], AXP_REG_T12);
2548 assemble_tokens (insXh_op[lgsize], newtok, 3, 1);
2550 /* Emit "mskXl $t9, $at, $t9". */
2551 set_tok_reg (newtok[0], AXP_REG_T9);
2552 newtok[2] = newtok[0];
2553 assemble_tokens (mskXl_op[lgsize], newtok, 3, 1);
2555 /* Emit "mskXh $t10, $at, $t10". */
2556 set_tok_reg (newtok[0], AXP_REG_T10);
2557 newtok[2] = newtok[0];
2558 assemble_tokens (mskXh_op[lgsize], newtok, 3, 1);
2560 /* Emit "or $t9, $t11, $t9". */
2561 set_tok_reg (newtok[0], AXP_REG_T9);
2562 set_tok_reg (newtok[1], AXP_REG_T11);
2563 newtok[2] = newtok[0];
2564 assemble_tokens ("or", newtok, 3, 1);
2566 /* Emit "or $t10, $t12, $t10". */
2567 set_tok_reg (newtok[0], AXP_REG_T10);
2568 set_tok_reg (newtok[1], AXP_REG_T12);
2569 newtok[2] = newtok[0];
2570 assemble_tokens ("or", newtok, 3, 1);
2572 /* Emit "stq_u $t10, size-1($at)". */
2573 set_tok_reg (newtok[0], AXP_REG_T10);
2574 set_tok_const (newtok[1], (1 << lgsize) - 1);
2575 set_tok_preg (newtok[2], AXP_REG_AT);
2576 assemble_tokens ("stq_u", newtok, 3, 1);
2578 /* Emit "stq_u $t9, 0($at)". */
2579 set_tok_reg (newtok[0], AXP_REG_T9);
2580 set_tok_const (newtok[1], 0);
2581 assemble_tokens ("stq_u", newtok, 3, 1);
2584 /* Sign extend a half-word or byte. The 32-bit sign extend is
2585 implemented as "addl $31, $r, $t" in the opcode table. */
2588 emit_sextX (const expressionS *tok,
2590 const void * vlgsize)
2592 long lgsize = (long) vlgsize;
2594 if (alpha_target & AXP_OPCODE_BWX)
2595 assemble_tokens (sextX_op[lgsize], tok, ntok, 0);
2598 int bitshift = 64 - 8 * (1 << lgsize);
2599 expressionS newtok[3];
2601 /* Emit "sll src,bits,dst". */
2603 set_tok_const (newtok[1], bitshift);
2604 newtok[2] = tok[ntok - 1];
2605 assemble_tokens ("sll", newtok, 3, 1);
2607 /* Emit "sra dst,bits,dst". */
2608 newtok[0] = newtok[2];
2609 assemble_tokens ("sra", newtok, 3, 1);
2613 /* Implement the division and modulus macros. */
2617 /* Make register usage like in normal procedure call.
2618 Don't clobber PV and RA. */
2621 emit_division (const expressionS *tok,
2623 const void * symname)
2625 /* DIVISION and MODULUS. Yech.
2630 mov x,R16 # if x != R16
2631 mov y,R17 # if y != R17
2636 with appropriate optimizations if R0,R16,R17 are the registers
2637 specified by the compiler. */
2641 expressionS newtok[3];
2643 xr = regno (tok[0].X_add_number);
2644 yr = regno (tok[1].X_add_number);
2649 rr = regno (tok[2].X_add_number);
2651 /* Move the operands into the right place. */
2652 if (yr == AXP_REG_R16 && xr == AXP_REG_R17)
2654 /* They are in exactly the wrong order -- swap through AT. */
2656 as_bad (_("macro requires $at register while noat in effect"));
2658 set_tok_reg (newtok[0], AXP_REG_R16);
2659 set_tok_reg (newtok[1], AXP_REG_AT);
2660 assemble_tokens ("mov", newtok, 2, 1);
2662 set_tok_reg (newtok[0], AXP_REG_R17);
2663 set_tok_reg (newtok[1], AXP_REG_R16);
2664 assemble_tokens ("mov", newtok, 2, 1);
2666 set_tok_reg (newtok[0], AXP_REG_AT);
2667 set_tok_reg (newtok[1], AXP_REG_R17);
2668 assemble_tokens ("mov", newtok, 2, 1);
2672 if (yr == AXP_REG_R16)
2674 set_tok_reg (newtok[0], AXP_REG_R16);
2675 set_tok_reg (newtok[1], AXP_REG_R17);
2676 assemble_tokens ("mov", newtok, 2, 1);
2679 if (xr != AXP_REG_R16)
2681 set_tok_reg (newtok[0], xr);
2682 set_tok_reg (newtok[1], AXP_REG_R16);
2683 assemble_tokens ("mov", newtok, 2, 1);
2686 if (yr != AXP_REG_R16 && yr != AXP_REG_R17)
2688 set_tok_reg (newtok[0], yr);
2689 set_tok_reg (newtok[1], AXP_REG_R17);
2690 assemble_tokens ("mov", newtok, 2, 1);
2694 sym = symbol_find_or_make ((const char *) symname);
2696 set_tok_reg (newtok[0], AXP_REG_AT);
2697 set_tok_sym (newtok[1], sym, 0);
2698 assemble_tokens ("lda", newtok, 2, 1);
2700 /* Call the division routine. */
2701 set_tok_reg (newtok[0], AXP_REG_AT);
2702 set_tok_cpreg (newtok[1], AXP_REG_AT);
2703 set_tok_const (newtok[2], 0);
2704 assemble_tokens ("jsr", newtok, 3, 1);
2706 /* Move the result to the right place. */
2707 if (rr != AXP_REG_R0)
2709 set_tok_reg (newtok[0], AXP_REG_R0);
2710 set_tok_reg (newtok[1], rr);
2711 assemble_tokens ("mov", newtok, 2, 1);
2715 #else /* !OBJ_EVAX */
2718 emit_division (const expressionS *tok,
2720 const void * symname)
2722 /* DIVISION and MODULUS. Yech.
2732 with appropriate optimizations if t10,t11,t12 are the registers
2733 specified by the compiler. */
2737 expressionS newtok[3];
2739 xr = regno (tok[0].X_add_number);
2740 yr = regno (tok[1].X_add_number);
2745 rr = regno (tok[2].X_add_number);
2747 sym = symbol_find_or_make ((const char *) symname);
2749 /* Move the operands into the right place. */
2750 if (yr == AXP_REG_T10 && xr == AXP_REG_T11)
2752 /* They are in exactly the wrong order -- swap through AT. */
2754 as_bad (_("macro requires $at register while noat in effect"));
2756 set_tok_reg (newtok[0], AXP_REG_T10);
2757 set_tok_reg (newtok[1], AXP_REG_AT);
2758 assemble_tokens ("mov", newtok, 2, 1);
2760 set_tok_reg (newtok[0], AXP_REG_T11);
2761 set_tok_reg (newtok[1], AXP_REG_T10);
2762 assemble_tokens ("mov", newtok, 2, 1);
2764 set_tok_reg (newtok[0], AXP_REG_AT);
2765 set_tok_reg (newtok[1], AXP_REG_T11);
2766 assemble_tokens ("mov", newtok, 2, 1);
2770 if (yr == AXP_REG_T10)
2772 set_tok_reg (newtok[0], AXP_REG_T10);
2773 set_tok_reg (newtok[1], AXP_REG_T11);
2774 assemble_tokens ("mov", newtok, 2, 1);
2777 if (xr != AXP_REG_T10)
2779 set_tok_reg (newtok[0], xr);
2780 set_tok_reg (newtok[1], AXP_REG_T10);
2781 assemble_tokens ("mov", newtok, 2, 1);
2784 if (yr != AXP_REG_T10 && yr != AXP_REG_T11)
2786 set_tok_reg (newtok[0], yr);
2787 set_tok_reg (newtok[1], AXP_REG_T11);
2788 assemble_tokens ("mov", newtok, 2, 1);
2792 /* Call the division routine. */
2793 set_tok_reg (newtok[0], AXP_REG_T9);
2794 set_tok_sym (newtok[1], sym, 0);
2795 assemble_tokens ("jsr", newtok, 2, 1);
2797 /* Reload the GP register. */
2801 #if defined(OBJ_ECOFF) || defined(OBJ_ELF)
2802 set_tok_reg (newtok[0], alpha_gp_register);
2803 set_tok_const (newtok[1], 0);
2804 set_tok_preg (newtok[2], AXP_REG_T9);
2805 assemble_tokens ("ldgp", newtok, 3, 1);
2808 /* Move the result to the right place. */
2809 if (rr != AXP_REG_T12)
2811 set_tok_reg (newtok[0], AXP_REG_T12);
2812 set_tok_reg (newtok[1], rr);
2813 assemble_tokens ("mov", newtok, 2, 1);
2817 #endif /* !OBJ_EVAX */
2819 /* The jsr and jmp macros differ from their instruction counterparts
2820 in that they can load the target address and default most
2824 emit_jsrjmp (const expressionS *tok,
2826 const void * vopname)
2828 const char *opname = (const char *) vopname;
2829 struct alpha_insn insn;
2830 expressionS newtok[3];
2834 if (tokidx < ntok && tok[tokidx].X_op == O_register)
2835 r = regno (tok[tokidx++].X_add_number);
2837 r = strcmp (opname, "jmp") == 0 ? AXP_REG_ZERO : AXP_REG_RA;
2839 set_tok_reg (newtok[0], r);
2841 if (tokidx < ntok &&
2842 (tok[tokidx].X_op == O_pregister || tok[tokidx].X_op == O_cpregister))
2843 r = regno (tok[tokidx++].X_add_number);
2845 /* Keep register if jsr $n.<sym>. */
2849 int basereg = alpha_gp_register;
2850 lituse = load_expression (r = AXP_REG_PV, &tok[tokidx],
2851 &basereg, NULL, opname);
2855 set_tok_cpreg (newtok[1], r);
2859 newtok[2] = tok[tokidx];
2862 set_tok_const (newtok[2], 0);
2864 assemble_tokens_to_insn (opname, newtok, 3, &insn);
2868 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2869 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_JSR;
2870 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2872 insn.sequence = lituse;
2876 if (alpha_flag_replace
2878 && tok[tokidx].X_add_symbol
2879 && alpha_linkage_symbol)
2881 /* Create a BOH reloc for 'jsr $27,NAME'. */
2882 const char *symname = S_GET_NAME (tok[tokidx].X_add_symbol);
2883 int symlen = strlen (symname);
2886 /* Build the entry name as 'NAME..en'. */
2887 ensymname = (char *) alloca (symlen + 5);
2888 memcpy (ensymname, symname, symlen);
2889 memcpy (ensymname + symlen, "..en", 5);
2891 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2892 if (insn.nfixups > 0)
2894 memmove (&insn.fixups[1], &insn.fixups[0],
2895 sizeof(struct alpha_fixup) * insn.nfixups);
2898 /* The fixup must be the same as the BFD_RELOC_ALPHA_NOP
2899 case in load_expression. See B.4.5.2 of the OpenVMS
2900 Linker Utility Manual. */
2901 insn.fixups[0].reloc = BFD_RELOC_ALPHA_BOH;
2902 insn.fixups[0].exp.X_op = O_symbol;
2903 insn.fixups[0].exp.X_add_symbol = symbol_find_or_make (ensymname);
2904 insn.fixups[0].exp.X_add_number = 0;
2905 insn.fixups[0].xtrasym = alpha_linkage_symbol;
2906 insn.fixups[0].procsym = alpha_evax_proc->symbol;
2908 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 the basesym - linksym expression (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);
3423 (frag_now, p - frag_now->fr_literal, 8, sym, addend, 0, BFD_RELOC_64);
3424 fixp->tc_fix_data.info = get_alpha_reloc_tag (next_sequence_num--);
3425 fixp->tc_fix_data.info->sym = expsym;
3427 subseg_set (current_section, current_subsec);
3430 #endif /* OBJ_EVAX */
3432 /* Assembler directives. */
3434 /* Handle the .text pseudo-op. This is like the usual one, but it
3435 clears alpha_insn_label and restores auto alignment. */
3438 s_alpha_text (int i)
3449 symbolP = symbol_find (".text");
3450 if (symbolP == NULL)
3452 symbolP = symbol_make (".text");
3453 S_SET_SEGMENT (symbolP, text_section);
3454 symbol_table_insert (symbolP);
3458 alpha_insn_label = NULL;
3459 alpha_auto_align_on = 1;
3460 alpha_current_align = 0;
3463 /* Handle the .data pseudo-op. This is like the usual one, but it
3464 clears alpha_insn_label and restores auto alignment. */
3467 s_alpha_data (int i)
3474 alpha_insn_label = NULL;
3475 alpha_auto_align_on = 1;
3476 alpha_current_align = 0;
3479 #if defined (OBJ_ECOFF) || defined (OBJ_EVAX)
3481 /* Handle the OSF/1 and openVMS .comm pseudo quirks. */
3484 s_alpha_comm (int ignore ATTRIBUTE_UNUSED)
3496 name = input_line_pointer;
3497 c = get_symbol_end ();
3499 /* Just after name is now '\0'. */
3500 p = input_line_pointer;
3505 /* Alpha OSF/1 compiler doesn't provide the comma, gcc does. */
3506 if (*input_line_pointer == ',')
3508 input_line_pointer++;
3511 if ((size = get_absolute_expression ()) < 0)
3513 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size);
3514 ignore_rest_of_line ();
3519 symbolP = symbol_find_or_make (name);
3522 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
3524 as_bad (_("Ignoring attempt to re-define symbol"));
3525 ignore_rest_of_line ();
3530 if (*input_line_pointer != ',')
3531 temp = 8; /* Default alignment. */
3534 input_line_pointer++;
3536 temp = get_absolute_expression ();
3539 /* ??? Unlike on OSF/1, the alignment factor is not in log units. */
3540 while ((temp >>= 1) != 0)
3543 if (*input_line_pointer == ',')
3545 /* Extended form of the directive
3547 .comm symbol, size, alignment, section
3549 where the "common" semantics is transferred to the section.
3550 The symbol is effectively an alias for the section name. */
3554 symbolS *sec_symbol;
3555 segT current_seg = now_seg;
3556 subsegT current_subseg = now_subseg;
3559 input_line_pointer++;
3561 sec_name = s_alpha_section_name ();
3562 sec_symbol = symbol_find_or_make (sec_name);
3563 sec = subseg_new (sec_name, 0);
3564 S_SET_SEGMENT (sec_symbol, sec);
3565 symbol_get_bfdsym (sec_symbol)->flags |= BSF_SECTION_SYM;
3566 bfd_vms_set_section_flags (stdoutput, sec, 0,
3567 EGPS__V_OVR | EGPS__V_GBL | EGPS__V_NOMOD);
3568 record_alignment (sec, log_align);
3570 /* Reuse stab_string_size to store the size of the section. */
3571 cur_size = seg_info (sec)->stabu.stab_string_size;
3572 if ((int) size > cur_size)
3575 = frag_var (rs_fill, 1, 1, (relax_substateT)0, NULL,
3576 (valueT)size - (valueT)cur_size, NULL);
3578 seg_info (sec)->stabu.stab_string_size = (int)size;
3581 S_SET_SEGMENT (symbolP, sec);
3583 subseg_set (current_seg, current_subseg);
3587 /* Regular form of the directive
3589 .comm symbol, size, alignment
3591 where the "common" semantics in on the symbol.
3592 These symbols are assembled in the .bss section. */
3595 segT current_seg = now_seg;
3596 subsegT current_subseg = now_subseg;
3598 subseg_set (bss_section, 1);
3599 frag_align (log_align, 0, 0);
3600 record_alignment (bss_section, log_align);
3602 symbolP->sy_frag = frag_now;
3603 pfrag = frag_var (rs_org, 1, 1, (relax_substateT)0, symbolP,
3607 S_SET_SEGMENT (symbolP, bss_section);
3609 subseg_set (current_seg, current_subseg);
3613 if (S_GET_VALUE (symbolP))
3615 if (S_GET_VALUE (symbolP) != (valueT) size)
3616 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
3617 S_GET_NAME (symbolP),
3618 (long) S_GET_VALUE (symbolP),
3624 S_SET_VALUE (symbolP, (valueT) size);
3626 S_SET_EXTERNAL (symbolP);
3630 know (symbolP->sy_frag == &zero_address_frag);
3632 demand_empty_rest_of_line ();
3635 #endif /* ! OBJ_ELF */
3639 /* Handle the .rdata pseudo-op. This is like the usual one, but it
3640 clears alpha_insn_label and restores auto alignment. */
3643 s_alpha_rdata (int ignore ATTRIBUTE_UNUSED)
3645 get_absolute_expression ();
3646 subseg_new (".rdata", 0);
3647 demand_empty_rest_of_line ();
3648 alpha_insn_label = NULL;
3649 alpha_auto_align_on = 1;
3650 alpha_current_align = 0;
3657 /* Handle the .sdata pseudo-op. This is like the usual one, but it
3658 clears alpha_insn_label and restores auto alignment. */
3661 s_alpha_sdata (int ignore ATTRIBUTE_UNUSED)
3663 get_absolute_expression ();
3664 subseg_new (".sdata", 0);
3665 demand_empty_rest_of_line ();
3666 alpha_insn_label = NULL;
3667 alpha_auto_align_on = 1;
3668 alpha_current_align = 0;
3673 struct alpha_elf_frame_data
3676 symbolS *func_end_sym;
3677 symbolS *prologue_sym;
3683 offsetT mask_offset;
3684 offsetT fmask_offset;
3686 struct alpha_elf_frame_data *next;
3689 static struct alpha_elf_frame_data *all_frame_data;
3690 static struct alpha_elf_frame_data **plast_frame_data = &all_frame_data;
3691 static struct alpha_elf_frame_data *cur_frame_data;
3693 /* Handle the .section pseudo-op. This is like the usual one, but it
3694 clears alpha_insn_label and restores auto alignment. */
3697 s_alpha_section (int ignore ATTRIBUTE_UNUSED)
3699 obj_elf_section (ignore);
3701 alpha_insn_label = NULL;
3702 alpha_auto_align_on = 1;
3703 alpha_current_align = 0;
3707 s_alpha_ent (int dummy ATTRIBUTE_UNUSED)
3709 if (ECOFF_DEBUGGING)
3710 ecoff_directive_ent (0);
3713 char *name, name_end;
3714 name = input_line_pointer;
3715 name_end = get_symbol_end ();
3717 if (! is_name_beginner (*name))
3719 as_warn (_(".ent directive has no name"));
3720 *input_line_pointer = name_end;
3727 as_warn (_("nested .ent directives"));
3729 sym = symbol_find_or_make (name);
3730 symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
3732 cur_frame_data = (struct alpha_elf_frame_data *)
3733 calloc (1, sizeof (*cur_frame_data));
3734 cur_frame_data->func_sym = sym;
3736 /* Provide sensible defaults. */
3737 cur_frame_data->fp_regno = 30; /* sp */
3738 cur_frame_data->ra_regno = 26; /* ra */
3740 *plast_frame_data = cur_frame_data;
3741 plast_frame_data = &cur_frame_data->next;
3743 /* The .ent directive is sometimes followed by a number. Not sure
3744 what it really means, but ignore it. */
3745 *input_line_pointer = name_end;
3747 if (*input_line_pointer == ',')
3749 input_line_pointer++;
3752 if (ISDIGIT (*input_line_pointer) || *input_line_pointer == '-')
3753 (void) get_absolute_expression ();
3755 demand_empty_rest_of_line ();
3760 s_alpha_end (int dummy ATTRIBUTE_UNUSED)
3762 if (ECOFF_DEBUGGING)
3763 ecoff_directive_end (0);
3766 char *name, name_end;
3767 name = input_line_pointer;
3768 name_end = get_symbol_end ();
3770 if (! is_name_beginner (*name))
3772 as_warn (_(".end directive has no name"));
3773 *input_line_pointer = name_end;
3779 sym = symbol_find (name);
3780 if (!cur_frame_data)
3781 as_warn (_(".end directive without matching .ent"));
3782 else if (sym != cur_frame_data->func_sym)
3783 as_warn (_(".end directive names different symbol than .ent"));
3785 /* Create an expression to calculate the size of the function. */
3786 if (sym && cur_frame_data)
3788 OBJ_SYMFIELD_TYPE *obj = symbol_get_obj (sym);
3789 expressionS *exp = (expressionS *) xmalloc (sizeof (expressionS));
3792 exp->X_op = O_subtract;
3793 exp->X_add_symbol = symbol_temp_new_now ();
3794 exp->X_op_symbol = sym;
3795 exp->X_add_number = 0;
3797 cur_frame_data->func_end_sym = exp->X_add_symbol;
3800 cur_frame_data = NULL;
3802 *input_line_pointer = name_end;
3804 demand_empty_rest_of_line ();
3809 s_alpha_mask (int fp)
3811 if (ECOFF_DEBUGGING)
3814 ecoff_directive_fmask (0);
3816 ecoff_directive_mask (0);
3823 if (!cur_frame_data)
3826 as_warn (_(".fmask outside of .ent"));
3828 as_warn (_(".mask outside of .ent"));
3829 discard_rest_of_line ();
3833 if (get_absolute_expression_and_terminator (&val) != ',')
3836 as_warn (_("bad .fmask directive"));
3838 as_warn (_("bad .mask directive"));
3839 --input_line_pointer;
3840 discard_rest_of_line ();
3844 offset = get_absolute_expression ();
3845 demand_empty_rest_of_line ();
3849 cur_frame_data->fmask = val;
3850 cur_frame_data->fmask_offset = offset;
3854 cur_frame_data->mask = val;
3855 cur_frame_data->mask_offset = offset;
3861 s_alpha_frame (int dummy ATTRIBUTE_UNUSED)
3863 if (ECOFF_DEBUGGING)
3864 ecoff_directive_frame (0);
3869 if (!cur_frame_data)
3871 as_warn (_(".frame outside of .ent"));
3872 discard_rest_of_line ();
3876 cur_frame_data->fp_regno = tc_get_register (1);
3879 if (*input_line_pointer++ != ','
3880 || get_absolute_expression_and_terminator (&val) != ',')
3882 as_warn (_("bad .frame directive"));
3883 --input_line_pointer;
3884 discard_rest_of_line ();
3887 cur_frame_data->frame_size = val;
3889 cur_frame_data->ra_regno = tc_get_register (0);
3891 /* Next comes the "offset of saved $a0 from $sp". In gcc terms
3892 this is current_function_pretend_args_size. There's no place
3893 to put this value, so ignore it. */
3899 s_alpha_prologue (int ignore ATTRIBUTE_UNUSED)
3904 arg = get_absolute_expression ();
3905 demand_empty_rest_of_line ();
3906 alpha_prologue_label = symbol_new
3907 (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
3909 if (ECOFF_DEBUGGING)
3910 sym = ecoff_get_cur_proc_sym ();
3912 sym = cur_frame_data ? cur_frame_data->func_sym : NULL;
3916 as_bad (_(".prologue directive without a preceding .ent directive"));
3922 case 0: /* No PV required. */
3923 S_SET_OTHER (sym, STO_ALPHA_NOPV
3924 | (S_GET_OTHER (sym) & ~STO_ALPHA_STD_GPLOAD));
3926 case 1: /* Std GP load. */
3927 S_SET_OTHER (sym, STO_ALPHA_STD_GPLOAD
3928 | (S_GET_OTHER (sym) & ~STO_ALPHA_STD_GPLOAD));
3930 case 2: /* Non-std use of PV. */
3934 as_bad (_("Invalid argument %d to .prologue."), arg);
3939 cur_frame_data->prologue_sym = symbol_temp_new_now ();
3942 static char *first_file_directive;
3945 s_alpha_file (int ignore ATTRIBUTE_UNUSED)
3947 /* Save the first .file directive we see, so that we can change our
3948 minds about whether ecoff debugging should or shouldn't be enabled. */
3949 if (alpha_flag_mdebug < 0 && ! first_file_directive)
3951 char *start = input_line_pointer;
3954 discard_rest_of_line ();
3956 len = input_line_pointer - start;
3957 first_file_directive = (char *) xmalloc (len + 1);
3958 memcpy (first_file_directive, start, len);
3959 first_file_directive[len] = '\0';
3961 input_line_pointer = start;
3964 if (ECOFF_DEBUGGING)
3965 ecoff_directive_file (0);
3967 dwarf2_directive_file (0);
3971 s_alpha_loc (int ignore ATTRIBUTE_UNUSED)
3973 if (ECOFF_DEBUGGING)
3974 ecoff_directive_loc (0);
3976 dwarf2_directive_loc (0);
3980 s_alpha_stab (int n)
3982 /* If we've been undecided about mdebug, make up our minds in favour. */
3983 if (alpha_flag_mdebug < 0)
3985 segT sec = subseg_new (".mdebug", 0);
3986 bfd_set_section_flags (stdoutput, sec, SEC_HAS_CONTENTS | SEC_READONLY);
3987 bfd_set_section_alignment (stdoutput, sec, 3);
3989 ecoff_read_begin_hook ();
3991 if (first_file_directive)
3993 char *save_ilp = input_line_pointer;
3994 input_line_pointer = first_file_directive;
3995 ecoff_directive_file (0);
3996 input_line_pointer = save_ilp;
3997 free (first_file_directive);
4000 alpha_flag_mdebug = 1;
4006 s_alpha_coff_wrapper (int which)
4008 static void (* const fns[]) (int) = {
4009 ecoff_directive_begin,
4010 ecoff_directive_bend,
4011 ecoff_directive_def,
4012 ecoff_directive_dim,
4013 ecoff_directive_endef,
4014 ecoff_directive_scl,
4015 ecoff_directive_tag,
4016 ecoff_directive_val,
4019 gas_assert (which >= 0 && which < (int) (sizeof (fns)/sizeof (*fns)));
4021 if (ECOFF_DEBUGGING)
4025 as_bad (_("ECOFF debugging is disabled."));
4026 ignore_rest_of_line ();
4030 /* Called at the end of assembly. Here we emit unwind info for frames
4031 unless the compiler has done it for us. */
4034 alpha_elf_md_end (void)
4036 struct alpha_elf_frame_data *p;
4039 as_warn (_(".ent directive without matching .end"));
4041 /* If someone has generated the unwind info themselves, great. */
4042 if (bfd_get_section_by_name (stdoutput, ".eh_frame") != NULL)
4045 /* Generate .eh_frame data for the unwind directives specified. */
4046 for (p = all_frame_data; p ; p = p->next)
4047 if (p->prologue_sym)
4049 /* Create a temporary symbol at the same location as our
4050 function symbol. This prevents problems with globals. */
4051 cfi_new_fde (symbol_temp_new (S_GET_SEGMENT (p->func_sym),
4052 S_GET_VALUE (p->func_sym),
4053 symbol_get_frag (p->func_sym)));
4055 cfi_set_return_column (p->ra_regno);
4056 cfi_add_CFA_def_cfa_register (30);
4057 if (p->fp_regno != 30 || p->mask || p->fmask || p->frame_size)
4062 cfi_add_advance_loc (p->prologue_sym);
4064 if (p->fp_regno != 30)
4065 if (p->frame_size != 0)
4066 cfi_add_CFA_def_cfa (p->fp_regno, p->frame_size);
4068 cfi_add_CFA_def_cfa_register (p->fp_regno);
4069 else if (p->frame_size != 0)
4070 cfi_add_CFA_def_cfa_offset (p->frame_size);
4073 offset = p->mask_offset;
4075 /* Recall that $26 is special-cased and stored first. */
4076 if ((mask >> 26) & 1)
4078 cfi_add_CFA_offset (26, offset);
4089 cfi_add_CFA_offset (i, offset);
4094 offset = p->fmask_offset;
4102 cfi_add_CFA_offset (i + 32, offset);
4107 cfi_end_fde (p->func_end_sym);
4112 s_alpha_usepv (int unused ATTRIBUTE_UNUSED)
4114 char *name, name_end;
4115 char *which, which_end;
4119 name = input_line_pointer;
4120 name_end = get_symbol_end ();
4122 if (! is_name_beginner (*name))
4124 as_bad (_(".usepv directive has no name"));
4125 *input_line_pointer = name_end;
4126 ignore_rest_of_line ();
4130 sym = symbol_find_or_make (name);
4131 *input_line_pointer++ = name_end;
4133 if (name_end != ',')
4135 as_bad (_(".usepv directive has no type"));
4136 ignore_rest_of_line ();
4141 which = input_line_pointer;
4142 which_end = get_symbol_end ();
4144 if (strcmp (which, "no") == 0)
4145 other = STO_ALPHA_NOPV;
4146 else if (strcmp (which, "std") == 0)
4147 other = STO_ALPHA_STD_GPLOAD;
4150 as_bad (_("unknown argument for .usepv"));
4154 *input_line_pointer = which_end;
4155 demand_empty_rest_of_line ();
4157 S_SET_OTHER (sym, other | (S_GET_OTHER (sym) & ~STO_ALPHA_STD_GPLOAD));
4159 #endif /* OBJ_ELF */
4161 /* Standard calling conventions leaves the CFA at $30 on entry. */
4164 alpha_cfi_frame_initial_instructions (void)
4166 cfi_add_CFA_def_cfa_register (30);
4171 /* Get name of section. */
4173 s_alpha_section_name (void)
4178 if (*input_line_pointer == '"')
4182 name = demand_copy_C_string (&dummy);
4185 ignore_rest_of_line ();
4191 char *end = input_line_pointer;
4193 while (0 == strchr ("\n\t,; ", *end))
4195 if (end == input_line_pointer)
4197 as_warn (_("missing name"));
4198 ignore_rest_of_line ();
4202 name = xmalloc (end - input_line_pointer + 1);
4203 memcpy (name, input_line_pointer, end - input_line_pointer);
4204 name[end - input_line_pointer] = '\0';
4205 input_line_pointer = end;
4211 /* Put clear/set flags in one flagword. The LSBs are flags to be set,
4212 the MSBs are the flags to be cleared. */
4214 #define EGPS__V_NO_SHIFT 16
4215 #define EGPS__V_MASK 0xffff
4217 /* Parse one VMS section flag. */
4220 s_alpha_section_word (char *str, size_t len)
4225 if (len == 5 && strncmp (str, "NO", 2) == 0)
4234 if (strncmp (str, "PIC", 3) == 0)
4236 else if (strncmp (str, "LIB", 3) == 0)
4238 else if (strncmp (str, "OVR", 3) == 0)
4240 else if (strncmp (str, "REL", 3) == 0)
4242 else if (strncmp (str, "GBL", 3) == 0)
4244 else if (strncmp (str, "SHR", 3) == 0)
4246 else if (strncmp (str, "EXE", 3) == 0)
4248 else if (strncmp (str, "WRT", 3) == 0)
4250 else if (strncmp (str, "VEC", 3) == 0)
4252 else if (strncmp (str, "MOD", 3) == 0)
4254 flag = no ? EGPS__V_NOMOD : EGPS__V_NOMOD << EGPS__V_NO_SHIFT;
4257 else if (strncmp (str, "COM", 3) == 0)
4265 as_warn (_("unknown section attribute %s"), str);
4271 return flag << EGPS__V_NO_SHIFT;
4276 /* Handle the section specific pseudo-op. */
4278 #define EVAX_SECTION_COUNT 5
4280 static char *section_name[EVAX_SECTION_COUNT + 1] =
4281 { "NULL", ".rdata", ".comm", ".link", ".ctors", ".dtors" };
4284 s_alpha_section (int secid)
4288 flagword vms_flags = 0;
4293 name = s_alpha_section_name ();
4296 sec = subseg_new (name, 0);
4297 if (*input_line_pointer == ',')
4299 /* Skip the comma. */
4300 ++input_line_pointer;
4308 beg = input_line_pointer;
4309 c = get_symbol_end ();
4310 *input_line_pointer = c;
4312 vms_flags |= s_alpha_section_word (beg, input_line_pointer - beg);
4316 while (*input_line_pointer++ == ',');
4317 --input_line_pointer;
4320 symbol = symbol_find_or_make (name);
4321 S_SET_SEGMENT (symbol, sec);
4322 symbol_get_bfdsym (symbol)->flags |= BSF_SECTION_SYM;
4323 bfd_vms_set_section_flags
4325 (vms_flags >> EGPS__V_NO_SHIFT) & EGPS__V_MASK,
4326 vms_flags & EGPS__V_MASK);
4330 get_absolute_expression ();
4331 subseg_new (section_name[secid], 0);
4334 demand_empty_rest_of_line ();
4335 alpha_insn_label = NULL;
4336 alpha_auto_align_on = 1;
4337 alpha_current_align = 0;
4341 s_alpha_literals (int ignore ATTRIBUTE_UNUSED)
4343 subseg_new (".literals", 0);
4344 demand_empty_rest_of_line ();
4345 alpha_insn_label = NULL;
4346 alpha_auto_align_on = 1;
4347 alpha_current_align = 0;
4350 /* Parse .ent directives. */
4353 s_alpha_ent (int ignore ATTRIBUTE_UNUSED)
4356 expressionS symexpr;
4358 if (alpha_evax_proc != NULL)
4359 as_bad (_("previous .ent not closed by a .end"));
4361 alpha_evax_proc = &alpha_evax_proc_data;
4363 alpha_evax_proc->pdsckind = 0;
4364 alpha_evax_proc->framereg = -1;
4365 alpha_evax_proc->framesize = 0;
4366 alpha_evax_proc->rsa_offset = 0;
4367 alpha_evax_proc->ra_save = AXP_REG_RA;
4368 alpha_evax_proc->fp_save = -1;
4369 alpha_evax_proc->imask = 0;
4370 alpha_evax_proc->fmask = 0;
4371 alpha_evax_proc->prologue = 0;
4372 alpha_evax_proc->type = 0;
4373 alpha_evax_proc->handler = 0;
4374 alpha_evax_proc->handler_data = 0;
4376 expression (&symexpr);
4378 if (symexpr.X_op != O_symbol)
4380 as_fatal (_(".ent directive has no symbol"));
4381 demand_empty_rest_of_line ();
4385 symbol = make_expr_symbol (&symexpr);
4386 symbol_get_bfdsym (symbol)->flags |= BSF_FUNCTION;
4387 alpha_evax_proc->symbol = symbol;
4389 demand_empty_rest_of_line ();
4393 s_alpha_handler (int is_data)
4396 alpha_evax_proc->handler_data = get_absolute_expression ();
4399 char *name, name_end;
4400 name = input_line_pointer;
4401 name_end = get_symbol_end ();
4403 if (! is_name_beginner (*name))
4405 as_warn (_(".handler directive has no name"));
4406 *input_line_pointer = name_end;
4412 sym = symbol_find_or_make (name);
4413 symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
4414 alpha_evax_proc->handler = sym;
4415 *input_line_pointer = name_end;
4418 demand_empty_rest_of_line ();
4421 /* Parse .frame <framreg>,<framesize>,RA,<rsa_offset> directives. */
4424 s_alpha_frame (int ignore ATTRIBUTE_UNUSED)
4428 alpha_evax_proc->framereg = tc_get_register (1);
4431 if (*input_line_pointer++ != ','
4432 || get_absolute_expression_and_terminator (&val) != ',')
4434 as_warn (_("Bad .frame directive 1./2. param"));
4435 --input_line_pointer;
4436 demand_empty_rest_of_line ();
4440 alpha_evax_proc->framesize = val;
4442 (void) tc_get_register (1);
4444 if (*input_line_pointer++ != ',')
4446 as_warn (_("Bad .frame directive 3./4. param"));
4447 --input_line_pointer;
4448 demand_empty_rest_of_line ();
4451 alpha_evax_proc->rsa_offset = get_absolute_expression ();
4454 /* Parse .prologue. */
4457 s_alpha_prologue (int ignore ATTRIBUTE_UNUSED)
4459 get_absolute_expression ();
4460 demand_empty_rest_of_line ();
4461 alpha_prologue_label = symbol_new
4462 (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
4465 /* Parse .pdesc <entry_name>.
4466 Insert a procedure descriptor. */
4469 s_alpha_pdesc (int ignore ATTRIBUTE_UNUSED)
4476 const char *entry_sym_name;
4477 const char *pdesc_sym_name;
4481 if (now_seg != alpha_link_section)
4483 as_bad (_(".pdesc directive not in link (.link) section"));
4488 if (exp.X_op != O_symbol)
4490 as_bad (_(".pdesc directive has no entry symbol"));
4494 entry_sym = make_expr_symbol (&exp);
4495 entry_sym_name = S_GET_NAME (entry_sym);
4498 len = strlen (entry_sym_name);
4499 if (len < 4 || strcmp (entry_sym_name + len - 4, "..en") != 0)
4501 as_bad (_(".pdesc has a bad entry symbol"));
4505 pdesc_sym_name = S_GET_NAME (alpha_evax_proc->symbol);
4507 if (!alpha_evax_proc
4508 || !S_IS_DEFINED (alpha_evax_proc->symbol)
4509 || strlen (pdesc_sym_name) != len
4510 || memcmp (entry_sym_name, pdesc_sym_name, len) != 0)
4512 as_fatal (_(".pdesc doesn't match with last .ent"));
4516 /* Define pdesc symbol. */
4517 symbol_set_value_now (alpha_evax_proc->symbol);
4519 /* Save bfd symbol of proc entry in function symbol. */
4520 ((struct evax_private_udata_struct *)
4521 symbol_get_bfdsym (alpha_evax_proc->symbol)->udata.p)->enbsym
4522 = symbol_get_bfdsym (entry_sym);
4525 if (*input_line_pointer++ != ',')
4527 as_warn (_("No comma after .pdesc <entryname>"));
4528 demand_empty_rest_of_line ();
4533 name = input_line_pointer;
4534 name_end = get_symbol_end ();
4536 if (strncmp (name, "stack", 5) == 0)
4537 alpha_evax_proc->pdsckind = PDSC_S_K_KIND_FP_STACK;
4539 else if (strncmp (name, "reg", 3) == 0)
4540 alpha_evax_proc->pdsckind = PDSC_S_K_KIND_FP_REGISTER;
4542 else if (strncmp (name, "null", 4) == 0)
4543 alpha_evax_proc->pdsckind = PDSC_S_K_KIND_NULL;
4547 as_fatal (_("unknown procedure kind"));
4548 demand_empty_rest_of_line ();
4552 *input_line_pointer = name_end;
4553 demand_empty_rest_of_line ();
4555 #ifdef md_flush_pending_output
4556 md_flush_pending_output ();
4559 frag_align (3, 0, 0);
4561 fixp = fix_new (frag_now, p - frag_now->fr_literal, 8, 0, 0, 0, 0);
4564 *p = alpha_evax_proc->pdsckind
4565 | ((alpha_evax_proc->framereg == 29) ? PDSC_S_M_BASE_REG_IS_FP : 0)
4566 | ((alpha_evax_proc->handler) ? PDSC_S_M_HANDLER_VALID : 0)
4567 | ((alpha_evax_proc->handler_data) ? PDSC_S_M_HANDLER_DATA_VALID : 0);
4568 *(p + 1) = PDSC_S_M_NATIVE | PDSC_S_M_NO_JACKET;
4570 switch (alpha_evax_proc->pdsckind)
4572 case PDSC_S_K_KIND_NULL:
4576 case PDSC_S_K_KIND_FP_REGISTER:
4577 *(p + 2) = alpha_evax_proc->fp_save;
4578 *(p + 3) = alpha_evax_proc->ra_save;
4580 case PDSC_S_K_KIND_FP_STACK:
4581 md_number_to_chars (p + 2, (valueT) alpha_evax_proc->rsa_offset, 2);
4583 default: /* impossible */
4588 *(p + 5) = alpha_evax_proc->type & 0x0f;
4590 /* Signature offset. */
4591 md_number_to_chars (p + 6, (valueT) 0, 2);
4593 fix_new_exp (frag_now, p - frag_now->fr_literal+8, 8, &exp, 0, BFD_RELOC_64);
4595 if (alpha_evax_proc->pdsckind == PDSC_S_K_KIND_NULL)
4598 /* Add dummy fix to make add_to_link_pool work. */
4600 fixp = fix_new (frag_now, p - frag_now->fr_literal, 6, 0, 0, 0, 0);
4603 /* pdesc+16: Size. */
4604 md_number_to_chars (p, (valueT) alpha_evax_proc->framesize, 4);
4606 md_number_to_chars (p + 4, (valueT) 0, 2);
4609 exp.X_op = O_subtract;
4610 exp.X_add_symbol = alpha_prologue_label;
4611 exp.X_op_symbol = entry_sym;
4612 emit_expr (&exp, 2);
4614 if (alpha_evax_proc->pdsckind == PDSC_S_K_KIND_FP_REGISTER)
4617 /* Add dummy fix to make add_to_link_pool work. */
4619 fixp = fix_new (frag_now, p - frag_now->fr_literal, 8, 0, 0, 0, 0);
4622 /* pdesc+24: register masks. */
4624 md_number_to_chars (p, alpha_evax_proc->imask, 4);
4625 md_number_to_chars (p + 4, alpha_evax_proc->fmask, 4);
4627 if (alpha_evax_proc->handler)
4630 fixp = fix_new (frag_now, p - frag_now->fr_literal, 8,
4631 alpha_evax_proc->handler, 0, 0, BFD_RELOC_64);
4634 if (alpha_evax_proc->handler_data)
4636 /* Add dummy fix to make add_to_link_pool work. */
4638 fixp = fix_new (frag_now, p - frag_now->fr_literal, 8, 0, 0, 0, 0);
4640 md_number_to_chars (p, alpha_evax_proc->handler_data, 8);
4644 /* Support for crash debug on vms. */
4647 s_alpha_name (int ignore ATTRIBUTE_UNUSED)
4652 if (now_seg != alpha_link_section)
4654 as_bad (_(".name directive not in link (.link) section"));
4655 demand_empty_rest_of_line ();
4660 if (exp.X_op != O_symbol)
4662 as_warn (_(".name directive has no symbol"));
4663 demand_empty_rest_of_line ();
4667 demand_empty_rest_of_line ();
4669 #ifdef md_flush_pending_output
4670 md_flush_pending_output ();
4673 frag_align (3, 0, 0);
4676 fix_new_exp (frag_now, p - frag_now->fr_literal, 8, &exp, 0, BFD_RELOC_64);
4679 /* Parse .linkage <symbol>.
4680 Create a linkage pair relocation. */
4683 s_alpha_linkage (int ignore ATTRIBUTE_UNUSED)
4689 #ifdef md_flush_pending_output
4690 md_flush_pending_output ();
4694 if (exp.X_op != O_symbol)
4696 as_fatal (_("No symbol after .linkage"));
4700 struct alpha_linkage_fixups *linkage_fixup;
4702 p = frag_more (LKP_S_K_SIZE);
4703 memset (p, 0, LKP_S_K_SIZE);
4705 (frag_now, p - frag_now->fr_literal, LKP_S_K_SIZE, &exp, 0,\
4706 BFD_RELOC_ALPHA_LINKAGE);
4708 linkage_fixup = (struct alpha_linkage_fixups *)
4709 xmalloc (sizeof (struct alpha_linkage_fixups));
4711 linkage_fixup->fixp = fixp;
4712 linkage_fixup->next = 0;
4714 if (alpha_insn_label == 0)
4715 alpha_insn_label = symbol_new
4716 (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
4717 linkage_fixup->label = alpha_insn_label;
4719 if (alpha_linkage_fixup_root == 0)
4721 alpha_linkage_fixup_root = alpha_linkage_fixup_tail = linkage_fixup;
4722 alpha_linkage_fixup_tail->next = 0;
4726 alpha_linkage_fixup_tail->next = linkage_fixup;
4727 alpha_linkage_fixup_tail = linkage_fixup;
4728 alpha_linkage_fixup_tail->next = 0;
4731 demand_empty_rest_of_line ();
4734 /* Parse .code_address <symbol>.
4735 Create a code address relocation. */
4738 s_alpha_code_address (int ignore ATTRIBUTE_UNUSED)
4743 #ifdef md_flush_pending_output
4744 md_flush_pending_output ();
4748 if (exp.X_op != O_symbol)
4749 as_fatal (_("No symbol after .code_address"));
4754 fix_new_exp (frag_now, p - frag_now->fr_literal, 8, &exp, 0,\
4755 BFD_RELOC_ALPHA_CODEADDR);
4757 demand_empty_rest_of_line ();
4761 s_alpha_fp_save (int ignore ATTRIBUTE_UNUSED)
4764 alpha_evax_proc->fp_save = tc_get_register (1);
4766 demand_empty_rest_of_line ();
4770 s_alpha_mask (int ignore ATTRIBUTE_UNUSED)
4774 if (get_absolute_expression_and_terminator (&val) != ',')
4776 as_warn (_("Bad .mask directive"));
4777 --input_line_pointer;
4781 alpha_evax_proc->imask = val;
4782 (void) get_absolute_expression ();
4784 demand_empty_rest_of_line ();
4788 s_alpha_fmask (int ignore ATTRIBUTE_UNUSED)
4792 if (get_absolute_expression_and_terminator (&val) != ',')
4794 as_warn (_("Bad .fmask directive"));
4795 --input_line_pointer;
4799 alpha_evax_proc->fmask = val;
4800 (void) get_absolute_expression ();
4802 demand_empty_rest_of_line ();
4806 s_alpha_end (int ignore ATTRIBUTE_UNUSED)
4810 c = get_symbol_end ();
4811 *input_line_pointer = c;
4812 demand_empty_rest_of_line ();
4813 alpha_evax_proc = NULL;
4817 s_alpha_file (int ignore ATTRIBUTE_UNUSED)
4821 static char case_hack[32];
4823 sprintf (case_hack, "<CASE:%01d%01d>",
4824 alpha_flag_hash_long_names, alpha_flag_show_after_trunc);
4826 s = symbol_find_or_make (case_hack);
4827 symbol_get_bfdsym (s)->flags |= BSF_FILE;
4829 get_absolute_expression ();
4830 s = symbol_find_or_make (demand_copy_string (&length));
4831 symbol_get_bfdsym (s)->flags |= BSF_FILE;
4832 demand_empty_rest_of_line ();
4834 #endif /* OBJ_EVAX */
4836 /* Handle the .gprel32 pseudo op. */
4839 s_alpha_gprel32 (int ignore ATTRIBUTE_UNUSED)
4851 e.X_add_symbol = section_symbol (absolute_section);
4864 e.X_add_symbol = section_symbol (absolute_section);
4867 e.X_op = O_subtract;
4868 e.X_op_symbol = alpha_gp_symbol;
4876 if (alpha_auto_align_on && alpha_current_align < 2)
4877 alpha_align (2, (char *) NULL, alpha_insn_label, 0);
4878 if (alpha_current_align > 2)
4879 alpha_current_align = 2;
4880 alpha_insn_label = NULL;
4884 fix_new_exp (frag_now, p - frag_now->fr_literal, 4,
4885 &e, 0, BFD_RELOC_GPREL32);
4888 /* Handle floating point allocation pseudo-ops. This is like the
4889 generic vresion, but it makes sure the current label, if any, is
4890 correctly aligned. */
4893 s_alpha_float_cons (int type)
4919 if (alpha_auto_align_on && alpha_current_align < log_size)
4920 alpha_align (log_size, (char *) NULL, alpha_insn_label, 0);
4921 if (alpha_current_align > log_size)
4922 alpha_current_align = log_size;
4923 alpha_insn_label = NULL;
4928 /* Handle the .proc pseudo op. We don't really do much with it except
4932 s_alpha_proc (int is_static ATTRIBUTE_UNUSED)
4940 /* Takes ".proc name,nargs". */
4942 name = input_line_pointer;
4943 c = get_symbol_end ();
4944 p = input_line_pointer;
4945 symbolP = symbol_find_or_make (name);
4948 if (*input_line_pointer != ',')
4951 as_warn (_("Expected comma after name \"%s\""), name);
4954 ignore_rest_of_line ();
4958 input_line_pointer++;
4959 temp = get_absolute_expression ();
4961 /* *symbol_get_obj (symbolP) = (signed char) temp; */
4963 as_warn (_("unhandled: .proc %s,%d"), name, temp);
4964 demand_empty_rest_of_line ();
4967 /* Handle the .set pseudo op. This is used to turn on and off most of
4968 the assembler features. */
4971 s_alpha_set (int x ATTRIBUTE_UNUSED)
4977 name = input_line_pointer;
4978 ch = get_symbol_end ();
4981 if (s[0] == 'n' && s[1] == 'o')
4986 if (!strcmp ("reorder", s))
4988 else if (!strcmp ("at", s))
4989 alpha_noat_on = !yesno;
4990 else if (!strcmp ("macro", s))
4991 alpha_macros_on = yesno;
4992 else if (!strcmp ("move", s))
4994 else if (!strcmp ("volatile", s))
4997 as_warn (_("Tried to .set unrecognized mode `%s'"), name);
4999 *input_line_pointer = ch;
5000 demand_empty_rest_of_line ();
5003 /* Handle the .base pseudo op. This changes the assembler's notion of
5004 the $gp register. */
5007 s_alpha_base (int ignore ATTRIBUTE_UNUSED)
5011 if (*input_line_pointer == '$')
5014 input_line_pointer++;
5015 if (*input_line_pointer == 'r')
5016 input_line_pointer++;
5019 alpha_gp_register = get_absolute_expression ();
5020 if (alpha_gp_register < 0 || alpha_gp_register > 31)
5022 alpha_gp_register = AXP_REG_GP;
5023 as_warn (_("Bad base register, using $%d."), alpha_gp_register);
5026 demand_empty_rest_of_line ();
5029 /* Handle the .align pseudo-op. This aligns to a power of two. It
5030 also adjusts any current instruction label. We treat this the same
5031 way the MIPS port does: .align 0 turns off auto alignment. */
5034 s_alpha_align (int ignore ATTRIBUTE_UNUSED)
5038 long max_alignment = 16;
5040 align = get_absolute_expression ();
5041 if (align > max_alignment)
5043 align = max_alignment;
5044 as_bad (_("Alignment too large: %d. assumed"), align);
5048 as_warn (_("Alignment negative: 0 assumed"));
5052 if (*input_line_pointer == ',')
5054 input_line_pointer++;
5055 fill = get_absolute_expression ();
5063 alpha_auto_align_on = 1;
5064 alpha_align (align, pfill, NULL, 1);
5068 alpha_auto_align_on = 0;
5070 alpha_insn_label = NULL;
5072 demand_empty_rest_of_line ();
5075 /* Hook the normal string processor to reset known alignment. */
5078 s_alpha_stringer (int terminate)
5080 alpha_current_align = 0;
5081 alpha_insn_label = NULL;
5082 stringer (8 + terminate);
5085 /* Hook the normal space processing to reset known alignment. */
5088 s_alpha_space (int ignore)
5090 alpha_current_align = 0;
5091 alpha_insn_label = NULL;
5095 /* Hook into cons for auto-alignment. */
5098 alpha_cons_align (int size)
5103 while ((size >>= 1) != 0)
5106 if (alpha_auto_align_on && alpha_current_align < log_size)
5107 alpha_align (log_size, (char *) NULL, alpha_insn_label, 0);
5108 if (alpha_current_align > log_size)
5109 alpha_current_align = log_size;
5110 alpha_insn_label = NULL;
5113 /* Here come the .uword, .ulong, and .uquad explicitly unaligned
5114 pseudos. We just turn off auto-alignment and call down to cons. */
5117 s_alpha_ucons (int bytes)
5119 int hold = alpha_auto_align_on;
5120 alpha_auto_align_on = 0;
5122 alpha_auto_align_on = hold;
5125 /* Switch the working cpu type. */
5128 s_alpha_arch (int ignored ATTRIBUTE_UNUSED)
5131 const struct cpu_type *p;
5134 name = input_line_pointer;
5135 ch = get_symbol_end ();
5137 for (p = cpu_types; p->name; ++p)
5138 if (strcmp (name, p->name) == 0)
5140 alpha_target_name = p->name, alpha_target = p->flags;
5143 as_warn (_("Unknown CPU identifier `%s'"), name);
5146 *input_line_pointer = ch;
5147 demand_empty_rest_of_line ();
5151 /* print token expression with alpha specific extension. */
5154 alpha_print_token (FILE *f, const expressionS *exp)
5164 expressionS nexp = *exp;
5165 nexp.X_op = O_register;
5166 print_expr_1 (f, &nexp);
5171 print_expr_1 (f, exp);
5177 /* The target specific pseudo-ops which we support. */
5179 const pseudo_typeS md_pseudo_table[] =
5182 {"comm", s_alpha_comm, 0}, /* OSF1 compiler does this. */
5183 {"rdata", s_alpha_rdata, 0},
5185 {"text", s_alpha_text, 0},
5186 {"data", s_alpha_data, 0},
5188 {"sdata", s_alpha_sdata, 0},
5191 {"section", s_alpha_section, 0},
5192 {"section.s", s_alpha_section, 0},
5193 {"sect", s_alpha_section, 0},
5194 {"sect.s", s_alpha_section, 0},
5197 {"section", s_alpha_section, 0},
5198 {"literals", s_alpha_literals, 0},
5199 {"pdesc", s_alpha_pdesc, 0},
5200 {"name", s_alpha_name, 0},
5201 {"linkage", s_alpha_linkage, 0},
5202 {"code_address", s_alpha_code_address, 0},
5203 {"ent", s_alpha_ent, 0},
5204 {"frame", s_alpha_frame, 0},
5205 {"fp_save", s_alpha_fp_save, 0},
5206 {"mask", s_alpha_mask, 0},
5207 {"fmask", s_alpha_fmask, 0},
5208 {"end", s_alpha_end, 0},
5209 {"file", s_alpha_file, 0},
5210 {"rdata", s_alpha_section, 1},
5211 {"comm", s_alpha_comm, 0},
5212 {"link", s_alpha_section, 3},
5213 {"ctors", s_alpha_section, 4},
5214 {"dtors", s_alpha_section, 5},
5215 {"handler", s_alpha_handler, 0},
5216 {"handler_data", s_alpha_handler, 1},
5219 /* Frame related pseudos. */
5220 {"ent", s_alpha_ent, 0},
5221 {"end", s_alpha_end, 0},
5222 {"mask", s_alpha_mask, 0},
5223 {"fmask", s_alpha_mask, 1},
5224 {"frame", s_alpha_frame, 0},
5225 {"prologue", s_alpha_prologue, 0},
5226 {"file", s_alpha_file, 5},
5227 {"loc", s_alpha_loc, 9},
5228 {"stabs", s_alpha_stab, 's'},
5229 {"stabn", s_alpha_stab, 'n'},
5230 {"usepv", s_alpha_usepv, 0},
5231 /* COFF debugging related pseudos. */
5232 {"begin", s_alpha_coff_wrapper, 0},
5233 {"bend", s_alpha_coff_wrapper, 1},
5234 {"def", s_alpha_coff_wrapper, 2},
5235 {"dim", s_alpha_coff_wrapper, 3},
5236 {"endef", s_alpha_coff_wrapper, 4},
5237 {"scl", s_alpha_coff_wrapper, 5},
5238 {"tag", s_alpha_coff_wrapper, 6},
5239 {"val", s_alpha_coff_wrapper, 7},
5242 {"prologue", s_alpha_prologue, 0},
5244 {"prologue", s_ignore, 0},
5247 {"gprel32", s_alpha_gprel32, 0},
5248 {"t_floating", s_alpha_float_cons, 'd'},
5249 {"s_floating", s_alpha_float_cons, 'f'},
5250 {"f_floating", s_alpha_float_cons, 'F'},
5251 {"g_floating", s_alpha_float_cons, 'G'},
5252 {"d_floating", s_alpha_float_cons, 'D'},
5254 {"proc", s_alpha_proc, 0},
5255 {"aproc", s_alpha_proc, 1},
5256 {"set", s_alpha_set, 0},
5257 {"reguse", s_ignore, 0},
5258 {"livereg", s_ignore, 0},
5259 {"base", s_alpha_base, 0}, /*??*/
5260 {"option", s_ignore, 0},
5261 {"aent", s_ignore, 0},
5262 {"ugen", s_ignore, 0},
5263 {"eflag", s_ignore, 0},
5265 {"align", s_alpha_align, 0},
5266 {"double", s_alpha_float_cons, 'd'},
5267 {"float", s_alpha_float_cons, 'f'},
5268 {"single", s_alpha_float_cons, 'f'},
5269 {"ascii", s_alpha_stringer, 0},
5270 {"asciz", s_alpha_stringer, 1},
5271 {"string", s_alpha_stringer, 1},
5272 {"space", s_alpha_space, 0},
5273 {"skip", s_alpha_space, 0},
5274 {"zero", s_alpha_space, 0},
5276 /* Unaligned data pseudos. */
5277 {"uword", s_alpha_ucons, 2},
5278 {"ulong", s_alpha_ucons, 4},
5279 {"uquad", s_alpha_ucons, 8},
5282 /* Dwarf wants these versions of unaligned. */
5283 {"2byte", s_alpha_ucons, 2},
5284 {"4byte", s_alpha_ucons, 4},
5285 {"8byte", s_alpha_ucons, 8},
5288 /* We don't do any optimizing, so we can safely ignore these. */
5289 {"noalias", s_ignore, 0},
5290 {"alias", s_ignore, 0},
5292 {"arch", s_alpha_arch, 0},
5299 /* @@@ GP selection voodoo. All of this seems overly complicated and
5300 unnecessary; which is the primary reason it's for ECOFF only. */
5303 maybe_set_gp (asection *sec)
5309 vma = bfd_get_section_vma (foo, sec);
5310 if (vma && vma < alpha_gp_value)
5311 alpha_gp_value = vma;
5315 select_gp_value (void)
5317 gas_assert (alpha_gp_value == 0);
5319 /* Get minus-one in whatever width... */
5323 /* Select the smallest VMA of these existing sections. */
5324 maybe_set_gp (alpha_lita_section);
5326 /* @@ Will a simple 0x8000 work here? If not, why not? */
5327 #define GP_ADJUSTMENT (0x8000 - 0x10)
5329 alpha_gp_value += GP_ADJUSTMENT;
5331 S_SET_VALUE (alpha_gp_symbol, alpha_gp_value);
5334 printf (_("Chose GP value of %lx\n"), alpha_gp_value);
5337 #endif /* OBJ_ECOFF */
5340 /* Map 's' to SHF_ALPHA_GPREL. */
5343 alpha_elf_section_letter (int letter, char **ptr_msg)
5346 return SHF_ALPHA_GPREL;
5348 *ptr_msg = _("bad .section directive: want a,s,w,x,M,S,G,T in string");
5352 /* Map SHF_ALPHA_GPREL to SEC_SMALL_DATA. */
5355 alpha_elf_section_flags (flagword flags, bfd_vma attr, int type ATTRIBUTE_UNUSED)
5357 if (attr & SHF_ALPHA_GPREL)
5358 flags |= SEC_SMALL_DATA;
5361 #endif /* OBJ_ELF */
5363 /* This is called from HANDLE_ALIGN in write.c. Fill in the contents
5364 of an rs_align_code fragment. */
5367 alpha_handle_align (fragS *fragp)
5369 static char const unop[4] = { 0x00, 0x00, 0xfe, 0x2f };
5370 static char const nopunop[8] =
5372 0x1f, 0x04, 0xff, 0x47,
5373 0x00, 0x00, 0xfe, 0x2f
5379 if (fragp->fr_type != rs_align_code)
5382 bytes = fragp->fr_next->fr_address - fragp->fr_address - fragp->fr_fix;
5383 p = fragp->fr_literal + fragp->fr_fix;
5396 memcpy (p, unop, 4);
5402 memcpy (p, nopunop, 8);
5404 fragp->fr_fix += fix;
5408 /* Public interface functions. */
5410 /* This function is called once, at assembler startup time. It sets
5411 up all the tables, etc. that the MD part of the assembler will
5412 need, that can be determined before arguments are parsed. */
5419 /* Verify that X_op field is wide enough. */
5424 gas_assert (e.X_op == O_max);
5427 /* Create the opcode hash table. */
5428 alpha_opcode_hash = hash_new ();
5430 for (i = 0; i < alpha_num_opcodes;)
5432 const char *name, *retval, *slash;
5434 name = alpha_opcodes[i].name;
5435 retval = hash_insert (alpha_opcode_hash, name, (void *) &alpha_opcodes[i]);
5437 as_fatal (_("internal error: can't hash opcode `%s': %s"),
5440 /* Some opcodes include modifiers of various sorts with a "/mod"
5441 syntax, like the architecture manual suggests. However, for
5442 use with gcc at least, we also need access to those same opcodes
5445 if ((slash = strchr (name, '/')) != NULL)
5447 char *p = (char *) xmalloc (strlen (name));
5449 memcpy (p, name, slash - name);
5450 strcpy (p + (slash - name), slash + 1);
5452 (void) hash_insert (alpha_opcode_hash, p, (void *) &alpha_opcodes[i]);
5453 /* Ignore failures -- the opcode table does duplicate some
5454 variants in different forms, like "hw_stq" and "hw_st/q". */
5457 while (++i < alpha_num_opcodes
5458 && (alpha_opcodes[i].name == name
5459 || !strcmp (alpha_opcodes[i].name, name)))
5463 /* Create the macro hash table. */
5464 alpha_macro_hash = hash_new ();
5466 for (i = 0; i < alpha_num_macros;)
5468 const char *name, *retval;
5470 name = alpha_macros[i].name;
5471 retval = hash_insert (alpha_macro_hash, name, (void *) &alpha_macros[i]);
5473 as_fatal (_("internal error: can't hash macro `%s': %s"),
5476 while (++i < alpha_num_macros
5477 && (alpha_macros[i].name == name
5478 || !strcmp (alpha_macros[i].name, name)))
5482 /* Construct symbols for each of the registers. */
5483 for (i = 0; i < 32; ++i)
5487 sprintf (name, "$%d", i);
5488 alpha_register_table[i] = symbol_create (name, reg_section, i,
5489 &zero_address_frag);
5496 sprintf (name, "$f%d", i - 32);
5497 alpha_register_table[i] = symbol_create (name, reg_section, i,
5498 &zero_address_frag);
5501 /* Create the special symbols and sections we'll be using. */
5503 /* So .sbss will get used for tiny objects. */
5504 bfd_set_gp_size (stdoutput, g_switch_value);
5507 create_literal_section (".lita", &alpha_lita_section, &alpha_lita_symbol);
5509 /* For handling the GP, create a symbol that won't be output in the
5510 symbol table. We'll edit it out of relocs later. */
5511 alpha_gp_symbol = symbol_create ("<GP value>", alpha_lita_section, 0x8000,
5512 &zero_address_frag);
5516 create_literal_section (".link", &alpha_link_section, &alpha_link_symbol);
5520 if (ECOFF_DEBUGGING)
5522 segT sec = subseg_new (".mdebug", (subsegT) 0);
5523 bfd_set_section_flags (stdoutput, sec, SEC_HAS_CONTENTS | SEC_READONLY);
5524 bfd_set_section_alignment (stdoutput, sec, 3);
5528 /* Create literal lookup hash table. */
5529 alpha_literal_hash = hash_new ();
5531 subseg_set (text_section, 0);
5534 /* The public interface to the instruction assembler. */
5537 md_assemble (char *str)
5539 /* Current maximum is 13. */
5541 expressionS tok[MAX_INSN_ARGS];
5545 /* Split off the opcode. */
5546 opnamelen = strspn (str, "abcdefghijklmnopqrstuvwxyz_/46819");
5547 trunclen = (opnamelen < sizeof (opname) - 1
5549 : sizeof (opname) - 1);
5550 memcpy (opname, str, trunclen);
5551 opname[trunclen] = '\0';
5553 /* Tokenize the rest of the line. */
5554 if ((ntok = tokenize_arguments (str + opnamelen, tok, MAX_INSN_ARGS)) < 0)
5556 if (ntok != TOKENIZE_ERROR_REPORT)
5557 as_bad (_("syntax error"));
5562 /* Finish it off. */
5563 assemble_tokens (opname, tok, ntok, alpha_macros_on);
5566 /* Round up a section's size to the appropriate boundary. */
5569 md_section_align (segT seg, valueT size)
5571 int align = bfd_get_section_alignment (stdoutput, seg);
5572 valueT mask = ((valueT) 1 << align) - 1;
5574 return (size + mask) & ~mask;
5577 /* Turn a string in input_line_pointer into a floating point constant
5578 of type TYPE, and store the appropriate bytes in *LITP. The number
5579 of LITTLENUMS emitted is stored in *SIZEP. An error message is
5580 returned, or NULL on OK. */
5583 md_atof (int type, char *litP, int *sizeP)
5585 extern char *vax_md_atof (int, char *, int *);
5591 /* vax_md_atof() doesn't like "G" for some reason. */
5595 return vax_md_atof (type, litP, sizeP);
5598 return ieee_md_atof (type, litP, sizeP, FALSE);
5602 /* Take care of the target-specific command-line options. */
5605 md_parse_option (int c, char *arg)
5610 alpha_nofloats_on = 1;
5614 alpha_addr32_on = 1;
5622 g_switch_value = atoi (arg);
5627 const struct cpu_type *p;
5629 for (p = cpu_types; p->name; ++p)
5630 if (strcmp (arg, p->name) == 0)
5632 alpha_target_name = p->name, alpha_target = p->flags;
5635 as_warn (_("Unknown CPU identifier `%s'"), arg);
5641 case '+': /* For g++. Hash any name > 63 chars long. */
5642 alpha_flag_hash_long_names = 1;
5645 case 'H': /* Show new symbol after hash truncation. */
5646 alpha_flag_show_after_trunc = 1;
5649 case 'h': /* For gnu-c/vax compatibility. */
5652 case OPTION_REPLACE:
5653 alpha_flag_replace = 1;
5656 case OPTION_NOREPLACE:
5657 alpha_flag_replace = 0;
5662 alpha_flag_relax = 1;
5667 alpha_flag_mdebug = 1;
5669 case OPTION_NO_MDEBUG:
5670 alpha_flag_mdebug = 0;
5681 /* Print a description of the command-line options that we accept. */
5684 md_show_usage (FILE *stream)
5688 -32addr treat addresses as 32-bit values\n\
5689 -F lack floating point instructions support\n\
5690 -mev4 | -mev45 | -mev5 | -mev56 | -mpca56 | -mev6 | -mev67 | -mev68 | -mall\n\
5691 specify variant of Alpha architecture\n\
5692 -m21064 | -m21066 | -m21164 | -m21164a | -m21164pc | -m21264 | -m21264a | -m21264b\n\
5693 these variants include PALcode opcodes\n"),
5698 -+ encode (don't truncate) names longer than 64 characters\n\
5699 -H show new symbol after hash truncation\n\
5700 -replace/-noreplace enable or disable the optimization of procedure calls\n"),
5705 /* Decide from what point a pc-relative relocation is relative to,
5706 relative to the pc-relative fixup. Er, relatively speaking. */
5709 md_pcrel_from (fixS *fixP)
5711 valueT addr = fixP->fx_where + fixP->fx_frag->fr_address;
5713 switch (fixP->fx_r_type)
5715 case BFD_RELOC_23_PCREL_S2:
5716 case BFD_RELOC_ALPHA_HINT:
5717 case BFD_RELOC_ALPHA_BRSGP:
5724 /* Attempt to simplify or even eliminate a fixup. The return value is
5725 ignored; perhaps it was once meaningful, but now it is historical.
5726 To indicate that a fixup has been eliminated, set fixP->fx_done.
5728 For ELF, here it is that we transform the GPDISP_HI16 reloc we used
5729 internally into the GPDISP reloc used externally. We had to do
5730 this so that we'd have the GPDISP_LO16 reloc as a tag to compute
5731 the distance to the "lda" instruction for setting the addend to
5735 md_apply_fix (fixS *fixP, valueT * valP, segT seg)
5737 char * const fixpos = fixP->fx_frag->fr_literal + fixP->fx_where;
5738 valueT value = * valP;
5739 unsigned image, size;
5741 switch (fixP->fx_r_type)
5743 /* The GPDISP relocations are processed internally with a symbol
5744 referring to the current function's section; we need to drop
5745 in a value which, when added to the address of the start of
5746 the function, gives the desired GP. */
5747 case BFD_RELOC_ALPHA_GPDISP_HI16:
5749 fixS *next = fixP->fx_next;
5751 /* With user-specified !gpdisp relocations, we can be missing
5752 the matching LO16 reloc. We will have already issued an
5755 fixP->fx_offset = (next->fx_frag->fr_address + next->fx_where
5756 - fixP->fx_frag->fr_address - fixP->fx_where);
5758 value = (value - sign_extend_16 (value)) >> 16;
5761 fixP->fx_r_type = BFD_RELOC_ALPHA_GPDISP;
5765 case BFD_RELOC_ALPHA_GPDISP_LO16:
5766 value = sign_extend_16 (value);
5767 fixP->fx_offset = 0;
5773 fixP->fx_addsy = section_symbol (seg);
5774 md_number_to_chars (fixpos, value, 2);
5779 fixP->fx_r_type = BFD_RELOC_16_PCREL;
5785 fixP->fx_r_type = BFD_RELOC_32_PCREL;
5791 fixP->fx_r_type = BFD_RELOC_64_PCREL;
5795 if (fixP->fx_pcrel == 0 && fixP->fx_addsy == 0)
5797 md_number_to_chars (fixpos, value, size);
5803 case BFD_RELOC_GPREL32:
5804 gas_assert (fixP->fx_subsy == alpha_gp_symbol);
5806 /* FIXME: inherited this obliviousness of `value' -- why? */
5807 md_number_to_chars (fixpos, -alpha_gp_value, 4);
5810 case BFD_RELOC_GPREL32:
5812 case BFD_RELOC_GPREL16:
5813 case BFD_RELOC_ALPHA_GPREL_HI16:
5814 case BFD_RELOC_ALPHA_GPREL_LO16:
5817 case BFD_RELOC_23_PCREL_S2:
5818 if (fixP->fx_pcrel == 0 && fixP->fx_addsy == 0)
5820 image = bfd_getl32 (fixpos);
5821 image = (image & ~0x1FFFFF) | ((value >> 2) & 0x1FFFFF);
5826 case BFD_RELOC_ALPHA_HINT:
5827 if (fixP->fx_pcrel == 0 && fixP->fx_addsy == 0)
5829 image = bfd_getl32 (fixpos);
5830 image = (image & ~0x3FFF) | ((value >> 2) & 0x3FFF);
5836 case BFD_RELOC_ALPHA_BRSGP:
5839 case BFD_RELOC_ALPHA_TLSGD:
5840 case BFD_RELOC_ALPHA_TLSLDM:
5841 case BFD_RELOC_ALPHA_GOTDTPREL16:
5842 case BFD_RELOC_ALPHA_DTPREL_HI16:
5843 case BFD_RELOC_ALPHA_DTPREL_LO16:
5844 case BFD_RELOC_ALPHA_DTPREL16:
5845 case BFD_RELOC_ALPHA_GOTTPREL16:
5846 case BFD_RELOC_ALPHA_TPREL_HI16:
5847 case BFD_RELOC_ALPHA_TPREL_LO16:
5848 case BFD_RELOC_ALPHA_TPREL16:
5850 S_SET_THREAD_LOCAL (fixP->fx_addsy);
5855 case BFD_RELOC_ALPHA_LITERAL:
5856 md_number_to_chars (fixpos, value, 2);
5859 case BFD_RELOC_ALPHA_ELF_LITERAL:
5860 case BFD_RELOC_ALPHA_LITUSE:
5861 case BFD_RELOC_ALPHA_LINKAGE:
5862 case BFD_RELOC_ALPHA_CODEADDR:
5866 case BFD_RELOC_ALPHA_NOP:
5867 value -= (8 + 4); /* PC-relative, base is jsr+4. */
5869 /* From B.4.5.2 of the OpenVMS Linker Utility Manual:
5870 "Finally, the ETIR$C_STC_BSR command passes the same address
5871 as ETIR$C_STC_NOP (so that they will fail or succeed together),
5872 and the same test is done again." */
5873 if (S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
5875 fixP->fx_addnumber = -value;
5879 if ((abs (value) >> 2) & ~0xfffff)
5883 /* Change to a nop. */
5888 case BFD_RELOC_ALPHA_LDA:
5889 /* fixup_segment sets fixP->fx_addsy to NULL when it can pre-compute
5890 the value for an O_subtract. */
5892 && S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
5894 fixP->fx_addnumber = symbol_get_bfdsym (fixP->fx_subsy)->value;
5898 if ((abs (value)) & ~0x7fff)
5902 /* Change to an lda. */
5903 image = 0x237B0000 | (value & 0xFFFF);
5907 case BFD_RELOC_ALPHA_BSR:
5908 case BFD_RELOC_ALPHA_BOH:
5909 value -= 4; /* PC-relative, base is jsr+4. */
5911 /* See comment in the BFD_RELOC_ALPHA_NOP case above. */
5912 if (S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
5914 fixP->fx_addnumber = -value;
5918 if ((abs (value) >> 2) & ~0xfffff)
5921 if (fixP->fx_r_type == BFD_RELOC_ALPHA_BOH)
5924 image = bfd_getl32(fixpos);
5925 image = (image & ~0x3FFF) | ((value >> 2) & 0x3FFF);
5932 /* Change to a branch. */
5933 image = 0xD3400000 | ((value >> 2) & 0x1FFFFF);
5938 case BFD_RELOC_VTABLE_INHERIT:
5939 case BFD_RELOC_VTABLE_ENTRY:
5944 const struct alpha_operand *operand;
5946 if ((int) fixP->fx_r_type >= 0)
5947 as_fatal (_("unhandled relocation type %s"),
5948 bfd_get_reloc_code_name (fixP->fx_r_type));
5950 gas_assert (-(int) fixP->fx_r_type < (int) alpha_num_operands);
5951 operand = &alpha_operands[-(int) fixP->fx_r_type];
5953 /* The rest of these fixups only exist internally during symbol
5954 resolution and have no representation in the object file.
5955 Therefore they must be completely resolved as constants. */
5957 if (fixP->fx_addsy != 0
5958 && S_GET_SEGMENT (fixP->fx_addsy) != absolute_section)
5959 as_bad_where (fixP->fx_file, fixP->fx_line,
5960 _("non-absolute expression in constant field"));
5962 image = bfd_getl32 (fixpos);
5963 image = insert_operand (image, operand, (offsetT) value,
5964 fixP->fx_file, fixP->fx_line);
5969 if (fixP->fx_addsy != 0 || fixP->fx_pcrel != 0)
5973 as_warn_where (fixP->fx_file, fixP->fx_line,
5974 _("type %d reloc done?\n"), (int) fixP->fx_r_type);
5979 md_number_to_chars (fixpos, image, 4);
5985 /* Look for a register name in the given symbol. */
5988 md_undefined_symbol (char *name)
5992 int is_float = 0, num;
5997 if (name[1] == 'p' && name[2] == '\0')
5998 return alpha_register_table[AXP_REG_FP];
6003 if (!ISDIGIT (*++name))
6007 case '0': case '1': case '2': case '3': case '4':
6008 case '5': case '6': case '7': case '8': case '9':
6009 if (name[1] == '\0')
6010 num = name[0] - '0';
6011 else if (name[0] != '0' && ISDIGIT (name[1]) && name[2] == '\0')
6013 num = (name[0] - '0') * 10 + name[1] - '0';
6020 if (!alpha_noat_on && (num + is_float) == AXP_REG_AT)
6021 as_warn (_("Used $at without \".set noat\""));
6022 return alpha_register_table[num + is_float];
6025 if (name[1] == 't' && name[2] == '\0')
6028 as_warn (_("Used $at without \".set noat\""));
6029 return alpha_register_table[AXP_REG_AT];
6034 if (name[1] == 'p' && name[2] == '\0')
6035 return alpha_register_table[alpha_gp_register];
6039 if (name[1] == 'p' && name[2] == '\0')
6040 return alpha_register_table[AXP_REG_SP];
6048 /* @@@ Magic ECOFF bits. */
6051 alpha_frob_ecoff_data (void)
6054 /* $zero and $f31 are read-only. */
6055 alpha_gprmask &= ~1;
6056 alpha_fprmask &= ~1;
6060 /* Hook to remember a recently defined label so that the auto-align
6061 code can adjust the symbol after we know what alignment will be
6065 alpha_define_label (symbolS *sym)
6067 alpha_insn_label = sym;
6069 dwarf2_emit_label (sym);
6073 /* Return true if we must always emit a reloc for a type and false if
6074 there is some hope of resolving it at assembly time. */
6077 alpha_force_relocation (fixS *f)
6079 if (alpha_flag_relax)
6082 switch (f->fx_r_type)
6084 case BFD_RELOC_ALPHA_GPDISP_HI16:
6085 case BFD_RELOC_ALPHA_GPDISP_LO16:
6086 case BFD_RELOC_ALPHA_GPDISP:
6087 case BFD_RELOC_ALPHA_LITERAL:
6088 case BFD_RELOC_ALPHA_ELF_LITERAL:
6089 case BFD_RELOC_ALPHA_LITUSE:
6090 case BFD_RELOC_GPREL16:
6091 case BFD_RELOC_GPREL32:
6092 case BFD_RELOC_ALPHA_GPREL_HI16:
6093 case BFD_RELOC_ALPHA_GPREL_LO16:
6094 case BFD_RELOC_ALPHA_LINKAGE:
6095 case BFD_RELOC_ALPHA_CODEADDR:
6096 case BFD_RELOC_ALPHA_BRSGP:
6097 case BFD_RELOC_ALPHA_TLSGD:
6098 case BFD_RELOC_ALPHA_TLSLDM:
6099 case BFD_RELOC_ALPHA_GOTDTPREL16:
6100 case BFD_RELOC_ALPHA_DTPREL_HI16:
6101 case BFD_RELOC_ALPHA_DTPREL_LO16:
6102 case BFD_RELOC_ALPHA_DTPREL16:
6103 case BFD_RELOC_ALPHA_GOTTPREL16:
6104 case BFD_RELOC_ALPHA_TPREL_HI16:
6105 case BFD_RELOC_ALPHA_TPREL_LO16:
6106 case BFD_RELOC_ALPHA_TPREL16:
6108 case BFD_RELOC_ALPHA_NOP:
6109 case BFD_RELOC_ALPHA_BSR:
6110 case BFD_RELOC_ALPHA_LDA:
6111 case BFD_RELOC_ALPHA_BOH:
6119 return generic_force_reloc (f);
6122 /* Return true if we can partially resolve a relocation now. */
6125 alpha_fix_adjustable (fixS *f)
6127 /* Are there any relocation types for which we must generate a
6128 reloc but we can adjust the values contained within it? */
6129 switch (f->fx_r_type)
6131 case BFD_RELOC_ALPHA_GPDISP_HI16:
6132 case BFD_RELOC_ALPHA_GPDISP_LO16:
6133 case BFD_RELOC_ALPHA_GPDISP:
6136 case BFD_RELOC_ALPHA_LITERAL:
6137 case BFD_RELOC_ALPHA_ELF_LITERAL:
6138 case BFD_RELOC_ALPHA_LITUSE:
6139 case BFD_RELOC_ALPHA_LINKAGE:
6140 case BFD_RELOC_ALPHA_CODEADDR:
6143 case BFD_RELOC_VTABLE_ENTRY:
6144 case BFD_RELOC_VTABLE_INHERIT:
6147 case BFD_RELOC_GPREL16:
6148 case BFD_RELOC_GPREL32:
6149 case BFD_RELOC_ALPHA_GPREL_HI16:
6150 case BFD_RELOC_ALPHA_GPREL_LO16:
6151 case BFD_RELOC_23_PCREL_S2:
6155 case BFD_RELOC_ALPHA_HINT:
6158 case BFD_RELOC_ALPHA_TLSGD:
6159 case BFD_RELOC_ALPHA_TLSLDM:
6160 case BFD_RELOC_ALPHA_GOTDTPREL16:
6161 case BFD_RELOC_ALPHA_DTPREL_HI16:
6162 case BFD_RELOC_ALPHA_DTPREL_LO16:
6163 case BFD_RELOC_ALPHA_DTPREL16:
6164 case BFD_RELOC_ALPHA_GOTTPREL16:
6165 case BFD_RELOC_ALPHA_TPREL_HI16:
6166 case BFD_RELOC_ALPHA_TPREL_LO16:
6167 case BFD_RELOC_ALPHA_TPREL16:
6168 /* ??? No idea why we can't return a reference to .tbss+10, but
6169 we're preventing this in the other assemblers. Follow for now. */
6173 case BFD_RELOC_ALPHA_BRSGP:
6174 /* If we have a BRSGP reloc to a local symbol, adjust it to BRADDR and
6175 let it get resolved at assembly time. */
6177 symbolS *sym = f->fx_addsy;
6181 if (generic_force_reloc (f))
6184 switch (S_GET_OTHER (sym) & STO_ALPHA_STD_GPLOAD)
6186 case STO_ALPHA_NOPV:
6188 case STO_ALPHA_STD_GPLOAD:
6192 if (S_IS_LOCAL (sym))
6195 name = S_GET_NAME (sym);
6196 as_bad_where (f->fx_file, f->fx_line,
6197 _("!samegp reloc against symbol without .prologue: %s"),
6201 f->fx_r_type = BFD_RELOC_23_PCREL_S2;
6202 f->fx_offset += offset;
6207 case BFD_RELOC_ALPHA_NOP:
6208 case BFD_RELOC_ALPHA_BSR:
6209 case BFD_RELOC_ALPHA_LDA:
6210 case BFD_RELOC_ALPHA_BOH:
6219 /* Generate the BFD reloc to be stuck in the object file from the
6220 fixup used internally in the assembler. */
6223 tc_gen_reloc (asection *sec ATTRIBUTE_UNUSED,
6228 reloc = (arelent *) xmalloc (sizeof (* reloc));
6229 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
6230 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
6231 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
6233 /* Make sure none of our internal relocations make it this far.
6234 They'd better have been fully resolved by this point. */
6235 gas_assert ((int) fixp->fx_r_type > 0);
6237 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
6238 if (reloc->howto == NULL)
6240 as_bad_where (fixp->fx_file, fixp->fx_line,
6241 _("cannot represent `%s' relocation in object file"),
6242 bfd_get_reloc_code_name (fixp->fx_r_type));
6246 if (!fixp->fx_pcrel != !reloc->howto->pc_relative)
6247 as_fatal (_("internal error? cannot generate `%s' relocation"),
6248 bfd_get_reloc_code_name (fixp->fx_r_type));
6250 gas_assert (!fixp->fx_pcrel == !reloc->howto->pc_relative);
6252 reloc->addend = fixp->fx_offset;
6255 /* Fake out bfd_perform_relocation. sigh. */
6256 /* ??? Better would be to use the special_function hook. */
6257 if (fixp->fx_r_type == BFD_RELOC_ALPHA_LITERAL)
6258 reloc->addend = -alpha_gp_value;
6262 switch (fixp->fx_r_type)
6264 struct evax_private_udata_struct *udata;
6268 case BFD_RELOC_ALPHA_LINKAGE:
6269 /* Copy the linkage index. */
6270 reloc->addend = fixp->fx_addnumber;
6273 case BFD_RELOC_ALPHA_NOP:
6274 case BFD_RELOC_ALPHA_BSR:
6275 case BFD_RELOC_ALPHA_LDA:
6276 case BFD_RELOC_ALPHA_BOH:
6277 pname = symbol_get_bfdsym (fixp->fx_addsy)->name;
6279 /* We need the non-suffixed name of the procedure. Beware that
6280 the main symbol might be equated so look it up and take its name. */
6281 pname_len = strlen (pname);
6282 if (pname_len > 4 && strcmp (pname + pname_len - 4, "..en") == 0)
6285 char *my_pname = (char *) alloca (pname_len - 4 + 1);
6287 memcpy (my_pname, pname, pname_len - 4);
6288 my_pname [pname_len - 4] = 0;
6289 sym = symbol_find (my_pname);
6293 while (symbol_equated_reloc_p (sym))
6295 symbolS *n = symbol_get_value_expression (sym)->X_add_symbol;
6297 /* We must avoid looping, as that can occur with a badly
6303 pname = symbol_get_bfdsym (sym)->name;
6306 udata = (struct evax_private_udata_struct *)
6307 xmalloc (sizeof (struct evax_private_udata_struct));
6308 udata->enbsym = symbol_get_bfdsym (fixp->fx_addsy);
6309 udata->bsym = symbol_get_bfdsym (fixp->tc_fix_data.info->psym);
6310 udata->origname = (char *)pname;
6311 udata->lkindex = ((struct evax_private_udata_struct *)
6312 symbol_get_bfdsym (fixp->tc_fix_data.info->sym)->udata.p)->lkindex;
6313 reloc->sym_ptr_ptr = (void *)udata;
6314 reloc->addend = fixp->fx_addnumber;
6324 /* Parse a register name off of the input_line and return a register
6325 number. Gets md_undefined_symbol above to do the register name
6328 Only called as a part of processing the ECOFF .frame directive. */
6331 tc_get_register (int frame ATTRIBUTE_UNUSED)
6333 int framereg = AXP_REG_SP;
6336 if (*input_line_pointer == '$')
6338 char *s = input_line_pointer;
6339 char c = get_symbol_end ();
6340 symbolS *sym = md_undefined_symbol (s);
6342 *strchr (s, '\0') = c;
6343 if (sym && (framereg = S_GET_VALUE (sym)) <= 31)
6346 as_warn (_("frame reg expected, using $%d."), framereg);
6349 note_gpreg (framereg);
6353 /* This is called before the symbol table is processed. In order to
6354 work with gcc when using mips-tfile, we must keep all local labels.
6355 However, in other cases, we want to discard them. If we were
6356 called with -g, but we didn't see any debugging information, it may
6357 mean that gcc is smuggling debugging information through to
6358 mips-tfile, in which case we must generate all local labels. */
6363 alpha_frob_file_before_adjust (void)
6365 if (alpha_debug != 0
6366 && ! ecoff_debugging_seen)
6367 flag_keep_locals = 1;
6370 #endif /* OBJ_ECOFF */
6372 /* The Alpha has support for some VAX floating point types, as well as for
6373 IEEE floating point. We consider IEEE to be the primary floating point
6374 format, and sneak in the VAX floating point support here. */
6375 #include "config/atof-vax.c"