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 static struct hash_control *alpha_evax_proc_hash;
298 #endif /* OBJ_EVAX */
300 /* The cpu for which we are generating code. */
301 static unsigned alpha_target = AXP_OPCODE_BASE;
302 static const char *alpha_target_name = "<all>";
304 /* The hash table of instruction opcodes. */
305 static struct hash_control *alpha_opcode_hash;
307 /* The hash table of macro opcodes. */
308 static struct hash_control *alpha_macro_hash;
311 /* The $gp relocation symbol. */
312 static symbolS *alpha_gp_symbol;
314 /* XXX: what is this, and why is it exported? */
315 valueT alpha_gp_value;
318 /* The current $gp register. */
319 static int alpha_gp_register = AXP_REG_GP;
321 /* A table of the register symbols. */
322 static symbolS *alpha_register_table[64];
324 /* Constant sections, or sections of constants. */
326 static segT alpha_lita_section;
329 segT alpha_link_section;
332 static segT alpha_lit8_section;
335 /* Symbols referring to said sections. */
337 static symbolS *alpha_lita_symbol;
340 static symbolS *alpha_link_symbol;
343 static symbolS *alpha_lit8_symbol;
346 /* Literal for .litX+0x8000 within .lita. */
348 static offsetT alpha_lit8_literal;
351 /* Is the assembler not allowed to use $at? */
352 static int alpha_noat_on = 0;
354 /* Are macros enabled? */
355 static int alpha_macros_on = 1;
357 /* Are floats disabled? */
358 static int alpha_nofloats_on = 0;
360 /* Are addresses 32 bit? */
361 static int alpha_addr32_on = 0;
363 /* Symbol labelling the current insn. When the Alpha gas sees
366 and the section happens to not be on an eight byte boundary, it
367 will align both the symbol and the .quad to an eight byte boundary. */
368 static symbolS *alpha_insn_label;
369 #if defined(OBJ_ELF) || defined (OBJ_EVAX)
370 static symbolS *alpha_prologue_label;
374 /* Symbol associate with the current jsr instruction. */
375 static symbolS *alpha_linkage_symbol;
378 /* Whether we should automatically align data generation pseudo-ops.
379 .align 0 will turn this off. */
380 static int alpha_auto_align_on = 1;
382 /* The known current alignment of the current section. */
383 static int alpha_current_align;
385 /* These are exported to ECOFF code. */
386 unsigned long alpha_gprmask, alpha_fprmask;
388 /* Whether the debugging option was seen. */
389 static int alpha_debug;
392 /* Whether we are emitting an mdebug section. */
393 int alpha_flag_mdebug = -1;
397 /* Whether to perform the VMS procedure call optimization. */
398 int alpha_flag_replace = 1;
401 /* Don't fully resolve relocations, allowing code movement in the linker. */
402 static int alpha_flag_relax;
404 /* What value to give to bfd_set_gp_size. */
405 static int g_switch_value = 8;
408 /* Collect information about current procedure here. */
409 struct alpha_evax_procs
411 symbolS *symbol; /* Proc pdesc symbol. */
413 int framereg; /* Register for frame pointer. */
414 int framesize; /* Size of frame. */
426 /* Linked list of .linkage fixups. */
427 struct alpha_linkage_fixups *alpha_linkage_fixup_root;
428 static struct alpha_linkage_fixups *alpha_linkage_fixup_tail;
430 /* Current procedure descriptor. */
431 static struct alpha_evax_procs *alpha_evax_proc;
433 static int alpha_flag_hash_long_names = 0; /* -+ */
434 static int alpha_flag_show_after_trunc = 0; /* -H */
436 /* If the -+ switch is given, then a hash is appended to any name that is
437 longer than 64 characters, else longer symbol names are truncated. */
442 /* A table to map the spelling of a relocation operand into an appropriate
443 bfd_reloc_code_real_type type. The table is assumed to be ordered such
444 that op-O_literal indexes into it. */
446 #define ALPHA_RELOC_TABLE(op) \
447 (&alpha_reloc_op[ ((!USER_RELOC_P (op)) \
449 : (int) (op) - (int) O_literal) ])
451 #define DEF(NAME, RELOC, REQ, ALLOW) \
452 { #NAME, sizeof(#NAME)-1, O_##NAME, RELOC, REQ, ALLOW}
454 static const struct alpha_reloc_op_tag
456 const char *name; /* String to lookup. */
457 size_t length; /* Size of the string. */
458 operatorT op; /* Which operator to use. */
459 extended_bfd_reloc_code_real_type reloc;
460 unsigned int require_seq : 1; /* Require a sequence number. */
461 unsigned int allow_seq : 1; /* Allow a sequence number. */
465 DEF (literal, BFD_RELOC_ALPHA_ELF_LITERAL, 0, 1),
466 DEF (lituse_addr, DUMMY_RELOC_LITUSE_ADDR, 1, 1),
467 DEF (lituse_base, DUMMY_RELOC_LITUSE_BASE, 1, 1),
468 DEF (lituse_bytoff, DUMMY_RELOC_LITUSE_BYTOFF, 1, 1),
469 DEF (lituse_jsr, DUMMY_RELOC_LITUSE_JSR, 1, 1),
470 DEF (lituse_tlsgd, DUMMY_RELOC_LITUSE_TLSGD, 1, 1),
471 DEF (lituse_tlsldm, DUMMY_RELOC_LITUSE_TLSLDM, 1, 1),
472 DEF (lituse_jsrdirect, DUMMY_RELOC_LITUSE_JSRDIRECT, 1, 1),
473 DEF (gpdisp, BFD_RELOC_ALPHA_GPDISP, 1, 1),
474 DEF (gprelhigh, BFD_RELOC_ALPHA_GPREL_HI16, 0, 0),
475 DEF (gprellow, BFD_RELOC_ALPHA_GPREL_LO16, 0, 0),
476 DEF (gprel, BFD_RELOC_GPREL16, 0, 0),
477 DEF (samegp, BFD_RELOC_ALPHA_BRSGP, 0, 0),
478 DEF (tlsgd, BFD_RELOC_ALPHA_TLSGD, 0, 1),
479 DEF (tlsldm, BFD_RELOC_ALPHA_TLSLDM, 0, 1),
480 DEF (gotdtprel, BFD_RELOC_ALPHA_GOTDTPREL16, 0, 0),
481 DEF (dtprelhi, BFD_RELOC_ALPHA_DTPREL_HI16, 0, 0),
482 DEF (dtprello, BFD_RELOC_ALPHA_DTPREL_LO16, 0, 0),
483 DEF (dtprel, BFD_RELOC_ALPHA_DTPREL16, 0, 0),
484 DEF (gottprel, BFD_RELOC_ALPHA_GOTTPREL16, 0, 0),
485 DEF (tprelhi, BFD_RELOC_ALPHA_TPREL_HI16, 0, 0),
486 DEF (tprello, BFD_RELOC_ALPHA_TPREL_LO16, 0, 0),
487 DEF (tprel, BFD_RELOC_ALPHA_TPREL16, 0, 0),
492 static const int alpha_num_reloc_op
493 = sizeof (alpha_reloc_op) / sizeof (*alpha_reloc_op);
494 #endif /* RELOC_OP_P */
496 /* Maximum # digits needed to hold the largest sequence #. */
497 #define ALPHA_RELOC_DIGITS 25
499 /* Structure to hold explicit sequence information. */
500 struct alpha_reloc_tag
502 fixS *master; /* The literal reloc. */
504 struct symbol *sym; /* Linkage section item symbol. */
505 struct symbol *psym; /* Pdesc symbol. */
507 fixS *slaves; /* Head of linked list of lituses. */
508 segT segment; /* Segment relocs are in or undefined_section. */
509 long sequence; /* Sequence #. */
510 unsigned n_master; /* # of literals. */
511 unsigned n_slaves; /* # of lituses. */
512 unsigned saw_tlsgd : 1; /* True if ... */
513 unsigned saw_tlsldm : 1;
514 unsigned saw_lu_tlsgd : 1;
515 unsigned saw_lu_tlsldm : 1;
516 unsigned multi_section_p : 1; /* True if more than one section was used. */
517 char string[1]; /* Printable form of sequence to hash with. */
520 /* Hash table to link up literals with the appropriate lituse. */
521 static struct hash_control *alpha_literal_hash;
523 /* Sequence numbers for internal use by macros. */
524 static long next_sequence_num = -1;
526 /* A table of CPU names and opcode sets. */
528 static const struct cpu_type
535 /* Ad hoc convention: cpu number gets palcode, process code doesn't.
536 This supports usage under DU 4.0b that does ".arch ev4", and
537 usage in MILO that does -m21064. Probably something more
538 specific like -m21064-pal should be used, but oh well. */
540 { "21064", AXP_OPCODE_BASE|AXP_OPCODE_EV4 },
541 { "21064a", AXP_OPCODE_BASE|AXP_OPCODE_EV4 },
542 { "21066", AXP_OPCODE_BASE|AXP_OPCODE_EV4 },
543 { "21068", AXP_OPCODE_BASE|AXP_OPCODE_EV4 },
544 { "21164", AXP_OPCODE_BASE|AXP_OPCODE_EV5 },
545 { "21164a", AXP_OPCODE_BASE|AXP_OPCODE_EV5|AXP_OPCODE_BWX },
546 { "21164pc", (AXP_OPCODE_BASE|AXP_OPCODE_EV5|AXP_OPCODE_BWX
548 { "21264", (AXP_OPCODE_BASE|AXP_OPCODE_EV6|AXP_OPCODE_BWX
549 |AXP_OPCODE_MAX|AXP_OPCODE_CIX) },
550 { "21264a", (AXP_OPCODE_BASE|AXP_OPCODE_EV6|AXP_OPCODE_BWX
551 |AXP_OPCODE_MAX|AXP_OPCODE_CIX) },
552 { "21264b", (AXP_OPCODE_BASE|AXP_OPCODE_EV6|AXP_OPCODE_BWX
553 |AXP_OPCODE_MAX|AXP_OPCODE_CIX) },
555 { "ev4", AXP_OPCODE_BASE },
556 { "ev45", AXP_OPCODE_BASE },
557 { "lca45", AXP_OPCODE_BASE },
558 { "ev5", AXP_OPCODE_BASE },
559 { "ev56", AXP_OPCODE_BASE|AXP_OPCODE_BWX },
560 { "pca56", AXP_OPCODE_BASE|AXP_OPCODE_BWX|AXP_OPCODE_MAX },
561 { "ev6", AXP_OPCODE_BASE|AXP_OPCODE_BWX|AXP_OPCODE_MAX|AXP_OPCODE_CIX },
562 { "ev67", AXP_OPCODE_BASE|AXP_OPCODE_BWX|AXP_OPCODE_MAX|AXP_OPCODE_CIX },
563 { "ev68", AXP_OPCODE_BASE|AXP_OPCODE_BWX|AXP_OPCODE_MAX|AXP_OPCODE_CIX },
565 { "all", AXP_OPCODE_BASE },
569 /* Some instruction sets indexed by lg(size). */
570 static const char * const sextX_op[] = { "sextb", "sextw", "sextl", NULL };
571 static const char * const insXl_op[] = { "insbl", "inswl", "insll", "insql" };
572 static const char * const insXh_op[] = { NULL, "inswh", "inslh", "insqh" };
573 static const char * const extXl_op[] = { "extbl", "extwl", "extll", "extql" };
574 static const char * const extXh_op[] = { NULL, "extwh", "extlh", "extqh" };
575 static const char * const mskXl_op[] = { "mskbl", "mskwl", "mskll", "mskql" };
576 static const char * const mskXh_op[] = { NULL, "mskwh", "msklh", "mskqh" };
577 static const char * const stX_op[] = { "stb", "stw", "stl", "stq" };
578 static const char * const ldXu_op[] = { "ldbu", "ldwu", NULL, NULL };
580 static void assemble_insn (const struct alpha_opcode *, const expressionS *, int, struct alpha_insn *, extended_bfd_reloc_code_real_type);
581 static void emit_insn (struct alpha_insn *);
582 static void assemble_tokens (const char *, const expressionS *, int, int);
584 static char *s_alpha_section_name (void);
585 static symbolS *add_to_link_pool (symbolS *, symbolS *, offsetT);
588 static struct alpha_reloc_tag *
589 get_alpha_reloc_tag (long sequence)
591 char buffer[ALPHA_RELOC_DIGITS];
592 struct alpha_reloc_tag *info;
594 sprintf (buffer, "!%ld", sequence);
596 info = (struct alpha_reloc_tag *) hash_find (alpha_literal_hash, buffer);
599 size_t len = strlen (buffer);
602 info = (struct alpha_reloc_tag *)
603 xcalloc (sizeof (struct alpha_reloc_tag) + len, 1);
605 info->segment = now_seg;
606 info->sequence = sequence;
607 strcpy (info->string, buffer);
608 errmsg = hash_insert (alpha_literal_hash, info->string, (void *) info);
610 as_fatal ("%s", errmsg);
623 alpha_adjust_relocs (bfd *abfd ATTRIBUTE_UNUSED,
625 void * ptr ATTRIBUTE_UNUSED)
627 segment_info_type *seginfo = seg_info (sec);
633 /* If seginfo is NULL, we did not create this section; don't do
634 anything with it. By using a pointer to a pointer, we can update
635 the links in place. */
639 /* If there are no relocations, skip the section. */
640 if (! seginfo->fix_root)
643 /* First rebuild the fixup chain without the explicit lituse and
644 gpdisp_lo16 relocs. */
645 prevP = &seginfo->fix_root;
646 for (fixp = seginfo->fix_root; fixp; fixp = next)
648 next = fixp->fx_next;
649 fixp->fx_next = (fixS *) 0;
651 switch (fixp->fx_r_type)
653 case BFD_RELOC_ALPHA_LITUSE:
654 if (fixp->tc_fix_data.info->n_master == 0)
655 as_bad_where (fixp->fx_file, fixp->fx_line,
656 _("No !literal!%ld was found"),
657 fixp->tc_fix_data.info->sequence);
659 if (fixp->fx_offset == LITUSE_ALPHA_TLSGD)
661 if (! fixp->tc_fix_data.info->saw_tlsgd)
662 as_bad_where (fixp->fx_file, fixp->fx_line,
663 _("No !tlsgd!%ld was found"),
664 fixp->tc_fix_data.info->sequence);
666 else if (fixp->fx_offset == LITUSE_ALPHA_TLSLDM)
668 if (! fixp->tc_fix_data.info->saw_tlsldm)
669 as_bad_where (fixp->fx_file, fixp->fx_line,
670 _("No !tlsldm!%ld was found"),
671 fixp->tc_fix_data.info->sequence);
676 case BFD_RELOC_ALPHA_GPDISP_LO16:
677 if (fixp->tc_fix_data.info->n_master == 0)
678 as_bad_where (fixp->fx_file, fixp->fx_line,
679 _("No ldah !gpdisp!%ld was found"),
680 fixp->tc_fix_data.info->sequence);
683 case BFD_RELOC_ALPHA_ELF_LITERAL:
684 if (fixp->tc_fix_data.info
685 && (fixp->tc_fix_data.info->saw_tlsgd
686 || fixp->tc_fix_data.info->saw_tlsldm))
692 prevP = &fixp->fx_next;
697 /* Go back and re-chain dependent relocations. They are currently
698 linked through the next_reloc field in reverse order, so as we
699 go through the next_reloc chain, we effectively reverse the chain
702 Except if there is more than one !literal for a given sequence
703 number. In that case, the programmer and/or compiler is not sure
704 how control flows from literal to lituse, and we can't be sure to
705 get the relaxation correct.
707 ??? Well, actually we could, if there are enough lituses such that
708 we can make each literal have at least one of each lituse type
709 present. Not implemented.
711 Also suppress the optimization if the !literals/!lituses are spread
712 in different segments. This can happen with "intersting" uses of
713 inline assembly; examples are present in the Linux kernel semaphores. */
715 for (fixp = seginfo->fix_root; fixp; fixp = next)
717 next = fixp->fx_next;
718 switch (fixp->fx_r_type)
720 case BFD_RELOC_ALPHA_TLSGD:
721 case BFD_RELOC_ALPHA_TLSLDM:
722 if (!fixp->tc_fix_data.info)
724 if (fixp->tc_fix_data.info->n_master == 0)
726 else if (fixp->tc_fix_data.info->n_master > 1)
728 as_bad_where (fixp->fx_file, fixp->fx_line,
729 _("too many !literal!%ld for %s"),
730 fixp->tc_fix_data.info->sequence,
731 (fixp->fx_r_type == BFD_RELOC_ALPHA_TLSGD
732 ? "!tlsgd" : "!tlsldm"));
736 fixp->tc_fix_data.info->master->fx_next = fixp->fx_next;
737 fixp->fx_next = fixp->tc_fix_data.info->master;
738 fixp = fixp->fx_next;
741 case BFD_RELOC_ALPHA_ELF_LITERAL:
742 if (fixp->tc_fix_data.info
743 && fixp->tc_fix_data.info->n_master == 1
744 && ! fixp->tc_fix_data.info->multi_section_p)
746 for (slave = fixp->tc_fix_data.info->slaves;
748 slave = slave->tc_fix_data.next_reloc)
750 slave->fx_next = fixp->fx_next;
751 fixp->fx_next = slave;
756 case BFD_RELOC_ALPHA_GPDISP_HI16:
757 if (fixp->tc_fix_data.info->n_slaves == 0)
758 as_bad_where (fixp->fx_file, fixp->fx_line,
759 _("No lda !gpdisp!%ld was found"),
760 fixp->tc_fix_data.info->sequence);
763 slave = fixp->tc_fix_data.info->slaves;
764 slave->fx_next = next;
765 fixp->fx_next = slave;
775 /* Before the relocations are written, reorder them, so that user
776 supplied !lituse relocations follow the appropriate !literal
777 relocations, and similarly for !gpdisp relocations. */
780 alpha_before_fix (void)
782 if (alpha_literal_hash)
783 bfd_map_over_sections (stdoutput, alpha_adjust_relocs, NULL);
790 debug_exp (expressionS tok[], int ntok)
794 fprintf (stderr, "debug_exp: %d tokens", ntok);
795 for (i = 0; i < ntok; i++)
797 expressionS *t = &tok[i];
802 default: name = "unknown"; break;
803 case O_illegal: name = "O_illegal"; break;
804 case O_absent: name = "O_absent"; break;
805 case O_constant: name = "O_constant"; break;
806 case O_symbol: name = "O_symbol"; break;
807 case O_symbol_rva: name = "O_symbol_rva"; break;
808 case O_register: name = "O_register"; break;
809 case O_big: name = "O_big"; break;
810 case O_uminus: name = "O_uminus"; break;
811 case O_bit_not: name = "O_bit_not"; break;
812 case O_logical_not: name = "O_logical_not"; break;
813 case O_multiply: name = "O_multiply"; break;
814 case O_divide: name = "O_divide"; break;
815 case O_modulus: name = "O_modulus"; break;
816 case O_left_shift: name = "O_left_shift"; break;
817 case O_right_shift: name = "O_right_shift"; break;
818 case O_bit_inclusive_or: name = "O_bit_inclusive_or"; break;
819 case O_bit_or_not: name = "O_bit_or_not"; break;
820 case O_bit_exclusive_or: name = "O_bit_exclusive_or"; break;
821 case O_bit_and: name = "O_bit_and"; break;
822 case O_add: name = "O_add"; break;
823 case O_subtract: name = "O_subtract"; break;
824 case O_eq: name = "O_eq"; break;
825 case O_ne: name = "O_ne"; break;
826 case O_lt: name = "O_lt"; break;
827 case O_le: name = "O_le"; break;
828 case O_ge: name = "O_ge"; break;
829 case O_gt: name = "O_gt"; break;
830 case O_logical_and: name = "O_logical_and"; break;
831 case O_logical_or: name = "O_logical_or"; break;
832 case O_index: name = "O_index"; break;
833 case O_pregister: name = "O_pregister"; break;
834 case O_cpregister: name = "O_cpregister"; break;
835 case O_literal: name = "O_literal"; break;
836 case O_lituse_addr: name = "O_lituse_addr"; break;
837 case O_lituse_base: name = "O_lituse_base"; break;
838 case O_lituse_bytoff: name = "O_lituse_bytoff"; break;
839 case O_lituse_jsr: name = "O_lituse_jsr"; break;
840 case O_lituse_tlsgd: name = "O_lituse_tlsgd"; break;
841 case O_lituse_tlsldm: name = "O_lituse_tlsldm"; break;
842 case O_lituse_jsrdirect: name = "O_lituse_jsrdirect"; break;
843 case O_gpdisp: name = "O_gpdisp"; break;
844 case O_gprelhigh: name = "O_gprelhigh"; break;
845 case O_gprellow: name = "O_gprellow"; break;
846 case O_gprel: name = "O_gprel"; break;
847 case O_samegp: name = "O_samegp"; break;
848 case O_tlsgd: name = "O_tlsgd"; break;
849 case O_tlsldm: name = "O_tlsldm"; break;
850 case O_gotdtprel: name = "O_gotdtprel"; break;
851 case O_dtprelhi: name = "O_dtprelhi"; break;
852 case O_dtprello: name = "O_dtprello"; break;
853 case O_dtprel: name = "O_dtprel"; break;
854 case O_gottprel: name = "O_gottprel"; break;
855 case O_tprelhi: name = "O_tprelhi"; break;
856 case O_tprello: name = "O_tprello"; break;
857 case O_tprel: name = "O_tprel"; break;
860 fprintf (stderr, ", %s(%s, %s, %d)", name,
861 (t->X_add_symbol) ? S_GET_NAME (t->X_add_symbol) : "--",
862 (t->X_op_symbol) ? S_GET_NAME (t->X_op_symbol) : "--",
863 (int) t->X_add_number);
865 fprintf (stderr, "\n");
870 /* Parse the arguments to an opcode. */
873 tokenize_arguments (char *str,
877 expressionS *end_tok = tok + ntok;
878 char *old_input_line_pointer;
879 int saw_comma = 0, saw_arg = 0;
881 expressionS *orig_tok = tok;
885 const struct alpha_reloc_op_tag *r;
888 int reloc_found_p = 0;
891 memset (tok, 0, sizeof (*tok) * ntok);
893 /* Save and restore input_line_pointer around this function. */
894 old_input_line_pointer = input_line_pointer;
895 input_line_pointer = str;
898 /* ??? Wrest control of ! away from the regular expression parser. */
899 is_end_of_line[(unsigned char) '!'] = 1;
902 while (tok < end_tok && *input_line_pointer)
905 switch (*input_line_pointer)
912 /* A relocation operand can be placed after the normal operand on an
913 assembly language statement, and has the following form:
914 !relocation_type!sequence_number. */
917 /* Only support one relocation op per insn. */
918 as_bad (_("More than one relocation op per insn"));
925 ++input_line_pointer;
927 p = input_line_pointer;
928 c = get_symbol_end ();
930 /* Parse !relocation_type. */
931 len = input_line_pointer - p;
934 as_bad (_("No relocation operand"));
938 r = &alpha_reloc_op[0];
939 for (i = alpha_num_reloc_op - 1; i >= 0; i--, r++)
940 if (len == r->length && memcmp (p, r->name, len) == 0)
944 as_bad (_("Unknown relocation operand: !%s"), p);
948 *input_line_pointer = c;
950 if (*input_line_pointer != '!')
954 as_bad (_("no sequence number after !%s"), p);
958 tok->X_add_number = 0;
964 as_bad (_("!%s does not use a sequence number"), p);
968 input_line_pointer++;
970 /* Parse !sequence_number. */
972 if (tok->X_op != O_constant || tok->X_add_number <= 0)
974 as_bad (_("Bad sequence number: !%s!%s"),
975 r->name, input_line_pointer);
984 #endif /* RELOC_OP_P */
987 ++input_line_pointer;
988 if (saw_comma || !saw_arg)
995 char *hold = input_line_pointer++;
997 /* First try for parenthesized register ... */
999 if (*input_line_pointer == ')' && tok->X_op == O_register)
1001 tok->X_op = (saw_comma ? O_cpregister : O_pregister);
1004 ++input_line_pointer;
1009 /* ... then fall through to plain expression. */
1010 input_line_pointer = hold;
1014 if (saw_arg && !saw_comma)
1018 if (tok->X_op == O_illegal || tok->X_op == O_absent)
1031 input_line_pointer = old_input_line_pointer;
1034 debug_exp (orig_tok, ntok - (end_tok - tok));
1037 is_end_of_line[(unsigned char) '!'] = 0;
1040 return ntok - (end_tok - tok);
1044 is_end_of_line[(unsigned char) '!'] = 0;
1046 input_line_pointer = old_input_line_pointer;
1047 return TOKENIZE_ERROR;
1051 is_end_of_line[(unsigned char) '!'] = 0;
1053 input_line_pointer = old_input_line_pointer;
1054 return TOKENIZE_ERROR_REPORT;
1057 /* Search forward through all variants of an opcode looking for a
1060 static const struct alpha_opcode *
1061 find_opcode_match (const struct alpha_opcode *first_opcode,
1062 const expressionS *tok,
1066 const struct alpha_opcode *opcode = first_opcode;
1068 int got_cpu_match = 0;
1072 const unsigned char *opidx;
1075 /* Don't match opcodes that don't exist on this architecture. */
1076 if (!(opcode->flags & alpha_target))
1081 for (opidx = opcode->operands; *opidx; ++opidx)
1083 const struct alpha_operand *operand = &alpha_operands[*opidx];
1085 /* Only take input from real operands. */
1086 if (operand->flags & AXP_OPERAND_FAKE)
1089 /* When we expect input, make sure we have it. */
1092 if ((operand->flags & AXP_OPERAND_OPTIONAL_MASK) == 0)
1097 /* Match operand type with expression type. */
1098 switch (operand->flags & AXP_OPERAND_TYPECHECK_MASK)
1100 case AXP_OPERAND_IR:
1101 if (tok[tokidx].X_op != O_register
1102 || !is_ir_num (tok[tokidx].X_add_number))
1105 case AXP_OPERAND_FPR:
1106 if (tok[tokidx].X_op != O_register
1107 || !is_fpr_num (tok[tokidx].X_add_number))
1110 case AXP_OPERAND_IR | AXP_OPERAND_PARENS:
1111 if (tok[tokidx].X_op != O_pregister
1112 || !is_ir_num (tok[tokidx].X_add_number))
1115 case AXP_OPERAND_IR | AXP_OPERAND_PARENS | AXP_OPERAND_COMMA:
1116 if (tok[tokidx].X_op != O_cpregister
1117 || !is_ir_num (tok[tokidx].X_add_number))
1121 case AXP_OPERAND_RELATIVE:
1122 case AXP_OPERAND_SIGNED:
1123 case AXP_OPERAND_UNSIGNED:
1124 switch (tok[tokidx].X_op)
1139 /* Everything else should have been fake. */
1145 /* Possible match -- did we use all of our input? */
1154 while (++opcode - alpha_opcodes < (int) alpha_num_opcodes
1155 && !strcmp (opcode->name, first_opcode->name));
1158 *pcpumatch = got_cpu_match;
1163 /* Given an opcode name and a pre-tokenized set of arguments, assemble
1164 the insn, but do not emit it.
1166 Note that this implies no macros allowed, since we can't store more
1167 than one insn in an insn structure. */
1170 assemble_tokens_to_insn (const char *opname,
1171 const expressionS *tok,
1173 struct alpha_insn *insn)
1175 const struct alpha_opcode *opcode;
1177 /* Search opcodes. */
1178 opcode = (const struct alpha_opcode *) hash_find (alpha_opcode_hash, opname);
1182 opcode = find_opcode_match (opcode, tok, &ntok, &cpumatch);
1185 assemble_insn (opcode, tok, ntok, insn, BFD_RELOC_UNUSED);
1189 as_bad (_("inappropriate arguments for opcode `%s'"), opname);
1191 as_bad (_("opcode `%s' not supported for target %s"), opname,
1195 as_bad (_("unknown opcode `%s'"), opname);
1198 /* Build a BFD section with its flags set appropriately for the .lita,
1199 .lit8, or .lit4 sections. */
1202 create_literal_section (const char *name,
1206 segT current_section = now_seg;
1207 int current_subsec = now_subseg;
1210 *secp = new_sec = subseg_new (name, 0);
1211 subseg_set (current_section, current_subsec);
1212 bfd_set_section_alignment (stdoutput, new_sec, 4);
1213 bfd_set_section_flags (stdoutput, new_sec,
1214 SEC_RELOC | SEC_ALLOC | SEC_LOAD | SEC_READONLY
1217 S_CLEAR_EXTERNAL (*symp = section_symbol (new_sec));
1220 /* Load a (partial) expression into a target register.
1222 If poffset is not null, after the call it will either contain
1223 O_constant 0, or a 16-bit offset appropriate for any MEM format
1224 instruction. In addition, pbasereg will be modified to point to
1225 the base register to use in that MEM format instruction.
1227 In any case, *pbasereg should contain a base register to add to the
1228 expression. This will normally be either AXP_REG_ZERO or
1229 alpha_gp_register. Symbol addresses will always be loaded via $gp,
1230 so "foo($0)" is interpreted as adding the address of foo to $0;
1231 i.e. "ldq $targ, LIT($gp); addq $targ, $0, $targ". Odd, perhaps,
1232 but this is what OSF/1 does.
1234 If explicit relocations of the form !literal!<number> are allowed,
1235 and used, then explicit_reloc with be an expression pointer.
1237 Finally, the return value is nonzero if the calling macro may emit
1238 a LITUSE reloc if otherwise appropriate; the return value is the
1239 sequence number to use. */
1242 load_expression (int targreg,
1243 const expressionS *exp,
1245 expressionS *poffset,
1248 long emit_lituse = 0;
1249 offsetT addend = exp->X_add_number;
1250 int basereg = *pbasereg;
1251 struct alpha_insn insn;
1252 expressionS newtok[3];
1261 /* Attempt to reduce .lit load by splitting the offset from
1262 its symbol when possible, but don't create a situation in
1264 if (!range_signed_32 (addend) &&
1265 (alpha_noat_on || targreg == AXP_REG_AT))
1267 lit = add_to_literal_pool (exp->X_add_symbol, addend,
1268 alpha_lita_section, 8);
1272 lit = add_to_literal_pool (exp->X_add_symbol, 0,
1273 alpha_lita_section, 8);
1276 as_fatal (_("overflow in literal (.lita) table"));
1278 /* Emit "ldq r, lit(gp)". */
1280 if (basereg != alpha_gp_register && targreg == basereg)
1283 as_bad (_("macro requires $at register while noat in effect"));
1284 if (targreg == AXP_REG_AT)
1285 as_bad (_("macro requires $at while $at in use"));
1287 set_tok_reg (newtok[0], AXP_REG_AT);
1290 set_tok_reg (newtok[0], targreg);
1292 set_tok_sym (newtok[1], alpha_lita_symbol, lit);
1293 set_tok_preg (newtok[2], alpha_gp_register);
1295 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1297 gas_assert (insn.nfixups == 1);
1298 insn.fixups[0].reloc = BFD_RELOC_ALPHA_LITERAL;
1299 insn.sequence = emit_lituse = next_sequence_num--;
1300 #endif /* OBJ_ECOFF */
1302 /* Emit "ldq r, gotoff(gp)". */
1304 if (basereg != alpha_gp_register && targreg == basereg)
1307 as_bad (_("macro requires $at register while noat in effect"));
1308 if (targreg == AXP_REG_AT)
1309 as_bad (_("macro requires $at while $at in use"));
1311 set_tok_reg (newtok[0], AXP_REG_AT);
1314 set_tok_reg (newtok[0], targreg);
1316 /* XXX: Disable this .got minimizing optimization so that we can get
1317 better instruction offset knowledge in the compiler. This happens
1318 very infrequently anyway. */
1320 || (!range_signed_32 (addend)
1321 && (alpha_noat_on || targreg == AXP_REG_AT)))
1327 set_tok_sym (newtok[1], exp->X_add_symbol, 0);
1329 set_tok_preg (newtok[2], alpha_gp_register);
1331 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1333 gas_assert (insn.nfixups == 1);
1334 insn.fixups[0].reloc = BFD_RELOC_ALPHA_ELF_LITERAL;
1335 insn.sequence = emit_lituse = next_sequence_num--;
1336 #endif /* OBJ_ELF */
1338 /* Find symbol or symbol pointer in link section. */
1340 if (exp->X_add_symbol == alpha_evax_proc->symbol)
1342 /* Linkage-relative expression. */
1343 set_tok_reg (newtok[0], targreg);
1345 if (range_signed_16 (addend))
1347 set_tok_const (newtok[1], addend);
1352 set_tok_const (newtok[1], 0);
1354 set_tok_preg (newtok[2], basereg);
1355 assemble_tokens_to_insn ("lda", newtok, 3, &insn);
1359 const char *symname = S_GET_NAME (exp->X_add_symbol);
1360 const char *ptr1, *ptr2;
1361 int symlen = strlen (symname);
1364 strcmp (ptr2 = &symname [symlen - 4], "..lk") == 0))
1366 /* Access to an item whose address is stored in the linkage
1367 section. Just read the address. */
1368 set_tok_reg (newtok[0], targreg);
1371 newtok[1].X_op = O_subtract;
1372 newtok[1].X_op_symbol = alpha_evax_proc->symbol;
1374 set_tok_preg (newtok[2], basereg);
1375 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1376 alpha_linkage_symbol = exp->X_add_symbol;
1379 set_tok_const (*poffset, 0);
1381 if (alpha_flag_replace && targreg == 26)
1383 /* Add a NOP fixup for 'ldX $26,YYY..NAME..lk'. */
1387 /* Build the entry name as 'NAME..en'. */
1388 ptr1 = strstr (symname, "..") + 2;
1391 ensymname = (char *) xmalloc (ptr2 - ptr1 + 5);
1392 memcpy (ensymname, ptr1, ptr2 - ptr1);
1393 memcpy (ensymname + (ptr2 - ptr1), "..en", 5);
1395 gas_assert (insn.nfixups + 1 <= MAX_INSN_FIXUPS);
1396 insn.fixups[insn.nfixups].reloc = BFD_RELOC_ALPHA_NOP;
1397 ensym = symbol_find_or_make (ensymname);
1399 /* The fixup must be the same as the BFD_RELOC_ALPHA_BOH
1400 case in emit_jsrjmp. See B.4.5.2 of the OpenVMS Linker
1402 insn.fixups[insn.nfixups].exp.X_op = O_symbol;
1403 insn.fixups[insn.nfixups].exp.X_add_symbol = ensym;
1404 insn.fixups[insn.nfixups].exp.X_add_number = 0;
1405 insn.fixups[insn.nfixups].xtrasym = alpha_linkage_symbol;
1406 insn.fixups[insn.nfixups].procsym = alpha_evax_proc->symbol;
1409 /* ??? Force bsym to be instantiated now, as it will be
1410 too late to do so in tc_gen_reloc. */
1411 symbol_get_bfdsym (exp->X_add_symbol);
1413 else if (alpha_flag_replace && targreg == 27)
1415 /* Add a lda fixup for 'ldX $27,YYY.NAME..lk+8'. */
1420 ptr1 = strstr (symname, "..") + 2;
1423 psymname = (char *) xmalloc (ptr2 - ptr1 + 1);
1424 memcpy (psymname, ptr1, ptr2 - ptr1);
1425 psymname [ptr2 - ptr1] = 0;
1427 gas_assert (insn.nfixups + 1 <= MAX_INSN_FIXUPS);
1428 insn.fixups[insn.nfixups].reloc = BFD_RELOC_ALPHA_LDA;
1429 psym = symbol_find_or_make (psymname);
1431 insn.fixups[insn.nfixups].exp.X_op = O_subtract;
1432 insn.fixups[insn.nfixups].exp.X_add_symbol = psym;
1433 insn.fixups[insn.nfixups].exp.X_op_symbol = alpha_evax_proc->symbol;
1434 insn.fixups[insn.nfixups].exp.X_add_number = 0;
1435 insn.fixups[insn.nfixups].xtrasym = alpha_linkage_symbol;
1436 insn.fixups[insn.nfixups].procsym = alpha_evax_proc->symbol;
1445 /* Not in the linkage section. Put the value into the linkage
1449 if (!range_signed_32 (addend))
1450 addend = sign_extend_32 (addend);
1451 linkexp = add_to_link_pool (alpha_evax_proc->symbol,
1452 exp->X_add_symbol, 0);
1453 set_tok_reg (newtok[0], targreg);
1454 set_tok_sym (newtok[1], linkexp, 0);
1455 set_tok_preg (newtok[2], basereg);
1456 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1459 #endif /* OBJ_EVAX */
1464 if (basereg != alpha_gp_register && basereg != AXP_REG_ZERO)
1466 /* Emit "addq r, base, r". */
1468 set_tok_reg (newtok[1], basereg);
1469 set_tok_reg (newtok[2], targreg);
1470 assemble_tokens ("addq", newtok, 3, 0);
1481 /* Assume that this difference expression will be resolved to an
1482 absolute value and that that value will fit in 16 bits. */
1484 set_tok_reg (newtok[0], targreg);
1486 set_tok_preg (newtok[2], basereg);
1487 assemble_tokens (opname, newtok, 3, 0);
1490 set_tok_const (*poffset, 0);
1494 if (exp->X_add_number > 0)
1495 as_bad (_("bignum invalid; zero assumed"));
1497 as_bad (_("floating point number invalid; zero assumed"));
1502 as_bad (_("can't handle expression"));
1507 if (!range_signed_32 (addend))
1513 long seq_num = next_sequence_num--;
1516 /* For 64-bit addends, just put it in the literal pool. */
1518 /* Emit "ldq targreg, lit(basereg)". */
1519 litexp = add_to_link_pool (alpha_evax_proc->symbol,
1520 section_symbol (absolute_section), addend);
1521 set_tok_reg (newtok[0], targreg);
1522 set_tok_sym (newtok[1], litexp, 0);
1523 set_tok_preg (newtok[2], alpha_gp_register);
1524 assemble_tokens ("ldq", newtok, 3, 0);
1527 if (alpha_lit8_section == NULL)
1529 create_literal_section (".lit8",
1530 &alpha_lit8_section,
1531 &alpha_lit8_symbol);
1534 alpha_lit8_literal = add_to_literal_pool (alpha_lit8_symbol, 0x8000,
1535 alpha_lita_section, 8);
1536 if (alpha_lit8_literal >= 0x8000)
1537 as_fatal (_("overflow in literal (.lita) table"));
1541 lit = add_to_literal_pool (NULL, addend, alpha_lit8_section, 8) - 0x8000;
1543 as_fatal (_("overflow in literal (.lit8) table"));
1545 /* Emit "lda litreg, .lit8+0x8000". */
1547 if (targreg == basereg)
1550 as_bad (_("macro requires $at register while noat in effect"));
1551 if (targreg == AXP_REG_AT)
1552 as_bad (_("macro requires $at while $at in use"));
1554 set_tok_reg (newtok[0], AXP_REG_AT);
1557 set_tok_reg (newtok[0], targreg);
1559 set_tok_sym (newtok[1], alpha_lita_symbol, alpha_lit8_literal);
1562 set_tok_sym (newtok[1], alpha_lit8_symbol, 0x8000);
1564 set_tok_preg (newtok[2], alpha_gp_register);
1566 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1568 gas_assert (insn.nfixups == 1);
1570 insn.fixups[0].reloc = BFD_RELOC_ALPHA_LITERAL;
1573 insn.fixups[0].reloc = BFD_RELOC_ALPHA_ELF_LITERAL;
1575 insn.sequence = seq_num;
1579 /* Emit "ldq litreg, lit(litreg)". */
1581 set_tok_const (newtok[1], lit);
1582 set_tok_preg (newtok[2], newtok[0].X_add_number);
1584 assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
1586 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
1587 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
1588 insn.fixups[insn.nfixups].exp.X_op = O_absent;
1590 insn.sequence = seq_num;
1595 /* Emit "addq litreg, base, target". */
1597 if (basereg != AXP_REG_ZERO)
1599 set_tok_reg (newtok[1], basereg);
1600 set_tok_reg (newtok[2], targreg);
1601 assemble_tokens ("addq", newtok, 3, 0);
1603 #endif /* !OBJ_EVAX */
1606 set_tok_const (*poffset, 0);
1607 *pbasereg = targreg;
1611 offsetT low, high, extra, tmp;
1613 /* For 32-bit operands, break up the addend. */
1615 low = sign_extend_16 (addend);
1617 high = sign_extend_16 (tmp >> 16);
1619 if (tmp - (high << 16))
1623 high = sign_extend_16 (tmp >> 16);
1628 set_tok_reg (newtok[0], targreg);
1629 set_tok_preg (newtok[2], basereg);
1633 /* Emit "ldah r, extra(r). */
1634 set_tok_const (newtok[1], extra);
1635 assemble_tokens ("ldah", newtok, 3, 0);
1636 set_tok_preg (newtok[2], basereg = targreg);
1641 /* Emit "ldah r, high(r). */
1642 set_tok_const (newtok[1], high);
1643 assemble_tokens ("ldah", newtok, 3, 0);
1645 set_tok_preg (newtok[2], basereg);
1648 if ((low && !poffset) || (!poffset && basereg != targreg))
1650 /* Emit "lda r, low(base)". */
1651 set_tok_const (newtok[1], low);
1652 assemble_tokens ("lda", newtok, 3, 0);
1658 set_tok_const (*poffset, low);
1659 *pbasereg = basereg;
1665 /* The lda macro differs from the lda instruction in that it handles
1666 most simple expressions, particularly symbol address loads and
1670 emit_lda (const expressionS *tok,
1672 const void * unused ATTRIBUTE_UNUSED)
1677 basereg = (tok[1].X_op == O_constant ? AXP_REG_ZERO : alpha_gp_register);
1679 basereg = tok[2].X_add_number;
1681 (void) load_expression (tok[0].X_add_number, &tok[1], &basereg, NULL, "lda");
1684 /* The ldah macro differs from the ldah instruction in that it has $31
1685 as an implied base register. */
1688 emit_ldah (const expressionS *tok,
1689 int ntok ATTRIBUTE_UNUSED,
1690 const void * unused ATTRIBUTE_UNUSED)
1692 expressionS newtok[3];
1696 set_tok_preg (newtok[2], AXP_REG_ZERO);
1698 assemble_tokens ("ldah", newtok, 3, 0);
1701 /* Called internally to handle all alignment needs. This takes care
1702 of eliding calls to frag_align if'n the cached current alignment
1703 says we've already got it, as well as taking care of the auto-align
1704 feature wrt labels. */
1710 int force ATTRIBUTE_UNUSED)
1712 if (alpha_current_align >= n)
1717 if (subseg_text_p (now_seg))
1718 frag_align_code (n, 0);
1720 frag_align (n, 0, 0);
1723 frag_align (n, *pfill, 0);
1725 alpha_current_align = n;
1727 if (label != NULL && S_GET_SEGMENT (label) == now_seg)
1729 symbol_set_frag (label, frag_now);
1730 S_SET_VALUE (label, (valueT) frag_now_fix ());
1733 record_alignment (now_seg, n);
1735 /* ??? If alpha_flag_relax && force && elf, record the requested alignment
1736 in a reloc for the linker to see. */
1739 /* Actually output an instruction with its fixup. */
1742 emit_insn (struct alpha_insn *insn)
1747 /* Take care of alignment duties. */
1748 if (alpha_auto_align_on && alpha_current_align < 2)
1749 alpha_align (2, (char *) NULL, alpha_insn_label, 0);
1750 if (alpha_current_align > 2)
1751 alpha_current_align = 2;
1752 alpha_insn_label = NULL;
1754 /* Write out the instruction. */
1756 md_number_to_chars (f, insn->insn, 4);
1759 dwarf2_emit_insn (4);
1762 /* Apply the fixups in order. */
1763 for (i = 0; i < insn->nfixups; ++i)
1765 const struct alpha_operand *operand = (const struct alpha_operand *) 0;
1766 struct alpha_fixup *fixup = &insn->fixups[i];
1767 struct alpha_reloc_tag *info = NULL;
1771 /* Some fixups are only used internally and so have no howto. */
1772 if ((int) fixup->reloc < 0)
1774 operand = &alpha_operands[-(int) fixup->reloc];
1776 pcrel = ((operand->flags & AXP_OPERAND_RELATIVE) != 0);
1778 else if (fixup->reloc > BFD_RELOC_UNUSED
1779 || fixup->reloc == BFD_RELOC_ALPHA_GPDISP_HI16
1780 || fixup->reloc == BFD_RELOC_ALPHA_GPDISP_LO16)
1787 reloc_howto_type *reloc_howto =
1788 bfd_reloc_type_lookup (stdoutput,
1789 (bfd_reloc_code_real_type) fixup->reloc);
1790 gas_assert (reloc_howto);
1792 size = bfd_get_reloc_size (reloc_howto);
1794 switch (fixup->reloc)
1797 case BFD_RELOC_ALPHA_NOP:
1798 case BFD_RELOC_ALPHA_BSR:
1799 case BFD_RELOC_ALPHA_LDA:
1800 case BFD_RELOC_ALPHA_BOH:
1804 gas_assert (size >= 1 && size <= 4);
1807 pcrel = reloc_howto->pc_relative;
1810 fixP = fix_new_exp (frag_now, f - frag_now->fr_literal, size,
1811 &fixup->exp, pcrel, (bfd_reloc_code_real_type) fixup->reloc);
1813 /* Turn off complaints that the addend is too large for some fixups,
1814 and copy in the sequence number for the explicit relocations. */
1815 switch (fixup->reloc)
1817 case BFD_RELOC_ALPHA_HINT:
1818 case BFD_RELOC_GPREL32:
1819 case BFD_RELOC_GPREL16:
1820 case BFD_RELOC_ALPHA_GPREL_HI16:
1821 case BFD_RELOC_ALPHA_GPREL_LO16:
1822 case BFD_RELOC_ALPHA_GOTDTPREL16:
1823 case BFD_RELOC_ALPHA_DTPREL_HI16:
1824 case BFD_RELOC_ALPHA_DTPREL_LO16:
1825 case BFD_RELOC_ALPHA_DTPREL16:
1826 case BFD_RELOC_ALPHA_GOTTPREL16:
1827 case BFD_RELOC_ALPHA_TPREL_HI16:
1828 case BFD_RELOC_ALPHA_TPREL_LO16:
1829 case BFD_RELOC_ALPHA_TPREL16:
1830 fixP->fx_no_overflow = 1;
1833 case BFD_RELOC_ALPHA_GPDISP_HI16:
1834 fixP->fx_no_overflow = 1;
1835 fixP->fx_addsy = section_symbol (now_seg);
1836 fixP->fx_offset = 0;
1838 info = get_alpha_reloc_tag (insn->sequence);
1839 if (++info->n_master > 1)
1840 as_bad (_("too many ldah insns for !gpdisp!%ld"), insn->sequence);
1841 if (info->segment != now_seg)
1842 as_bad (_("both insns for !gpdisp!%ld must be in the same section"),
1844 fixP->tc_fix_data.info = info;
1847 case BFD_RELOC_ALPHA_GPDISP_LO16:
1848 fixP->fx_no_overflow = 1;
1850 info = get_alpha_reloc_tag (insn->sequence);
1851 if (++info->n_slaves > 1)
1852 as_bad (_("too many lda insns for !gpdisp!%ld"), insn->sequence);
1853 if (info->segment != now_seg)
1854 as_bad (_("both insns for !gpdisp!%ld must be in the same section"),
1856 fixP->tc_fix_data.info = info;
1857 info->slaves = fixP;
1860 case BFD_RELOC_ALPHA_LITERAL:
1861 case BFD_RELOC_ALPHA_ELF_LITERAL:
1862 fixP->fx_no_overflow = 1;
1864 if (insn->sequence == 0)
1866 info = get_alpha_reloc_tag (insn->sequence);
1867 info->master = fixP;
1869 if (info->segment != now_seg)
1870 info->multi_section_p = 1;
1871 fixP->tc_fix_data.info = info;
1875 case DUMMY_RELOC_LITUSE_ADDR:
1876 fixP->fx_offset = LITUSE_ALPHA_ADDR;
1878 case DUMMY_RELOC_LITUSE_BASE:
1879 fixP->fx_offset = LITUSE_ALPHA_BASE;
1881 case DUMMY_RELOC_LITUSE_BYTOFF:
1882 fixP->fx_offset = LITUSE_ALPHA_BYTOFF;
1884 case DUMMY_RELOC_LITUSE_JSR:
1885 fixP->fx_offset = LITUSE_ALPHA_JSR;
1887 case DUMMY_RELOC_LITUSE_TLSGD:
1888 fixP->fx_offset = LITUSE_ALPHA_TLSGD;
1890 case DUMMY_RELOC_LITUSE_TLSLDM:
1891 fixP->fx_offset = LITUSE_ALPHA_TLSLDM;
1893 case DUMMY_RELOC_LITUSE_JSRDIRECT:
1894 fixP->fx_offset = LITUSE_ALPHA_JSRDIRECT;
1897 fixP->fx_addsy = section_symbol (now_seg);
1898 fixP->fx_r_type = BFD_RELOC_ALPHA_LITUSE;
1900 info = get_alpha_reloc_tag (insn->sequence);
1901 if (fixup->reloc == DUMMY_RELOC_LITUSE_TLSGD)
1902 info->saw_lu_tlsgd = 1;
1903 else if (fixup->reloc == DUMMY_RELOC_LITUSE_TLSLDM)
1904 info->saw_lu_tlsldm = 1;
1905 if (++info->n_slaves > 1)
1907 if (info->saw_lu_tlsgd)
1908 as_bad (_("too many lituse insns for !lituse_tlsgd!%ld"),
1910 else if (info->saw_lu_tlsldm)
1911 as_bad (_("too many lituse insns for !lituse_tlsldm!%ld"),
1914 fixP->tc_fix_data.info = info;
1915 fixP->tc_fix_data.next_reloc = info->slaves;
1916 info->slaves = fixP;
1917 if (info->segment != now_seg)
1918 info->multi_section_p = 1;
1921 case BFD_RELOC_ALPHA_TLSGD:
1922 fixP->fx_no_overflow = 1;
1924 if (insn->sequence == 0)
1926 info = get_alpha_reloc_tag (insn->sequence);
1927 if (info->saw_tlsgd)
1928 as_bad (_("duplicate !tlsgd!%ld"), insn->sequence);
1929 else if (info->saw_tlsldm)
1930 as_bad (_("sequence number in use for !tlsldm!%ld"),
1933 info->saw_tlsgd = 1;
1934 fixP->tc_fix_data.info = info;
1937 case BFD_RELOC_ALPHA_TLSLDM:
1938 fixP->fx_no_overflow = 1;
1940 if (insn->sequence == 0)
1942 info = get_alpha_reloc_tag (insn->sequence);
1943 if (info->saw_tlsldm)
1944 as_bad (_("duplicate !tlsldm!%ld"), insn->sequence);
1945 else if (info->saw_tlsgd)
1946 as_bad (_("sequence number in use for !tlsgd!%ld"),
1949 info->saw_tlsldm = 1;
1950 fixP->tc_fix_data.info = info;
1954 case BFD_RELOC_ALPHA_NOP:
1955 case BFD_RELOC_ALPHA_LDA:
1956 case BFD_RELOC_ALPHA_BSR:
1957 case BFD_RELOC_ALPHA_BOH:
1958 info = get_alpha_reloc_tag (next_sequence_num--);
1959 fixP->tc_fix_data.info = info;
1960 fixP->tc_fix_data.info->sym = fixup->xtrasym;
1961 fixP->tc_fix_data.info->psym = fixup->procsym;
1966 if ((int) fixup->reloc < 0)
1968 if (operand->flags & AXP_OPERAND_NOOVERFLOW)
1969 fixP->fx_no_overflow = 1;
1976 /* Insert an operand value into an instruction. */
1979 insert_operand (unsigned insn,
1980 const struct alpha_operand *operand,
1985 if (operand->bits != 32 && !(operand->flags & AXP_OPERAND_NOOVERFLOW))
1989 if (operand->flags & AXP_OPERAND_SIGNED)
1991 max = (1 << (operand->bits - 1)) - 1;
1992 min = -(1 << (operand->bits - 1));
1996 max = (1 << operand->bits) - 1;
2000 if (val < min || val > max)
2001 as_warn_value_out_of_range (_("operand"), val, min, max, file, line);
2004 if (operand->insert)
2006 const char *errmsg = NULL;
2008 insn = (*operand->insert) (insn, val, &errmsg);
2010 as_warn ("%s", errmsg);
2013 insn |= ((val & ((1 << operand->bits) - 1)) << operand->shift);
2018 /* Turn an opcode description and a set of arguments into
2019 an instruction and a fixup. */
2022 assemble_insn (const struct alpha_opcode *opcode,
2023 const expressionS *tok,
2025 struct alpha_insn *insn,
2026 extended_bfd_reloc_code_real_type reloc)
2028 const struct alpha_operand *reloc_operand = NULL;
2029 const expressionS *reloc_exp = NULL;
2030 const unsigned char *argidx;
2034 memset (insn, 0, sizeof (*insn));
2035 image = opcode->opcode;
2037 for (argidx = opcode->operands; *argidx; ++argidx)
2039 const struct alpha_operand *operand = &alpha_operands[*argidx];
2040 const expressionS *t = (const expressionS *) 0;
2042 if (operand->flags & AXP_OPERAND_FAKE)
2044 /* Fake operands take no value and generate no fixup. */
2045 image = insert_operand (image, operand, 0, NULL, 0);
2051 switch (operand->flags & AXP_OPERAND_OPTIONAL_MASK)
2053 case AXP_OPERAND_DEFAULT_FIRST:
2056 case AXP_OPERAND_DEFAULT_SECOND:
2059 case AXP_OPERAND_DEFAULT_ZERO:
2061 static expressionS zero_exp;
2063 zero_exp.X_op = O_constant;
2064 zero_exp.X_unsigned = 1;
2079 image = insert_operand (image, operand, regno (t->X_add_number),
2084 image = insert_operand (image, operand, t->X_add_number, NULL, 0);
2085 gas_assert (reloc_operand == NULL);
2086 reloc_operand = operand;
2091 /* This is only 0 for fields that should contain registers,
2092 which means this pattern shouldn't have matched. */
2093 if (operand->default_reloc == 0)
2096 /* There is one special case for which an insn receives two
2097 relocations, and thus the user-supplied reloc does not
2098 override the operand reloc. */
2099 if (operand->default_reloc == BFD_RELOC_ALPHA_HINT)
2101 struct alpha_fixup *fixup;
2103 if (insn->nfixups >= MAX_INSN_FIXUPS)
2104 as_fatal (_("too many fixups"));
2106 fixup = &insn->fixups[insn->nfixups++];
2108 fixup->reloc = BFD_RELOC_ALPHA_HINT;
2112 if (reloc == BFD_RELOC_UNUSED)
2113 reloc = operand->default_reloc;
2115 gas_assert (reloc_operand == NULL);
2116 reloc_operand = operand;
2123 if (reloc != BFD_RELOC_UNUSED)
2125 struct alpha_fixup *fixup;
2127 if (insn->nfixups >= MAX_INSN_FIXUPS)
2128 as_fatal (_("too many fixups"));
2130 /* ??? My but this is hacky. But the OSF/1 assembler uses the same
2131 relocation tag for both ldah and lda with gpdisp. Choose the
2132 correct internal relocation based on the opcode. */
2133 if (reloc == BFD_RELOC_ALPHA_GPDISP)
2135 if (strcmp (opcode->name, "ldah") == 0)
2136 reloc = BFD_RELOC_ALPHA_GPDISP_HI16;
2137 else if (strcmp (opcode->name, "lda") == 0)
2138 reloc = BFD_RELOC_ALPHA_GPDISP_LO16;
2140 as_bad (_("invalid relocation for instruction"));
2143 /* If this is a real relocation (as opposed to a lituse hint), then
2144 the relocation width should match the operand width.
2145 Take care of -MDISP in operand table. */
2146 else if (reloc < BFD_RELOC_UNUSED && reloc > 0)
2148 reloc_howto_type *reloc_howto
2149 = bfd_reloc_type_lookup (stdoutput,
2150 (bfd_reloc_code_real_type) reloc);
2151 if (reloc_operand == NULL
2152 || reloc_howto->bitsize != reloc_operand->bits)
2154 as_bad (_("invalid relocation for field"));
2159 fixup = &insn->fixups[insn->nfixups++];
2161 fixup->exp = *reloc_exp;
2163 fixup->exp.X_op = O_absent;
2164 fixup->reloc = reloc;
2170 /* Handle all "simple" integer register loads -- ldq, ldq_l, ldq_u,
2171 etc. They differ from the real instructions in that they do simple
2172 expressions like the lda macro. */
2175 emit_ir_load (const expressionS *tok,
2177 const void * opname)
2181 expressionS newtok[3];
2182 struct alpha_insn insn;
2184 = tok[1].X_add_symbol ? S_GET_NAME (tok[1].X_add_symbol): "";
2185 int symlen = strlen (symname);
2188 basereg = (tok[1].X_op == O_constant ? AXP_REG_ZERO : alpha_gp_register);
2190 basereg = tok[2].X_add_number;
2192 lituse = load_expression (tok[0].X_add_number, &tok[1],
2193 &basereg, &newtok[1], (const char *) opname);
2195 if (basereg == alpha_gp_register &&
2196 (symlen > 4 && strcmp (&symname [symlen - 4], "..lk") == 0))
2200 set_tok_preg (newtok[2], basereg);
2202 assemble_tokens_to_insn ((const char *) opname, newtok, 3, &insn);
2206 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2207 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2208 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2210 insn.sequence = lituse;
2216 /* Handle fp register loads, and both integer and fp register stores.
2217 Again, we handle simple expressions. */
2220 emit_loadstore (const expressionS *tok,
2222 const void * opname)
2226 expressionS newtok[3];
2227 struct alpha_insn insn;
2230 basereg = (tok[1].X_op == O_constant ? AXP_REG_ZERO : alpha_gp_register);
2232 basereg = tok[2].X_add_number;
2234 if (tok[1].X_op != O_constant || !range_signed_16 (tok[1].X_add_number))
2237 as_bad (_("macro requires $at register while noat in effect"));
2239 lituse = load_expression (AXP_REG_AT, &tok[1],
2240 &basereg, &newtok[1], (const char *) opname);
2249 set_tok_preg (newtok[2], basereg);
2251 assemble_tokens_to_insn ((const char *) opname, newtok, 3, &insn);
2255 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2256 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2257 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2259 insn.sequence = lituse;
2265 /* Load a half-word or byte as an unsigned value. */
2268 emit_ldXu (const expressionS *tok,
2270 const void * vlgsize)
2272 if (alpha_target & AXP_OPCODE_BWX)
2273 emit_ir_load (tok, ntok, ldXu_op[(long) vlgsize]);
2276 expressionS newtok[3];
2277 struct alpha_insn insn;
2282 as_bad (_("macro requires $at register while noat in effect"));
2285 basereg = (tok[1].X_op == O_constant
2286 ? AXP_REG_ZERO : alpha_gp_register);
2288 basereg = tok[2].X_add_number;
2290 /* Emit "lda $at, exp". */
2291 lituse = load_expression (AXP_REG_AT, &tok[1], &basereg, NULL, "lda");
2293 /* Emit "ldq_u targ, 0($at)". */
2295 set_tok_const (newtok[1], 0);
2296 set_tok_preg (newtok[2], basereg);
2297 assemble_tokens_to_insn ("ldq_u", newtok, 3, &insn);
2301 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2302 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2303 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2305 insn.sequence = lituse;
2310 /* Emit "extXl targ, $at, targ". */
2311 set_tok_reg (newtok[1], basereg);
2312 newtok[2] = newtok[0];
2313 assemble_tokens_to_insn (extXl_op[(long) vlgsize], newtok, 3, &insn);
2317 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2318 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BYTOFF;
2319 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2321 insn.sequence = lituse;
2328 /* Load a half-word or byte as a signed value. */
2331 emit_ldX (const expressionS *tok,
2333 const void * vlgsize)
2335 emit_ldXu (tok, ntok, vlgsize);
2336 assemble_tokens (sextX_op[(long) vlgsize], tok, 1, 1);
2339 /* Load an integral value from an unaligned address as an unsigned
2343 emit_uldXu (const expressionS *tok,
2345 const void * vlgsize)
2347 long lgsize = (long) vlgsize;
2348 expressionS newtok[3];
2351 as_bad (_("macro requires $at register while noat in effect"));
2353 /* Emit "lda $at, exp". */
2354 memcpy (newtok, tok, sizeof (expressionS) * ntok);
2355 newtok[0].X_add_number = AXP_REG_AT;
2356 assemble_tokens ("lda", newtok, ntok, 1);
2358 /* Emit "ldq_u $t9, 0($at)". */
2359 set_tok_reg (newtok[0], AXP_REG_T9);
2360 set_tok_const (newtok[1], 0);
2361 set_tok_preg (newtok[2], AXP_REG_AT);
2362 assemble_tokens ("ldq_u", newtok, 3, 1);
2364 /* Emit "ldq_u $t10, size-1($at)". */
2365 set_tok_reg (newtok[0], AXP_REG_T10);
2366 set_tok_const (newtok[1], (1 << lgsize) - 1);
2367 assemble_tokens ("ldq_u", newtok, 3, 1);
2369 /* Emit "extXl $t9, $at, $t9". */
2370 set_tok_reg (newtok[0], AXP_REG_T9);
2371 set_tok_reg (newtok[1], AXP_REG_AT);
2372 set_tok_reg (newtok[2], AXP_REG_T9);
2373 assemble_tokens (extXl_op[lgsize], newtok, 3, 1);
2375 /* Emit "extXh $t10, $at, $t10". */
2376 set_tok_reg (newtok[0], AXP_REG_T10);
2377 set_tok_reg (newtok[2], AXP_REG_T10);
2378 assemble_tokens (extXh_op[lgsize], newtok, 3, 1);
2380 /* Emit "or $t9, $t10, targ". */
2381 set_tok_reg (newtok[0], AXP_REG_T9);
2382 set_tok_reg (newtok[1], AXP_REG_T10);
2384 assemble_tokens ("or", newtok, 3, 1);
2387 /* Load an integral value from an unaligned address as a signed value.
2388 Note that quads should get funneled to the unsigned load since we
2389 don't have to do the sign extension. */
2392 emit_uldX (const expressionS *tok,
2394 const void * vlgsize)
2396 emit_uldXu (tok, ntok, vlgsize);
2397 assemble_tokens (sextX_op[(long) vlgsize], tok, 1, 1);
2400 /* Implement the ldil macro. */
2403 emit_ldil (const expressionS *tok,
2405 const void * unused ATTRIBUTE_UNUSED)
2407 expressionS newtok[2];
2409 memcpy (newtok, tok, sizeof (newtok));
2410 newtok[1].X_add_number = sign_extend_32 (tok[1].X_add_number);
2412 assemble_tokens ("lda", newtok, ntok, 1);
2415 /* Store a half-word or byte. */
2418 emit_stX (const expressionS *tok,
2420 const void * vlgsize)
2422 int lgsize = (int) (long) vlgsize;
2424 if (alpha_target & AXP_OPCODE_BWX)
2425 emit_loadstore (tok, ntok, stX_op[lgsize]);
2428 expressionS newtok[3];
2429 struct alpha_insn insn;
2434 as_bad (_("macro requires $at register while noat in effect"));
2437 basereg = (tok[1].X_op == O_constant
2438 ? AXP_REG_ZERO : alpha_gp_register);
2440 basereg = tok[2].X_add_number;
2442 /* Emit "lda $at, exp". */
2443 lituse = load_expression (AXP_REG_AT, &tok[1], &basereg, NULL, "lda");
2445 /* Emit "ldq_u $t9, 0($at)". */
2446 set_tok_reg (newtok[0], AXP_REG_T9);
2447 set_tok_const (newtok[1], 0);
2448 set_tok_preg (newtok[2], basereg);
2449 assemble_tokens_to_insn ("ldq_u", newtok, 3, &insn);
2453 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2454 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2455 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2457 insn.sequence = lituse;
2462 /* Emit "insXl src, $at, $t10". */
2464 set_tok_reg (newtok[1], basereg);
2465 set_tok_reg (newtok[2], AXP_REG_T10);
2466 assemble_tokens_to_insn (insXl_op[lgsize], newtok, 3, &insn);
2470 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2471 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BYTOFF;
2472 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2474 insn.sequence = lituse;
2479 /* Emit "mskXl $t9, $at, $t9". */
2480 set_tok_reg (newtok[0], AXP_REG_T9);
2481 newtok[2] = newtok[0];
2482 assemble_tokens_to_insn (mskXl_op[lgsize], newtok, 3, &insn);
2486 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2487 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BYTOFF;
2488 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2490 insn.sequence = lituse;
2495 /* Emit "or $t9, $t10, $t9". */
2496 set_tok_reg (newtok[1], AXP_REG_T10);
2497 assemble_tokens ("or", newtok, 3, 1);
2499 /* Emit "stq_u $t9, 0($at). */
2500 set_tok_const(newtok[1], 0);
2501 set_tok_preg (newtok[2], AXP_REG_AT);
2502 assemble_tokens_to_insn ("stq_u", newtok, 3, &insn);
2506 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2507 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_BASE;
2508 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2510 insn.sequence = lituse;
2517 /* Store an integer to an unaligned address. */
2520 emit_ustX (const expressionS *tok,
2522 const void * vlgsize)
2524 int lgsize = (int) (long) vlgsize;
2525 expressionS newtok[3];
2527 /* Emit "lda $at, exp". */
2528 memcpy (newtok, tok, sizeof (expressionS) * ntok);
2529 newtok[0].X_add_number = AXP_REG_AT;
2530 assemble_tokens ("lda", newtok, ntok, 1);
2532 /* Emit "ldq_u $9, 0($at)". */
2533 set_tok_reg (newtok[0], AXP_REG_T9);
2534 set_tok_const (newtok[1], 0);
2535 set_tok_preg (newtok[2], AXP_REG_AT);
2536 assemble_tokens ("ldq_u", newtok, 3, 1);
2538 /* Emit "ldq_u $10, size-1($at)". */
2539 set_tok_reg (newtok[0], AXP_REG_T10);
2540 set_tok_const (newtok[1], (1 << lgsize) - 1);
2541 assemble_tokens ("ldq_u", newtok, 3, 1);
2543 /* Emit "insXl src, $at, $t11". */
2545 set_tok_reg (newtok[1], AXP_REG_AT);
2546 set_tok_reg (newtok[2], AXP_REG_T11);
2547 assemble_tokens (insXl_op[lgsize], newtok, 3, 1);
2549 /* Emit "insXh src, $at, $t12". */
2550 set_tok_reg (newtok[2], AXP_REG_T12);
2551 assemble_tokens (insXh_op[lgsize], newtok, 3, 1);
2553 /* Emit "mskXl $t9, $at, $t9". */
2554 set_tok_reg (newtok[0], AXP_REG_T9);
2555 newtok[2] = newtok[0];
2556 assemble_tokens (mskXl_op[lgsize], newtok, 3, 1);
2558 /* Emit "mskXh $t10, $at, $t10". */
2559 set_tok_reg (newtok[0], AXP_REG_T10);
2560 newtok[2] = newtok[0];
2561 assemble_tokens (mskXh_op[lgsize], newtok, 3, 1);
2563 /* Emit "or $t9, $t11, $t9". */
2564 set_tok_reg (newtok[0], AXP_REG_T9);
2565 set_tok_reg (newtok[1], AXP_REG_T11);
2566 newtok[2] = newtok[0];
2567 assemble_tokens ("or", newtok, 3, 1);
2569 /* Emit "or $t10, $t12, $t10". */
2570 set_tok_reg (newtok[0], AXP_REG_T10);
2571 set_tok_reg (newtok[1], AXP_REG_T12);
2572 newtok[2] = newtok[0];
2573 assemble_tokens ("or", newtok, 3, 1);
2575 /* Emit "stq_u $t10, size-1($at)". */
2576 set_tok_reg (newtok[0], AXP_REG_T10);
2577 set_tok_const (newtok[1], (1 << lgsize) - 1);
2578 set_tok_preg (newtok[2], AXP_REG_AT);
2579 assemble_tokens ("stq_u", newtok, 3, 1);
2581 /* Emit "stq_u $t9, 0($at)". */
2582 set_tok_reg (newtok[0], AXP_REG_T9);
2583 set_tok_const (newtok[1], 0);
2584 assemble_tokens ("stq_u", newtok, 3, 1);
2587 /* Sign extend a half-word or byte. The 32-bit sign extend is
2588 implemented as "addl $31, $r, $t" in the opcode table. */
2591 emit_sextX (const expressionS *tok,
2593 const void * vlgsize)
2595 long lgsize = (long) vlgsize;
2597 if (alpha_target & AXP_OPCODE_BWX)
2598 assemble_tokens (sextX_op[lgsize], tok, ntok, 0);
2601 int bitshift = 64 - 8 * (1 << lgsize);
2602 expressionS newtok[3];
2604 /* Emit "sll src,bits,dst". */
2606 set_tok_const (newtok[1], bitshift);
2607 newtok[2] = tok[ntok - 1];
2608 assemble_tokens ("sll", newtok, 3, 1);
2610 /* Emit "sra dst,bits,dst". */
2611 newtok[0] = newtok[2];
2612 assemble_tokens ("sra", newtok, 3, 1);
2616 /* Implement the division and modulus macros. */
2620 /* Make register usage like in normal procedure call.
2621 Don't clobber PV and RA. */
2624 emit_division (const expressionS *tok,
2626 const void * symname)
2628 /* DIVISION and MODULUS. Yech.
2633 mov x,R16 # if x != R16
2634 mov y,R17 # if y != R17
2639 with appropriate optimizations if R0,R16,R17 are the registers
2640 specified by the compiler. */
2644 expressionS newtok[3];
2646 xr = regno (tok[0].X_add_number);
2647 yr = regno (tok[1].X_add_number);
2652 rr = regno (tok[2].X_add_number);
2654 /* Move the operands into the right place. */
2655 if (yr == AXP_REG_R16 && xr == AXP_REG_R17)
2657 /* They are in exactly the wrong order -- swap through AT. */
2659 as_bad (_("macro requires $at register while noat in effect"));
2661 set_tok_reg (newtok[0], AXP_REG_R16);
2662 set_tok_reg (newtok[1], AXP_REG_AT);
2663 assemble_tokens ("mov", newtok, 2, 1);
2665 set_tok_reg (newtok[0], AXP_REG_R17);
2666 set_tok_reg (newtok[1], AXP_REG_R16);
2667 assemble_tokens ("mov", newtok, 2, 1);
2669 set_tok_reg (newtok[0], AXP_REG_AT);
2670 set_tok_reg (newtok[1], AXP_REG_R17);
2671 assemble_tokens ("mov", newtok, 2, 1);
2675 if (yr == AXP_REG_R16)
2677 set_tok_reg (newtok[0], AXP_REG_R16);
2678 set_tok_reg (newtok[1], AXP_REG_R17);
2679 assemble_tokens ("mov", newtok, 2, 1);
2682 if (xr != AXP_REG_R16)
2684 set_tok_reg (newtok[0], xr);
2685 set_tok_reg (newtok[1], AXP_REG_R16);
2686 assemble_tokens ("mov", newtok, 2, 1);
2689 if (yr != AXP_REG_R16 && yr != AXP_REG_R17)
2691 set_tok_reg (newtok[0], yr);
2692 set_tok_reg (newtok[1], AXP_REG_R17);
2693 assemble_tokens ("mov", newtok, 2, 1);
2697 sym = symbol_find_or_make ((const char *) symname);
2699 set_tok_reg (newtok[0], AXP_REG_AT);
2700 set_tok_sym (newtok[1], sym, 0);
2701 assemble_tokens ("lda", newtok, 2, 1);
2703 /* Call the division routine. */
2704 set_tok_reg (newtok[0], AXP_REG_AT);
2705 set_tok_cpreg (newtok[1], AXP_REG_AT);
2706 set_tok_const (newtok[2], 0);
2707 assemble_tokens ("jsr", newtok, 3, 1);
2709 /* Move the result to the right place. */
2710 if (rr != AXP_REG_R0)
2712 set_tok_reg (newtok[0], AXP_REG_R0);
2713 set_tok_reg (newtok[1], rr);
2714 assemble_tokens ("mov", newtok, 2, 1);
2718 #else /* !OBJ_EVAX */
2721 emit_division (const expressionS *tok,
2723 const void * symname)
2725 /* DIVISION and MODULUS. Yech.
2735 with appropriate optimizations if t10,t11,t12 are the registers
2736 specified by the compiler. */
2740 expressionS newtok[3];
2742 xr = regno (tok[0].X_add_number);
2743 yr = regno (tok[1].X_add_number);
2748 rr = regno (tok[2].X_add_number);
2750 sym = symbol_find_or_make ((const char *) symname);
2752 /* Move the operands into the right place. */
2753 if (yr == AXP_REG_T10 && xr == AXP_REG_T11)
2755 /* They are in exactly the wrong order -- swap through AT. */
2757 as_bad (_("macro requires $at register while noat in effect"));
2759 set_tok_reg (newtok[0], AXP_REG_T10);
2760 set_tok_reg (newtok[1], AXP_REG_AT);
2761 assemble_tokens ("mov", newtok, 2, 1);
2763 set_tok_reg (newtok[0], AXP_REG_T11);
2764 set_tok_reg (newtok[1], AXP_REG_T10);
2765 assemble_tokens ("mov", newtok, 2, 1);
2767 set_tok_reg (newtok[0], AXP_REG_AT);
2768 set_tok_reg (newtok[1], AXP_REG_T11);
2769 assemble_tokens ("mov", newtok, 2, 1);
2773 if (yr == AXP_REG_T10)
2775 set_tok_reg (newtok[0], AXP_REG_T10);
2776 set_tok_reg (newtok[1], AXP_REG_T11);
2777 assemble_tokens ("mov", newtok, 2, 1);
2780 if (xr != AXP_REG_T10)
2782 set_tok_reg (newtok[0], xr);
2783 set_tok_reg (newtok[1], AXP_REG_T10);
2784 assemble_tokens ("mov", newtok, 2, 1);
2787 if (yr != AXP_REG_T10 && yr != AXP_REG_T11)
2789 set_tok_reg (newtok[0], yr);
2790 set_tok_reg (newtok[1], AXP_REG_T11);
2791 assemble_tokens ("mov", newtok, 2, 1);
2795 /* Call the division routine. */
2796 set_tok_reg (newtok[0], AXP_REG_T9);
2797 set_tok_sym (newtok[1], sym, 0);
2798 assemble_tokens ("jsr", newtok, 2, 1);
2800 /* Reload the GP register. */
2804 #if defined(OBJ_ECOFF) || defined(OBJ_ELF)
2805 set_tok_reg (newtok[0], alpha_gp_register);
2806 set_tok_const (newtok[1], 0);
2807 set_tok_preg (newtok[2], AXP_REG_T9);
2808 assemble_tokens ("ldgp", newtok, 3, 1);
2811 /* Move the result to the right place. */
2812 if (rr != AXP_REG_T12)
2814 set_tok_reg (newtok[0], AXP_REG_T12);
2815 set_tok_reg (newtok[1], rr);
2816 assemble_tokens ("mov", newtok, 2, 1);
2820 #endif /* !OBJ_EVAX */
2822 /* The jsr and jmp macros differ from their instruction counterparts
2823 in that they can load the target address and default most
2827 emit_jsrjmp (const expressionS *tok,
2829 const void * vopname)
2831 const char *opname = (const char *) vopname;
2832 struct alpha_insn insn;
2833 expressionS newtok[3];
2837 if (tokidx < ntok && tok[tokidx].X_op == O_register)
2838 r = regno (tok[tokidx++].X_add_number);
2840 r = strcmp (opname, "jmp") == 0 ? AXP_REG_ZERO : AXP_REG_RA;
2842 set_tok_reg (newtok[0], r);
2844 if (tokidx < ntok &&
2845 (tok[tokidx].X_op == O_pregister || tok[tokidx].X_op == O_cpregister))
2846 r = regno (tok[tokidx++].X_add_number);
2848 /* Keep register if jsr $n.<sym>. */
2852 int basereg = alpha_gp_register;
2853 lituse = load_expression (r = AXP_REG_PV, &tok[tokidx],
2854 &basereg, NULL, opname);
2858 set_tok_cpreg (newtok[1], r);
2862 newtok[2] = tok[tokidx];
2865 set_tok_const (newtok[2], 0);
2867 assemble_tokens_to_insn (opname, newtok, 3, &insn);
2871 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2872 insn.fixups[insn.nfixups].reloc = DUMMY_RELOC_LITUSE_JSR;
2873 insn.fixups[insn.nfixups].exp.X_op = O_absent;
2875 insn.sequence = lituse;
2879 if (alpha_flag_replace
2881 && tok[tokidx].X_add_symbol
2882 && alpha_linkage_symbol)
2884 /* Create a BOH reloc for 'jsr $27,NAME'. */
2885 const char *symname = S_GET_NAME (tok[tokidx].X_add_symbol);
2886 int symlen = strlen (symname);
2889 /* Build the entry name as 'NAME..en'. */
2890 ensymname = (char *) xmalloc (symlen + 5);
2891 memcpy (ensymname, symname, symlen);
2892 memcpy (ensymname + symlen, "..en", 5);
2894 gas_assert (insn.nfixups < MAX_INSN_FIXUPS);
2895 if (insn.nfixups > 0)
2897 memmove (&insn.fixups[1], &insn.fixups[0],
2898 sizeof(struct alpha_fixup) * insn.nfixups);
2901 /* The fixup must be the same as the BFD_RELOC_ALPHA_NOP
2902 case in load_expression. See B.4.5.2 of the OpenVMS
2903 Linker Utility Manual. */
2904 insn.fixups[0].reloc = BFD_RELOC_ALPHA_BOH;
2905 insn.fixups[0].exp.X_op = O_symbol;
2906 insn.fixups[0].exp.X_add_symbol = symbol_find_or_make (ensymname);
2907 insn.fixups[0].exp.X_add_number = 0;
2908 insn.fixups[0].xtrasym = alpha_linkage_symbol;
2909 insn.fixups[0].procsym = alpha_evax_proc->symbol;
2911 alpha_linkage_symbol = 0;
2918 /* The ret and jcr instructions differ from their instruction
2919 counterparts in that everything can be defaulted. */
2922 emit_retjcr (const expressionS *tok,
2924 const void * vopname)
2926 const char *opname = (const char *) vopname;
2927 expressionS newtok[3];
2930 if (tokidx < ntok && tok[tokidx].X_op == O_register)
2931 r = regno (tok[tokidx++].X_add_number);
2935 set_tok_reg (newtok[0], r);
2937 if (tokidx < ntok &&
2938 (tok[tokidx].X_op == O_pregister || tok[tokidx].X_op == O_cpregister))
2939 r = regno (tok[tokidx++].X_add_number);
2943 set_tok_cpreg (newtok[1], r);
2946 newtok[2] = tok[tokidx];
2948 set_tok_const (newtok[2], strcmp (opname, "ret") == 0);
2950 assemble_tokens (opname, newtok, 3, 0);
2953 /* Implement the ldgp macro. */
2956 emit_ldgp (const expressionS *tok ATTRIBUTE_UNUSED,
2957 int ntok ATTRIBUTE_UNUSED,
2958 const void * unused ATTRIBUTE_UNUSED)
2963 #if defined(OBJ_ECOFF) || defined(OBJ_ELF)
2964 /* from "ldgp r1,n(r2)", generate "ldah r1,X(R2); lda r1,Y(r1)"
2965 with appropriate constants and relocations. */
2966 struct alpha_insn insn;
2967 expressionS newtok[3];
2971 if (regno (tok[2].X_add_number) == AXP_REG_PV)
2972 ecoff_set_gp_prolog_size (0);
2976 set_tok_const (newtok[1], 0);
2979 assemble_tokens_to_insn ("ldah", newtok, 3, &insn);
2984 if (addend.X_op != O_constant)
2985 as_bad (_("can not resolve expression"));
2986 addend.X_op = O_symbol;
2987 addend.X_add_symbol = alpha_gp_symbol;
2991 insn.fixups[0].exp = addend;
2992 insn.fixups[0].reloc = BFD_RELOC_ALPHA_GPDISP_HI16;
2993 insn.sequence = next_sequence_num;
2997 set_tok_preg (newtok[2], tok[0].X_add_number);
2999 assemble_tokens_to_insn ("lda", newtok, 3, &insn);
3002 addend.X_add_number += 4;
3006 insn.fixups[0].exp = addend;
3007 insn.fixups[0].reloc = BFD_RELOC_ALPHA_GPDISP_LO16;
3008 insn.sequence = next_sequence_num--;
3011 #endif /* OBJ_ECOFF || OBJ_ELF */
3014 /* The macro table. */
3016 static const struct alpha_macro alpha_macros[] =
3018 /* Load/Store macros. */
3019 { "lda", emit_lda, NULL,
3020 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3021 { "ldah", emit_ldah, NULL,
3022 { MACRO_IR, MACRO_EXP, MACRO_EOA } },
3024 { "ldl", emit_ir_load, "ldl",
3025 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3026 { "ldl_l", emit_ir_load, "ldl_l",
3027 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3028 { "ldq", emit_ir_load, "ldq",
3029 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3030 { "ldq_l", emit_ir_load, "ldq_l",
3031 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3032 { "ldq_u", emit_ir_load, "ldq_u",
3033 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3034 { "ldf", emit_loadstore, "ldf",
3035 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3036 { "ldg", emit_loadstore, "ldg",
3037 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3038 { "lds", emit_loadstore, "lds",
3039 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3040 { "ldt", emit_loadstore, "ldt",
3041 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3043 { "ldb", emit_ldX, (void *) 0,
3044 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3045 { "ldbu", emit_ldXu, (void *) 0,
3046 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3047 { "ldw", emit_ldX, (void *) 1,
3048 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3049 { "ldwu", emit_ldXu, (void *) 1,
3050 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3052 { "uldw", emit_uldX, (void *) 1,
3053 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3054 { "uldwu", emit_uldXu, (void *) 1,
3055 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3056 { "uldl", emit_uldX, (void *) 2,
3057 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3058 { "uldlu", emit_uldXu, (void *) 2,
3059 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3060 { "uldq", emit_uldXu, (void *) 3,
3061 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3063 { "ldgp", emit_ldgp, NULL,
3064 { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA } },
3066 { "ldi", emit_lda, NULL,
3067 { MACRO_IR, MACRO_EXP, MACRO_EOA } },
3068 { "ldil", emit_ldil, NULL,
3069 { MACRO_IR, MACRO_EXP, MACRO_EOA } },
3070 { "ldiq", emit_lda, NULL,
3071 { MACRO_IR, MACRO_EXP, MACRO_EOA } },
3073 { "stl", emit_loadstore, "stl",
3074 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3075 { "stl_c", emit_loadstore, "stl_c",
3076 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3077 { "stq", emit_loadstore, "stq",
3078 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3079 { "stq_c", emit_loadstore, "stq_c",
3080 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3081 { "stq_u", emit_loadstore, "stq_u",
3082 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3083 { "stf", emit_loadstore, "stf",
3084 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3085 { "stg", emit_loadstore, "stg",
3086 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3087 { "sts", emit_loadstore, "sts",
3088 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3089 { "stt", emit_loadstore, "stt",
3090 { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3092 { "stb", emit_stX, (void *) 0,
3093 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3094 { "stw", emit_stX, (void *) 1,
3095 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3096 { "ustw", emit_ustX, (void *) 1,
3097 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3098 { "ustl", emit_ustX, (void *) 2,
3099 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3100 { "ustq", emit_ustX, (void *) 3,
3101 { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_EOA } },
3103 /* Arithmetic macros. */
3105 { "sextb", emit_sextX, (void *) 0,
3106 { MACRO_IR, MACRO_IR, MACRO_EOA,
3107 MACRO_IR, MACRO_EOA,
3108 /* MACRO_EXP, MACRO_IR, MACRO_EOA */ } },
3109 { "sextw", emit_sextX, (void *) 1,
3110 { MACRO_IR, MACRO_IR, MACRO_EOA,
3111 MACRO_IR, MACRO_EOA,
3112 /* MACRO_EXP, MACRO_IR, MACRO_EOA */ } },
3114 { "divl", emit_division, "__divl",
3115 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3116 MACRO_IR, MACRO_IR, MACRO_EOA,
3117 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3118 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3119 { "divlu", emit_division, "__divlu",
3120 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3121 MACRO_IR, MACRO_IR, MACRO_EOA,
3122 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3123 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3124 { "divq", emit_division, "__divq",
3125 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3126 MACRO_IR, MACRO_IR, MACRO_EOA,
3127 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3128 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3129 { "divqu", emit_division, "__divqu",
3130 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3131 MACRO_IR, MACRO_IR, MACRO_EOA,
3132 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3133 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3134 { "reml", emit_division, "__reml",
3135 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3136 MACRO_IR, MACRO_IR, MACRO_EOA,
3137 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3138 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3139 { "remlu", emit_division, "__remlu",
3140 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3141 MACRO_IR, MACRO_IR, MACRO_EOA,
3142 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3143 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3144 { "remq", emit_division, "__remq",
3145 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3146 MACRO_IR, MACRO_IR, MACRO_EOA,
3147 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3148 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3149 { "remqu", emit_division, "__remqu",
3150 { MACRO_IR, MACRO_IR, MACRO_IR, MACRO_EOA,
3151 MACRO_IR, MACRO_IR, MACRO_EOA,
3152 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3153 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3155 { "jsr", emit_jsrjmp, "jsr",
3156 { MACRO_PIR, MACRO_EXP, MACRO_EOA,
3157 MACRO_PIR, MACRO_EOA,
3158 MACRO_IR, MACRO_EXP, MACRO_EOA,
3159 MACRO_EXP, MACRO_EOA } },
3160 { "jmp", emit_jsrjmp, "jmp",
3161 { MACRO_PIR, MACRO_EXP, MACRO_EOA,
3162 MACRO_PIR, MACRO_EOA,
3163 MACRO_IR, MACRO_EXP, MACRO_EOA,
3164 MACRO_EXP, MACRO_EOA } },
3165 { "ret", emit_retjcr, "ret",
3166 { MACRO_IR, MACRO_EXP, MACRO_EOA,
3167 MACRO_IR, MACRO_EOA,
3168 MACRO_PIR, MACRO_EXP, MACRO_EOA,
3169 MACRO_PIR, MACRO_EOA,
3170 MACRO_EXP, MACRO_EOA,
3172 { "jcr", emit_retjcr, "jcr",
3173 { MACRO_IR, MACRO_EXP, MACRO_EOA,
3174 MACRO_IR, MACRO_EOA,
3175 MACRO_PIR, MACRO_EXP, MACRO_EOA,
3176 MACRO_PIR, MACRO_EOA,
3177 MACRO_EXP, MACRO_EOA,
3179 { "jsr_coroutine", emit_retjcr, "jcr",
3180 { MACRO_IR, MACRO_EXP, MACRO_EOA,
3181 MACRO_IR, MACRO_EOA,
3182 MACRO_PIR, MACRO_EXP, MACRO_EOA,
3183 MACRO_PIR, MACRO_EOA,
3184 MACRO_EXP, MACRO_EOA,
3188 static const unsigned int alpha_num_macros
3189 = sizeof (alpha_macros) / sizeof (*alpha_macros);
3191 /* Search forward through all variants of a macro looking for a syntax
3194 static const struct alpha_macro *
3195 find_macro_match (const struct alpha_macro *first_macro,
3196 const expressionS *tok,
3200 const struct alpha_macro *macro = first_macro;
3205 const enum alpha_macro_arg *arg = macro->argsets;
3219 /* Index register. */
3221 if (tokidx >= ntok || tok[tokidx].X_op != O_register
3222 || !is_ir_num (tok[tokidx].X_add_number))
3227 /* Parenthesized index register. */
3229 if (tokidx >= ntok || tok[tokidx].X_op != O_pregister
3230 || !is_ir_num (tok[tokidx].X_add_number))
3235 /* Optional parenthesized index register. */
3237 if (tokidx < ntok && tok[tokidx].X_op == O_pregister
3238 && is_ir_num (tok[tokidx].X_add_number))
3242 /* Leading comma with a parenthesized index register. */
3244 if (tokidx >= ntok || tok[tokidx].X_op != O_cpregister
3245 || !is_ir_num (tok[tokidx].X_add_number))
3250 /* Floating point register. */
3252 if (tokidx >= ntok || tok[tokidx].X_op != O_register
3253 || !is_fpr_num (tok[tokidx].X_add_number))
3258 /* Normal expression. */
3262 switch (tok[tokidx].X_op)
3271 case O_lituse_bytoff:
3287 while (*arg != MACRO_EOA)
3295 while (++macro - alpha_macros < (int) alpha_num_macros
3296 && !strcmp (macro->name, first_macro->name));
3301 /* Given an opcode name and a pre-tokenized set of arguments, take the
3302 opcode all the way through emission. */
3305 assemble_tokens (const char *opname,
3306 const expressionS *tok,
3308 int local_macros_on)
3310 int found_something = 0;
3311 const struct alpha_opcode *opcode;
3312 const struct alpha_macro *macro;
3314 extended_bfd_reloc_code_real_type reloc = BFD_RELOC_UNUSED;
3317 /* If a user-specified relocation is present, this is not a macro. */
3318 if (ntok && USER_RELOC_P (tok[ntok - 1].X_op))
3320 reloc = ALPHA_RELOC_TABLE (tok[ntok - 1].X_op)->reloc;
3325 if (local_macros_on)
3327 macro = ((const struct alpha_macro *)
3328 hash_find (alpha_macro_hash, opname));
3331 found_something = 1;
3332 macro = find_macro_match (macro, tok, &ntok);
3335 (*macro->emit) (tok, ntok, macro->arg);
3341 /* Search opcodes. */
3342 opcode = (const struct alpha_opcode *) hash_find (alpha_opcode_hash, opname);
3345 found_something = 1;
3346 opcode = find_opcode_match (opcode, tok, &ntok, &cpumatch);
3349 struct alpha_insn insn;
3350 assemble_insn (opcode, tok, ntok, &insn, reloc);
3352 /* Copy the sequence number for the reloc from the reloc token. */
3353 if (reloc != BFD_RELOC_UNUSED)
3354 insn.sequence = tok[ntok].X_add_number;
3361 if (found_something)
3364 as_bad (_("inappropriate arguments for opcode `%s'"), opname);
3366 as_bad (_("opcode `%s' not supported for target %s"), opname,
3370 as_bad (_("unknown opcode `%s'"), opname);
3375 /* Add sym+addend to link pool.
3376 Return offset from basesym to entry in link pool.
3378 Add new fixup only if offset isn't 16bit. */
3381 add_to_link_pool (symbolS *basesym,
3385 segT current_section = now_seg;
3386 int current_subsec = now_subseg;
3388 segment_info_type *seginfo = seg_info (alpha_link_section);
3390 symbolS *linksym, *expsym;
3393 /* @@ This assumes all entries in a given section will be of the same
3394 size... Probably correct, but unwise to rely on. */
3395 /* This must always be called with the same subsegment. */
3397 if (seginfo->frchainP)
3398 for (fixp = seginfo->frchainP->fix_root;
3399 fixp != (fixS *) NULL;
3400 fixp = fixp->fx_next)
3402 if (fixp->fx_addsy == sym
3403 && fixp->fx_offset == (valueT)addend
3404 && fixp->tc_fix_data.info
3405 && fixp->tc_fix_data.info->sym
3406 && fixp->tc_fix_data.info->sym->sy_value.X_op_symbol == basesym)
3407 return fixp->tc_fix_data.info->sym;
3410 /* Not found in 16bit signed range. */
3412 subseg_set (alpha_link_section, 0);
3413 linksym = symbol_new
3414 (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
3418 e.X_op = O_subtract;
3419 e.X_add_symbol = linksym;
3420 e.X_op_symbol = basesym;
3422 expsym = make_expr_symbol (&e);
3425 (frag_now, p - frag_now->fr_literal, 8, sym, addend, 0, BFD_RELOC_64);
3426 fixp->tc_fix_data.info = get_alpha_reloc_tag (next_sequence_num--);
3427 fixp->tc_fix_data.info->sym = expsym;
3429 subseg_set (current_section, current_subsec);
3430 seginfo->literal_pool_size += 8;
3433 #endif /* OBJ_EVAX */
3435 /* Assembler directives. */
3437 /* Handle the .text pseudo-op. This is like the usual one, but it
3438 clears alpha_insn_label and restores auto alignment. */
3441 s_alpha_text (int i)
3452 symbolP = symbol_find (".text");
3453 if (symbolP == NULL)
3455 symbolP = symbol_make (".text");
3456 S_SET_SEGMENT (symbolP, text_section);
3457 symbol_table_insert (symbolP);
3461 alpha_insn_label = NULL;
3462 alpha_auto_align_on = 1;
3463 alpha_current_align = 0;
3466 /* Handle the .data pseudo-op. This is like the usual one, but it
3467 clears alpha_insn_label and restores auto alignment. */
3470 s_alpha_data (int i)
3477 alpha_insn_label = NULL;
3478 alpha_auto_align_on = 1;
3479 alpha_current_align = 0;
3482 #if defined (OBJ_ECOFF) || defined (OBJ_EVAX)
3484 /* Handle the OSF/1 and openVMS .comm pseudo quirks. */
3487 s_alpha_comm (int ignore ATTRIBUTE_UNUSED)
3499 name = input_line_pointer;
3500 c = get_symbol_end ();
3502 /* Just after name is now '\0'. */
3503 p = input_line_pointer;
3508 /* Alpha OSF/1 compiler doesn't provide the comma, gcc does. */
3509 if (*input_line_pointer == ',')
3511 input_line_pointer++;
3514 if ((size = get_absolute_expression ()) < 0)
3516 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size);
3517 ignore_rest_of_line ();
3522 symbolP = symbol_find_or_make (name);
3525 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
3527 as_bad (_("Ignoring attempt to re-define symbol"));
3528 ignore_rest_of_line ();
3533 if (*input_line_pointer != ',')
3534 temp = 8; /* Default alignment. */
3537 input_line_pointer++;
3539 temp = get_absolute_expression ();
3542 /* ??? Unlike on OSF/1, the alignment factor is not in log units. */
3543 while ((temp >>= 1) != 0)
3546 if (*input_line_pointer == ',')
3548 /* Extended form of the directive
3550 .comm symbol, size, alignment, section
3552 where the "common" semantics is transferred to the section.
3553 The symbol is effectively an alias for the section name. */
3557 symbolS *sec_symbol;
3558 segT current_seg = now_seg;
3559 subsegT current_subseg = now_subseg;
3562 input_line_pointer++;
3564 sec_name = s_alpha_section_name ();
3565 sec_symbol = symbol_find_or_make (sec_name);
3566 sec = subseg_new (sec_name, 0);
3567 S_SET_SEGMENT (sec_symbol, sec);
3568 symbol_get_bfdsym (sec_symbol)->flags |= BSF_SECTION_SYM;
3569 bfd_vms_set_section_flags (stdoutput, sec, 0,
3570 EGPS__V_OVR | EGPS__V_GBL | EGPS__V_NOMOD);
3571 record_alignment (sec, log_align);
3573 /* Reuse stab_string_size to store the size of the section. */
3574 cur_size = seg_info (sec)->stabu.stab_string_size;
3575 if ((int) size > cur_size)
3578 = frag_var (rs_fill, 1, 1, (relax_substateT)0, NULL,
3579 (valueT)size - (valueT)cur_size, NULL);
3581 seg_info (sec)->stabu.stab_string_size = (int)size;
3584 S_SET_SEGMENT (symbolP, sec);
3586 subseg_set (current_seg, current_subseg);
3590 /* Regular form of the directive
3592 .comm symbol, size, alignment
3594 where the "common" semantics in on the symbol.
3595 These symbols are assembled in the .bss section. */
3598 segT current_seg = now_seg;
3599 subsegT current_subseg = now_subseg;
3601 subseg_set (bss_section, 1);
3602 frag_align (log_align, 0, 0);
3603 record_alignment (bss_section, log_align);
3605 symbolP->sy_frag = frag_now;
3606 pfrag = frag_var (rs_org, 1, 1, (relax_substateT)0, symbolP,
3610 S_SET_SEGMENT (symbolP, bss_section);
3612 subseg_set (current_seg, current_subseg);
3616 if (S_GET_VALUE (symbolP))
3618 if (S_GET_VALUE (symbolP) != (valueT) size)
3619 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
3620 S_GET_NAME (symbolP),
3621 (long) S_GET_VALUE (symbolP),
3627 S_SET_VALUE (symbolP, (valueT) size);
3629 S_SET_EXTERNAL (symbolP);
3633 know (symbolP->sy_frag == &zero_address_frag);
3635 demand_empty_rest_of_line ();
3638 #endif /* ! OBJ_ELF */
3642 /* Handle the .rdata pseudo-op. This is like the usual one, but it
3643 clears alpha_insn_label and restores auto alignment. */
3646 s_alpha_rdata (int ignore ATTRIBUTE_UNUSED)
3648 get_absolute_expression ();
3649 subseg_new (".rdata", 0);
3650 demand_empty_rest_of_line ();
3651 alpha_insn_label = NULL;
3652 alpha_auto_align_on = 1;
3653 alpha_current_align = 0;
3660 /* Handle the .sdata pseudo-op. This is like the usual one, but it
3661 clears alpha_insn_label and restores auto alignment. */
3664 s_alpha_sdata (int ignore ATTRIBUTE_UNUSED)
3666 get_absolute_expression ();
3667 subseg_new (".sdata", 0);
3668 demand_empty_rest_of_line ();
3669 alpha_insn_label = NULL;
3670 alpha_auto_align_on = 1;
3671 alpha_current_align = 0;
3676 struct alpha_elf_frame_data
3679 symbolS *func_end_sym;
3680 symbolS *prologue_sym;
3686 offsetT mask_offset;
3687 offsetT fmask_offset;
3689 struct alpha_elf_frame_data *next;
3692 static struct alpha_elf_frame_data *all_frame_data;
3693 static struct alpha_elf_frame_data **plast_frame_data = &all_frame_data;
3694 static struct alpha_elf_frame_data *cur_frame_data;
3696 /* Handle the .section pseudo-op. This is like the usual one, but it
3697 clears alpha_insn_label and restores auto alignment. */
3700 s_alpha_section (int ignore ATTRIBUTE_UNUSED)
3702 obj_elf_section (ignore);
3704 alpha_insn_label = NULL;
3705 alpha_auto_align_on = 1;
3706 alpha_current_align = 0;
3710 s_alpha_ent (int dummy ATTRIBUTE_UNUSED)
3712 if (ECOFF_DEBUGGING)
3713 ecoff_directive_ent (0);
3716 char *name, name_end;
3717 name = input_line_pointer;
3718 name_end = get_symbol_end ();
3720 if (! is_name_beginner (*name))
3722 as_warn (_(".ent directive has no name"));
3723 *input_line_pointer = name_end;
3730 as_warn (_("nested .ent directives"));
3732 sym = symbol_find_or_make (name);
3733 symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
3735 cur_frame_data = (struct alpha_elf_frame_data *)
3736 calloc (1, sizeof (*cur_frame_data));
3737 cur_frame_data->func_sym = sym;
3739 /* Provide sensible defaults. */
3740 cur_frame_data->fp_regno = 30; /* sp */
3741 cur_frame_data->ra_regno = 26; /* ra */
3743 *plast_frame_data = cur_frame_data;
3744 plast_frame_data = &cur_frame_data->next;
3746 /* The .ent directive is sometimes followed by a number. Not sure
3747 what it really means, but ignore it. */
3748 *input_line_pointer = name_end;
3750 if (*input_line_pointer == ',')
3752 input_line_pointer++;
3755 if (ISDIGIT (*input_line_pointer) || *input_line_pointer == '-')
3756 (void) get_absolute_expression ();
3758 demand_empty_rest_of_line ();
3763 s_alpha_end (int dummy ATTRIBUTE_UNUSED)
3765 if (ECOFF_DEBUGGING)
3766 ecoff_directive_end (0);
3769 char *name, name_end;
3770 name = input_line_pointer;
3771 name_end = get_symbol_end ();
3773 if (! is_name_beginner (*name))
3775 as_warn (_(".end directive has no name"));
3776 *input_line_pointer = name_end;
3782 sym = symbol_find (name);
3783 if (!cur_frame_data)
3784 as_warn (_(".end directive without matching .ent"));
3785 else if (sym != cur_frame_data->func_sym)
3786 as_warn (_(".end directive names different symbol than .ent"));
3788 /* Create an expression to calculate the size of the function. */
3789 if (sym && cur_frame_data)
3791 OBJ_SYMFIELD_TYPE *obj = symbol_get_obj (sym);
3792 expressionS *exp = (expressionS *) xmalloc (sizeof (expressionS));
3795 exp->X_op = O_subtract;
3796 exp->X_add_symbol = symbol_temp_new_now ();
3797 exp->X_op_symbol = sym;
3798 exp->X_add_number = 0;
3800 cur_frame_data->func_end_sym = exp->X_add_symbol;
3803 cur_frame_data = NULL;
3805 *input_line_pointer = name_end;
3807 demand_empty_rest_of_line ();
3812 s_alpha_mask (int fp)
3814 if (ECOFF_DEBUGGING)
3817 ecoff_directive_fmask (0);
3819 ecoff_directive_mask (0);
3826 if (!cur_frame_data)
3829 as_warn (_(".fmask outside of .ent"));
3831 as_warn (_(".mask outside of .ent"));
3832 discard_rest_of_line ();
3836 if (get_absolute_expression_and_terminator (&val) != ',')
3839 as_warn (_("bad .fmask directive"));
3841 as_warn (_("bad .mask directive"));
3842 --input_line_pointer;
3843 discard_rest_of_line ();
3847 offset = get_absolute_expression ();
3848 demand_empty_rest_of_line ();
3852 cur_frame_data->fmask = val;
3853 cur_frame_data->fmask_offset = offset;
3857 cur_frame_data->mask = val;
3858 cur_frame_data->mask_offset = offset;
3864 s_alpha_frame (int dummy ATTRIBUTE_UNUSED)
3866 if (ECOFF_DEBUGGING)
3867 ecoff_directive_frame (0);
3872 if (!cur_frame_data)
3874 as_warn (_(".frame outside of .ent"));
3875 discard_rest_of_line ();
3879 cur_frame_data->fp_regno = tc_get_register (1);
3882 if (*input_line_pointer++ != ','
3883 || get_absolute_expression_and_terminator (&val) != ',')
3885 as_warn (_("bad .frame directive"));
3886 --input_line_pointer;
3887 discard_rest_of_line ();
3890 cur_frame_data->frame_size = val;
3892 cur_frame_data->ra_regno = tc_get_register (0);
3894 /* Next comes the "offset of saved $a0 from $sp". In gcc terms
3895 this is current_function_pretend_args_size. There's no place
3896 to put this value, so ignore it. */
3902 s_alpha_prologue (int ignore ATTRIBUTE_UNUSED)
3907 arg = get_absolute_expression ();
3908 demand_empty_rest_of_line ();
3909 alpha_prologue_label = symbol_new
3910 (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
3912 if (ECOFF_DEBUGGING)
3913 sym = ecoff_get_cur_proc_sym ();
3915 sym = cur_frame_data ? cur_frame_data->func_sym : NULL;
3919 as_bad (_(".prologue directive without a preceding .ent directive"));
3925 case 0: /* No PV required. */
3926 S_SET_OTHER (sym, STO_ALPHA_NOPV
3927 | (S_GET_OTHER (sym) & ~STO_ALPHA_STD_GPLOAD));
3929 case 1: /* Std GP load. */
3930 S_SET_OTHER (sym, STO_ALPHA_STD_GPLOAD
3931 | (S_GET_OTHER (sym) & ~STO_ALPHA_STD_GPLOAD));
3933 case 2: /* Non-std use of PV. */
3937 as_bad (_("Invalid argument %d to .prologue."), arg);
3942 cur_frame_data->prologue_sym = symbol_temp_new_now ();
3945 static char *first_file_directive;
3948 s_alpha_file (int ignore ATTRIBUTE_UNUSED)
3950 /* Save the first .file directive we see, so that we can change our
3951 minds about whether ecoff debugging should or shouldn't be enabled. */
3952 if (alpha_flag_mdebug < 0 && ! first_file_directive)
3954 char *start = input_line_pointer;
3957 discard_rest_of_line ();
3959 len = input_line_pointer - start;
3960 first_file_directive = (char *) xmalloc (len + 1);
3961 memcpy (first_file_directive, start, len);
3962 first_file_directive[len] = '\0';
3964 input_line_pointer = start;
3967 if (ECOFF_DEBUGGING)
3968 ecoff_directive_file (0);
3970 dwarf2_directive_file (0);
3974 s_alpha_loc (int ignore ATTRIBUTE_UNUSED)
3976 if (ECOFF_DEBUGGING)
3977 ecoff_directive_loc (0);
3979 dwarf2_directive_loc (0);
3983 s_alpha_stab (int n)
3985 /* If we've been undecided about mdebug, make up our minds in favour. */
3986 if (alpha_flag_mdebug < 0)
3988 segT sec = subseg_new (".mdebug", 0);
3989 bfd_set_section_flags (stdoutput, sec, SEC_HAS_CONTENTS | SEC_READONLY);
3990 bfd_set_section_alignment (stdoutput, sec, 3);
3992 ecoff_read_begin_hook ();
3994 if (first_file_directive)
3996 char *save_ilp = input_line_pointer;
3997 input_line_pointer = first_file_directive;
3998 ecoff_directive_file (0);
3999 input_line_pointer = save_ilp;
4000 free (first_file_directive);
4003 alpha_flag_mdebug = 1;
4009 s_alpha_coff_wrapper (int which)
4011 static void (* const fns[]) (int) = {
4012 ecoff_directive_begin,
4013 ecoff_directive_bend,
4014 ecoff_directive_def,
4015 ecoff_directive_dim,
4016 ecoff_directive_endef,
4017 ecoff_directive_scl,
4018 ecoff_directive_tag,
4019 ecoff_directive_val,
4022 gas_assert (which >= 0 && which < (int) (sizeof (fns)/sizeof (*fns)));
4024 if (ECOFF_DEBUGGING)
4028 as_bad (_("ECOFF debugging is disabled."));
4029 ignore_rest_of_line ();
4033 /* Called at the end of assembly. Here we emit unwind info for frames
4034 unless the compiler has done it for us. */
4037 alpha_elf_md_end (void)
4039 struct alpha_elf_frame_data *p;
4042 as_warn (_(".ent directive without matching .end"));
4044 /* If someone has generated the unwind info themselves, great. */
4045 if (bfd_get_section_by_name (stdoutput, ".eh_frame") != NULL)
4048 /* Generate .eh_frame data for the unwind directives specified. */
4049 for (p = all_frame_data; p ; p = p->next)
4050 if (p->prologue_sym)
4052 /* Create a temporary symbol at the same location as our
4053 function symbol. This prevents problems with globals. */
4054 cfi_new_fde (symbol_temp_new (S_GET_SEGMENT (p->func_sym),
4055 S_GET_VALUE (p->func_sym),
4056 symbol_get_frag (p->func_sym)));
4058 cfi_set_return_column (p->ra_regno);
4059 cfi_add_CFA_def_cfa_register (30);
4060 if (p->fp_regno != 30 || p->mask || p->fmask || p->frame_size)
4065 cfi_add_advance_loc (p->prologue_sym);
4067 if (p->fp_regno != 30)
4068 if (p->frame_size != 0)
4069 cfi_add_CFA_def_cfa (p->fp_regno, p->frame_size);
4071 cfi_add_CFA_def_cfa_register (p->fp_regno);
4072 else if (p->frame_size != 0)
4073 cfi_add_CFA_def_cfa_offset (p->frame_size);
4076 offset = p->mask_offset;
4078 /* Recall that $26 is special-cased and stored first. */
4079 if ((mask >> 26) & 1)
4081 cfi_add_CFA_offset (26, offset);
4092 cfi_add_CFA_offset (i, offset);
4097 offset = p->fmask_offset;
4105 cfi_add_CFA_offset (i + 32, offset);
4110 cfi_end_fde (p->func_end_sym);
4115 s_alpha_usepv (int unused ATTRIBUTE_UNUSED)
4117 char *name, name_end;
4118 char *which, which_end;
4122 name = input_line_pointer;
4123 name_end = get_symbol_end ();
4125 if (! is_name_beginner (*name))
4127 as_bad (_(".usepv directive has no name"));
4128 *input_line_pointer = name_end;
4129 ignore_rest_of_line ();
4133 sym = symbol_find_or_make (name);
4134 *input_line_pointer++ = name_end;
4136 if (name_end != ',')
4138 as_bad (_(".usepv directive has no type"));
4139 ignore_rest_of_line ();
4144 which = input_line_pointer;
4145 which_end = get_symbol_end ();
4147 if (strcmp (which, "no") == 0)
4148 other = STO_ALPHA_NOPV;
4149 else if (strcmp (which, "std") == 0)
4150 other = STO_ALPHA_STD_GPLOAD;
4153 as_bad (_("unknown argument for .usepv"));
4157 *input_line_pointer = which_end;
4158 demand_empty_rest_of_line ();
4160 S_SET_OTHER (sym, other | (S_GET_OTHER (sym) & ~STO_ALPHA_STD_GPLOAD));
4162 #endif /* OBJ_ELF */
4164 /* Standard calling conventions leaves the CFA at $30 on entry. */
4167 alpha_cfi_frame_initial_instructions (void)
4169 cfi_add_CFA_def_cfa_register (30);
4174 /* Get name of section. */
4176 s_alpha_section_name (void)
4181 if (*input_line_pointer == '"')
4185 name = demand_copy_C_string (&dummy);
4188 ignore_rest_of_line ();
4194 char *end = input_line_pointer;
4196 while (0 == strchr ("\n\t,; ", *end))
4198 if (end == input_line_pointer)
4200 as_warn (_("missing name"));
4201 ignore_rest_of_line ();
4205 name = xmalloc (end - input_line_pointer + 1);
4206 memcpy (name, input_line_pointer, end - input_line_pointer);
4207 name[end - input_line_pointer] = '\0';
4208 input_line_pointer = end;
4214 /* Put clear/set flags in one flagword. The LSBs are flags to be set,
4215 the MSBs are the flags to be cleared. */
4217 #define EGPS__V_NO_SHIFT 16
4218 #define EGPS__V_MASK 0xffff
4220 /* Parse one VMS section flag. */
4223 s_alpha_section_word (char *str, size_t len)
4228 if (len == 5 && strncmp (str, "NO", 2) == 0)
4237 if (strncmp (str, "PIC", 3) == 0)
4239 else if (strncmp (str, "LIB", 3) == 0)
4241 else if (strncmp (str, "OVR", 3) == 0)
4243 else if (strncmp (str, "REL", 3) == 0)
4245 else if (strncmp (str, "GBL", 3) == 0)
4247 else if (strncmp (str, "SHR", 3) == 0)
4249 else if (strncmp (str, "EXE", 3) == 0)
4251 else if (strncmp (str, "WRT", 3) == 0)
4253 else if (strncmp (str, "VEC", 3) == 0)
4255 else if (strncmp (str, "MOD", 3) == 0)
4257 flag = no ? EGPS__V_NOMOD : EGPS__V_NOMOD << EGPS__V_NO_SHIFT;
4260 else if (strncmp (str, "COM", 3) == 0)
4268 as_warn (_("unknown section attribute %s"), str);
4274 return flag << EGPS__V_NO_SHIFT;
4279 /* Handle the section specific pseudo-op. */
4281 #define EVAX_SECTION_COUNT 5
4283 static char *section_name[EVAX_SECTION_COUNT + 1] =
4284 { "NULL", ".rdata", ".comm", ".link", ".ctors", ".dtors" };
4287 s_alpha_section (int secid)
4291 flagword vms_flags = 0;
4296 name = s_alpha_section_name ();
4299 sec = subseg_new (name, 0);
4300 if (*input_line_pointer == ',')
4302 /* Skip the comma. */
4303 ++input_line_pointer;
4311 beg = input_line_pointer;
4312 c = get_symbol_end ();
4313 *input_line_pointer = c;
4315 vms_flags |= s_alpha_section_word (beg, input_line_pointer - beg);
4319 while (*input_line_pointer++ == ',');
4320 --input_line_pointer;
4323 symbol = symbol_find_or_make (name);
4324 S_SET_SEGMENT (symbol, sec);
4325 symbol_get_bfdsym (symbol)->flags |= BSF_SECTION_SYM;
4326 bfd_vms_set_section_flags
4328 (vms_flags >> EGPS__V_NO_SHIFT) & EGPS__V_MASK,
4329 vms_flags & EGPS__V_MASK);
4333 get_absolute_expression ();
4334 subseg_new (section_name[secid], 0);
4337 demand_empty_rest_of_line ();
4338 alpha_insn_label = NULL;
4339 alpha_auto_align_on = 1;
4340 alpha_current_align = 0;
4344 s_alpha_literals (int ignore ATTRIBUTE_UNUSED)
4346 subseg_new (".literals", 0);
4347 demand_empty_rest_of_line ();
4348 alpha_insn_label = NULL;
4349 alpha_auto_align_on = 1;
4350 alpha_current_align = 0;
4353 /* Parse .ent directives. */
4356 s_alpha_ent (int ignore ATTRIBUTE_UNUSED)
4359 expressionS symexpr;
4362 = (struct alpha_evax_procs *) xmalloc (sizeof (struct alpha_evax_procs));
4364 alpha_evax_proc->pdsckind = 0;
4365 alpha_evax_proc->framereg = -1;
4366 alpha_evax_proc->framesize = 0;
4367 alpha_evax_proc->rsa_offset = 0;
4368 alpha_evax_proc->ra_save = AXP_REG_RA;
4369 alpha_evax_proc->fp_save = -1;
4370 alpha_evax_proc->imask = 0;
4371 alpha_evax_proc->fmask = 0;
4372 alpha_evax_proc->prologue = 0;
4373 alpha_evax_proc->type = 0;
4374 alpha_evax_proc->handler = 0;
4375 alpha_evax_proc->handler_data = 0;
4377 expression (&symexpr);
4379 if (symexpr.X_op != O_symbol)
4381 as_fatal (_(".ent directive has no symbol"));
4382 demand_empty_rest_of_line ();
4386 symbol = make_expr_symbol (&symexpr);
4387 symbol_get_bfdsym (symbol)->flags |= BSF_FUNCTION;
4388 alpha_evax_proc->symbol = symbol;
4391 (alpha_evax_proc_hash,
4392 symbol_get_bfdsym (alpha_evax_proc->symbol)->name, (PTR)alpha_evax_proc);
4394 demand_empty_rest_of_line ();
4398 s_alpha_handler (int is_data)
4401 alpha_evax_proc->handler_data = get_absolute_expression ();
4404 char *name, name_end;
4405 name = input_line_pointer;
4406 name_end = get_symbol_end ();
4408 if (! is_name_beginner (*name))
4410 as_warn (_(".handler directive has no name"));
4411 *input_line_pointer = name_end;
4417 sym = symbol_find_or_make (name);
4418 symbol_get_bfdsym (sym)->flags |= BSF_FUNCTION;
4419 alpha_evax_proc->handler = sym;
4420 *input_line_pointer = name_end;
4423 demand_empty_rest_of_line ();
4426 /* Parse .frame <framreg>,<framesize>,RA,<rsa_offset> directives. */
4429 s_alpha_frame (int ignore ATTRIBUTE_UNUSED)
4433 alpha_evax_proc->framereg = tc_get_register (1);
4436 if (*input_line_pointer++ != ','
4437 || get_absolute_expression_and_terminator (&val) != ',')
4439 as_warn (_("Bad .frame directive 1./2. param"));
4440 --input_line_pointer;
4441 demand_empty_rest_of_line ();
4445 alpha_evax_proc->framesize = val;
4447 (void) tc_get_register (1);
4449 if (*input_line_pointer++ != ',')
4451 as_warn (_("Bad .frame directive 3./4. param"));
4452 --input_line_pointer;
4453 demand_empty_rest_of_line ();
4456 alpha_evax_proc->rsa_offset = get_absolute_expression ();
4459 /* Parse .prologue. */
4462 s_alpha_prologue (int ignore ATTRIBUTE_UNUSED)
4464 get_absolute_expression ();
4465 demand_empty_rest_of_line ();
4466 alpha_prologue_label = symbol_new
4467 (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
4470 /* Parse .pdesc <entry_name>.
4471 Insert a procedure descriptor. */
4474 s_alpha_pdesc (int ignore ATTRIBUTE_UNUSED)
4482 segment_info_type *seginfo = seg_info (alpha_link_section);
4483 const char *entry_sym_name;
4487 if (now_seg != alpha_link_section)
4489 as_bad (_(".pdesc directive not in link (.link) section"));
4490 demand_empty_rest_of_line ();
4495 if (exp.X_op != O_symbol)
4497 as_warn (_(".pdesc directive has no entry symbol"));
4498 demand_empty_rest_of_line ();
4502 entry_sym = make_expr_symbol (&exp);
4503 entry_sym_name = symbol_get_bfdsym (entry_sym)->name;
4505 len = strlen (entry_sym_name);
4506 sym_name = (char *) xmalloc (len - 4 + 1);
4507 strncpy (sym_name, entry_sym_name, len - 4);
4508 sym_name [len - 4] = 0;
4510 alpha_evax_proc = (struct alpha_evax_procs *)
4511 hash_find (alpha_evax_proc_hash, sym_name);
4513 if (!alpha_evax_proc || !S_IS_DEFINED (alpha_evax_proc->symbol))
4515 as_fatal (_(".pdesc has no matching .ent"));
4516 demand_empty_rest_of_line ();
4520 *symbol_get_obj (alpha_evax_proc->symbol) =
4521 (valueT) seginfo->literal_pool_size;
4523 alpha_evax_proc->symbol->sy_obj = (valueT)seginfo->literal_pool_size;
4525 /* Save bfd symbol of proc entry in function symbol. */
4526 ((struct evax_private_udata_struct *)
4527 symbol_get_bfdsym (alpha_evax_proc->symbol)->udata.p)->enbsym
4528 = symbol_get_bfdsym (entry_sym);
4531 if (*input_line_pointer++ != ',')
4533 as_warn (_("No comma after .pdesc <entryname>"));
4534 demand_empty_rest_of_line ();
4539 name = input_line_pointer;
4540 name_end = get_symbol_end ();
4542 if (strncmp (name, "stack", 5) == 0)
4543 alpha_evax_proc->pdsckind = PDSC_S_K_KIND_FP_STACK;
4545 else if (strncmp (name, "reg", 3) == 0)
4546 alpha_evax_proc->pdsckind = PDSC_S_K_KIND_FP_REGISTER;
4548 else if (strncmp (name, "null", 4) == 0)
4549 alpha_evax_proc->pdsckind = PDSC_S_K_KIND_NULL;
4553 as_fatal (_("unknown procedure kind"));
4554 demand_empty_rest_of_line ();
4558 *input_line_pointer = name_end;
4559 demand_empty_rest_of_line ();
4561 #ifdef md_flush_pending_output
4562 md_flush_pending_output ();
4565 frag_align (3, 0, 0);
4567 fixp = fix_new (frag_now, p - frag_now->fr_literal, 8, 0, 0, 0, 0);
4569 seginfo->literal_pool_size += 16;
4571 *p = alpha_evax_proc->pdsckind
4572 | ((alpha_evax_proc->framereg == 29) ? PDSC_S_M_BASE_REG_IS_FP : 0)
4573 | ((alpha_evax_proc->handler) ? PDSC_S_M_HANDLER_VALID : 0)
4574 | ((alpha_evax_proc->handler_data) ? PDSC_S_M_HANDLER_DATA_VALID : 0);
4575 *(p + 1) = PDSC_S_M_NATIVE | PDSC_S_M_NO_JACKET;
4577 switch (alpha_evax_proc->pdsckind)
4579 case PDSC_S_K_KIND_NULL:
4583 case PDSC_S_K_KIND_FP_REGISTER:
4584 *(p + 2) = alpha_evax_proc->fp_save;
4585 *(p + 3) = alpha_evax_proc->ra_save;
4587 case PDSC_S_K_KIND_FP_STACK:
4588 md_number_to_chars (p + 2, (valueT) alpha_evax_proc->rsa_offset, 2);
4590 default: /* impossible */
4595 *(p + 5) = alpha_evax_proc->type & 0x0f;
4597 /* Signature offset. */
4598 md_number_to_chars (p + 6, (valueT) 0, 2);
4600 fix_new_exp (frag_now, p - frag_now->fr_literal+8, 8, &exp, 0, BFD_RELOC_64);
4602 if (alpha_evax_proc->pdsckind == PDSC_S_K_KIND_NULL)
4605 /* Add dummy fix to make add_to_link_pool work. */
4607 fixp = fix_new (frag_now, p - frag_now->fr_literal, 6, 0, 0, 0, 0);
4609 seginfo->literal_pool_size += 6;
4611 /* pdesc+16: Size. */
4612 md_number_to_chars (p, (valueT) alpha_evax_proc->framesize, 4);
4614 md_number_to_chars (p + 4, (valueT) 0, 2);
4617 exp.X_op = O_subtract;
4618 exp.X_add_symbol = alpha_prologue_label;
4619 exp.X_op_symbol = entry_sym;
4620 emit_expr (&exp, 2);
4622 if (alpha_evax_proc->pdsckind == PDSC_S_K_KIND_FP_REGISTER)
4625 /* Add dummy fix to make add_to_link_pool work. */
4627 fixp = fix_new (frag_now, p - frag_now->fr_literal, 8, 0, 0, 0, 0);
4629 seginfo->literal_pool_size += 8;
4631 /* pdesc+24: register masks. */
4633 md_number_to_chars (p, alpha_evax_proc->imask, 4);
4634 md_number_to_chars (p + 4, alpha_evax_proc->fmask, 4);
4636 if (alpha_evax_proc->handler)
4639 fixp = fix_new (frag_now, p - frag_now->fr_literal, 8,
4640 alpha_evax_proc->handler, 0, 0, BFD_RELOC_64);
4643 if (alpha_evax_proc->handler_data)
4645 /* Add dummy fix to make add_to_link_pool work. */
4647 fixp = fix_new (frag_now, p - frag_now->fr_literal, 8, 0, 0, 0, 0);
4649 seginfo->literal_pool_size += 8;
4650 md_number_to_chars (p, alpha_evax_proc->handler_data, 8);
4654 /* Support for crash debug on vms. */
4657 s_alpha_name (int ignore ATTRIBUTE_UNUSED)
4661 segment_info_type *seginfo = seg_info (alpha_link_section);
4663 if (now_seg != alpha_link_section)
4665 as_bad (_(".name directive not in link (.link) section"));
4666 demand_empty_rest_of_line ();
4671 if (exp.X_op != O_symbol)
4673 as_warn (_(".name directive has no symbol"));
4674 demand_empty_rest_of_line ();
4678 demand_empty_rest_of_line ();
4680 #ifdef md_flush_pending_output
4681 md_flush_pending_output ();
4684 frag_align (3, 0, 0);
4686 seginfo->literal_pool_size += 8;
4688 fix_new_exp (frag_now, p - frag_now->fr_literal, 8, &exp, 0, BFD_RELOC_64);
4691 /* Parse .linkage <symbol>.
4692 Create a linkage pair relocation. */
4695 s_alpha_linkage (int ignore ATTRIBUTE_UNUSED)
4701 #ifdef md_flush_pending_output
4702 md_flush_pending_output ();
4706 if (exp.X_op != O_symbol)
4708 as_fatal (_("No symbol after .linkage"));
4712 struct alpha_linkage_fixups *linkage_fixup;
4714 p = frag_more (LKP_S_K_SIZE);
4715 memset (p, 0, LKP_S_K_SIZE);
4717 (frag_now, p - frag_now->fr_literal, LKP_S_K_SIZE, &exp, 0,\
4718 BFD_RELOC_ALPHA_LINKAGE);
4720 linkage_fixup = (struct alpha_linkage_fixups *)
4721 xmalloc (sizeof (struct alpha_linkage_fixups));
4723 linkage_fixup->fixp = fixp;
4724 linkage_fixup->next = 0;
4726 if (alpha_insn_label == 0)
4727 alpha_insn_label = symbol_new
4728 (FAKE_LABEL_NAME, now_seg, (valueT) frag_now_fix (), frag_now);
4729 linkage_fixup->label = alpha_insn_label;
4731 if (alpha_linkage_fixup_root == 0)
4733 alpha_linkage_fixup_root = alpha_linkage_fixup_tail = linkage_fixup;
4734 alpha_linkage_fixup_tail->next = 0;
4738 alpha_linkage_fixup_tail->next = linkage_fixup;
4739 alpha_linkage_fixup_tail = linkage_fixup;
4740 alpha_linkage_fixup_tail->next = 0;
4743 demand_empty_rest_of_line ();
4746 /* Parse .code_address <symbol>.
4747 Create a code address relocation. */
4750 s_alpha_code_address (int ignore ATTRIBUTE_UNUSED)
4755 #ifdef md_flush_pending_output
4756 md_flush_pending_output ();
4760 if (exp.X_op != O_symbol)
4761 as_fatal (_("No symbol after .code_address"));
4766 fix_new_exp (frag_now, p - frag_now->fr_literal, 8, &exp, 0,\
4767 BFD_RELOC_ALPHA_CODEADDR);
4769 demand_empty_rest_of_line ();
4773 s_alpha_fp_save (int ignore ATTRIBUTE_UNUSED)
4776 alpha_evax_proc->fp_save = tc_get_register (1);
4778 demand_empty_rest_of_line ();
4782 s_alpha_mask (int ignore ATTRIBUTE_UNUSED)
4786 if (get_absolute_expression_and_terminator (&val) != ',')
4788 as_warn (_("Bad .mask directive"));
4789 --input_line_pointer;
4793 alpha_evax_proc->imask = val;
4794 (void) get_absolute_expression ();
4796 demand_empty_rest_of_line ();
4800 s_alpha_fmask (int ignore ATTRIBUTE_UNUSED)
4804 if (get_absolute_expression_and_terminator (&val) != ',')
4806 as_warn (_("Bad .fmask directive"));
4807 --input_line_pointer;
4811 alpha_evax_proc->fmask = val;
4812 (void) get_absolute_expression ();
4814 demand_empty_rest_of_line ();
4818 s_alpha_end (int ignore ATTRIBUTE_UNUSED)
4822 c = get_symbol_end ();
4823 *input_line_pointer = c;
4824 demand_empty_rest_of_line ();
4825 alpha_evax_proc = 0;
4829 s_alpha_file (int ignore ATTRIBUTE_UNUSED)
4833 static char case_hack[32];
4835 sprintf (case_hack, "<CASE:%01d%01d>",
4836 alpha_flag_hash_long_names, alpha_flag_show_after_trunc);
4838 s = symbol_find_or_make (case_hack);
4839 symbol_get_bfdsym (s)->flags |= BSF_FILE;
4841 get_absolute_expression ();
4842 s = symbol_find_or_make (demand_copy_string (&length));
4843 symbol_get_bfdsym (s)->flags |= BSF_FILE;
4844 demand_empty_rest_of_line ();
4846 #endif /* OBJ_EVAX */
4848 /* Handle the .gprel32 pseudo op. */
4851 s_alpha_gprel32 (int ignore ATTRIBUTE_UNUSED)
4863 e.X_add_symbol = section_symbol (absolute_section);
4876 e.X_add_symbol = section_symbol (absolute_section);
4879 e.X_op = O_subtract;
4880 e.X_op_symbol = alpha_gp_symbol;
4888 if (alpha_auto_align_on && alpha_current_align < 2)
4889 alpha_align (2, (char *) NULL, alpha_insn_label, 0);
4890 if (alpha_current_align > 2)
4891 alpha_current_align = 2;
4892 alpha_insn_label = NULL;
4896 fix_new_exp (frag_now, p - frag_now->fr_literal, 4,
4897 &e, 0, BFD_RELOC_GPREL32);
4900 /* Handle floating point allocation pseudo-ops. This is like the
4901 generic vresion, but it makes sure the current label, if any, is
4902 correctly aligned. */
4905 s_alpha_float_cons (int type)
4931 if (alpha_auto_align_on && alpha_current_align < log_size)
4932 alpha_align (log_size, (char *) NULL, alpha_insn_label, 0);
4933 if (alpha_current_align > log_size)
4934 alpha_current_align = log_size;
4935 alpha_insn_label = NULL;
4940 /* Handle the .proc pseudo op. We don't really do much with it except
4944 s_alpha_proc (int is_static ATTRIBUTE_UNUSED)
4952 /* Takes ".proc name,nargs". */
4954 name = input_line_pointer;
4955 c = get_symbol_end ();
4956 p = input_line_pointer;
4957 symbolP = symbol_find_or_make (name);
4960 if (*input_line_pointer != ',')
4963 as_warn (_("Expected comma after name \"%s\""), name);
4966 ignore_rest_of_line ();
4970 input_line_pointer++;
4971 temp = get_absolute_expression ();
4973 /* *symbol_get_obj (symbolP) = (signed char) temp; */
4975 as_warn (_("unhandled: .proc %s,%d"), name, temp);
4976 demand_empty_rest_of_line ();
4979 /* Handle the .set pseudo op. This is used to turn on and off most of
4980 the assembler features. */
4983 s_alpha_set (int x ATTRIBUTE_UNUSED)
4989 name = input_line_pointer;
4990 ch = get_symbol_end ();
4993 if (s[0] == 'n' && s[1] == 'o')
4998 if (!strcmp ("reorder", s))
5000 else if (!strcmp ("at", s))
5001 alpha_noat_on = !yesno;
5002 else if (!strcmp ("macro", s))
5003 alpha_macros_on = yesno;
5004 else if (!strcmp ("move", s))
5006 else if (!strcmp ("volatile", s))
5009 as_warn (_("Tried to .set unrecognized mode `%s'"), name);
5011 *input_line_pointer = ch;
5012 demand_empty_rest_of_line ();
5015 /* Handle the .base pseudo op. This changes the assembler's notion of
5016 the $gp register. */
5019 s_alpha_base (int ignore ATTRIBUTE_UNUSED)
5023 if (*input_line_pointer == '$')
5026 input_line_pointer++;
5027 if (*input_line_pointer == 'r')
5028 input_line_pointer++;
5031 alpha_gp_register = get_absolute_expression ();
5032 if (alpha_gp_register < 0 || alpha_gp_register > 31)
5034 alpha_gp_register = AXP_REG_GP;
5035 as_warn (_("Bad base register, using $%d."), alpha_gp_register);
5038 demand_empty_rest_of_line ();
5041 /* Handle the .align pseudo-op. This aligns to a power of two. It
5042 also adjusts any current instruction label. We treat this the same
5043 way the MIPS port does: .align 0 turns off auto alignment. */
5046 s_alpha_align (int ignore ATTRIBUTE_UNUSED)
5050 long max_alignment = 16;
5052 align = get_absolute_expression ();
5053 if (align > max_alignment)
5055 align = max_alignment;
5056 as_bad (_("Alignment too large: %d. assumed"), align);
5060 as_warn (_("Alignment negative: 0 assumed"));
5064 if (*input_line_pointer == ',')
5066 input_line_pointer++;
5067 fill = get_absolute_expression ();
5075 alpha_auto_align_on = 1;
5076 alpha_align (align, pfill, NULL, 1);
5080 alpha_auto_align_on = 0;
5082 alpha_insn_label = NULL;
5084 demand_empty_rest_of_line ();
5087 /* Hook the normal string processor to reset known alignment. */
5090 s_alpha_stringer (int terminate)
5092 alpha_current_align = 0;
5093 alpha_insn_label = NULL;
5094 stringer (8 + terminate);
5097 /* Hook the normal space processing to reset known alignment. */
5100 s_alpha_space (int ignore)
5102 alpha_current_align = 0;
5103 alpha_insn_label = NULL;
5107 /* Hook into cons for auto-alignment. */
5110 alpha_cons_align (int size)
5115 while ((size >>= 1) != 0)
5118 if (alpha_auto_align_on && alpha_current_align < log_size)
5119 alpha_align (log_size, (char *) NULL, alpha_insn_label, 0);
5120 if (alpha_current_align > log_size)
5121 alpha_current_align = log_size;
5122 alpha_insn_label = NULL;
5125 /* Here come the .uword, .ulong, and .uquad explicitly unaligned
5126 pseudos. We just turn off auto-alignment and call down to cons. */
5129 s_alpha_ucons (int bytes)
5131 int hold = alpha_auto_align_on;
5132 alpha_auto_align_on = 0;
5134 alpha_auto_align_on = hold;
5137 /* Switch the working cpu type. */
5140 s_alpha_arch (int ignored ATTRIBUTE_UNUSED)
5143 const struct cpu_type *p;
5146 name = input_line_pointer;
5147 ch = get_symbol_end ();
5149 for (p = cpu_types; p->name; ++p)
5150 if (strcmp (name, p->name) == 0)
5152 alpha_target_name = p->name, alpha_target = p->flags;
5155 as_warn (_("Unknown CPU identifier `%s'"), name);
5158 *input_line_pointer = ch;
5159 demand_empty_rest_of_line ();
5163 /* print token expression with alpha specific extension. */
5166 alpha_print_token (FILE *f, const expressionS *exp)
5176 expressionS nexp = *exp;
5177 nexp.X_op = O_register;
5178 print_expr_1 (f, &nexp);
5183 print_expr_1 (f, exp);
5189 /* The target specific pseudo-ops which we support. */
5191 const pseudo_typeS md_pseudo_table[] =
5194 {"comm", s_alpha_comm, 0}, /* OSF1 compiler does this. */
5195 {"rdata", s_alpha_rdata, 0},
5197 {"text", s_alpha_text, 0},
5198 {"data", s_alpha_data, 0},
5200 {"sdata", s_alpha_sdata, 0},
5203 {"section", s_alpha_section, 0},
5204 {"section.s", s_alpha_section, 0},
5205 {"sect", s_alpha_section, 0},
5206 {"sect.s", s_alpha_section, 0},
5209 {"section", s_alpha_section, 0},
5210 {"literals", s_alpha_literals, 0},
5211 {"pdesc", s_alpha_pdesc, 0},
5212 {"name", s_alpha_name, 0},
5213 {"linkage", s_alpha_linkage, 0},
5214 {"code_address", s_alpha_code_address, 0},
5215 {"ent", s_alpha_ent, 0},
5216 {"frame", s_alpha_frame, 0},
5217 {"fp_save", s_alpha_fp_save, 0},
5218 {"mask", s_alpha_mask, 0},
5219 {"fmask", s_alpha_fmask, 0},
5220 {"end", s_alpha_end, 0},
5221 {"file", s_alpha_file, 0},
5222 {"rdata", s_alpha_section, 1},
5223 {"comm", s_alpha_comm, 0},
5224 {"link", s_alpha_section, 3},
5225 {"ctors", s_alpha_section, 4},
5226 {"dtors", s_alpha_section, 5},
5227 {"handler", s_alpha_handler, 0},
5228 {"handler_data", s_alpha_handler, 1},
5231 /* Frame related pseudos. */
5232 {"ent", s_alpha_ent, 0},
5233 {"end", s_alpha_end, 0},
5234 {"mask", s_alpha_mask, 0},
5235 {"fmask", s_alpha_mask, 1},
5236 {"frame", s_alpha_frame, 0},
5237 {"prologue", s_alpha_prologue, 0},
5238 {"file", s_alpha_file, 5},
5239 {"loc", s_alpha_loc, 9},
5240 {"stabs", s_alpha_stab, 's'},
5241 {"stabn", s_alpha_stab, 'n'},
5242 {"usepv", s_alpha_usepv, 0},
5243 /* COFF debugging related pseudos. */
5244 {"begin", s_alpha_coff_wrapper, 0},
5245 {"bend", s_alpha_coff_wrapper, 1},
5246 {"def", s_alpha_coff_wrapper, 2},
5247 {"dim", s_alpha_coff_wrapper, 3},
5248 {"endef", s_alpha_coff_wrapper, 4},
5249 {"scl", s_alpha_coff_wrapper, 5},
5250 {"tag", s_alpha_coff_wrapper, 6},
5251 {"val", s_alpha_coff_wrapper, 7},
5254 {"prologue", s_alpha_prologue, 0},
5256 {"prologue", s_ignore, 0},
5259 {"gprel32", s_alpha_gprel32, 0},
5260 {"t_floating", s_alpha_float_cons, 'd'},
5261 {"s_floating", s_alpha_float_cons, 'f'},
5262 {"f_floating", s_alpha_float_cons, 'F'},
5263 {"g_floating", s_alpha_float_cons, 'G'},
5264 {"d_floating", s_alpha_float_cons, 'D'},
5266 {"proc", s_alpha_proc, 0},
5267 {"aproc", s_alpha_proc, 1},
5268 {"set", s_alpha_set, 0},
5269 {"reguse", s_ignore, 0},
5270 {"livereg", s_ignore, 0},
5271 {"base", s_alpha_base, 0}, /*??*/
5272 {"option", s_ignore, 0},
5273 {"aent", s_ignore, 0},
5274 {"ugen", s_ignore, 0},
5275 {"eflag", s_ignore, 0},
5277 {"align", s_alpha_align, 0},
5278 {"double", s_alpha_float_cons, 'd'},
5279 {"float", s_alpha_float_cons, 'f'},
5280 {"single", s_alpha_float_cons, 'f'},
5281 {"ascii", s_alpha_stringer, 0},
5282 {"asciz", s_alpha_stringer, 1},
5283 {"string", s_alpha_stringer, 1},
5284 {"space", s_alpha_space, 0},
5285 {"skip", s_alpha_space, 0},
5286 {"zero", s_alpha_space, 0},
5288 /* Unaligned data pseudos. */
5289 {"uword", s_alpha_ucons, 2},
5290 {"ulong", s_alpha_ucons, 4},
5291 {"uquad", s_alpha_ucons, 8},
5294 /* Dwarf wants these versions of unaligned. */
5295 {"2byte", s_alpha_ucons, 2},
5296 {"4byte", s_alpha_ucons, 4},
5297 {"8byte", s_alpha_ucons, 8},
5300 /* We don't do any optimizing, so we can safely ignore these. */
5301 {"noalias", s_ignore, 0},
5302 {"alias", s_ignore, 0},
5304 {"arch", s_alpha_arch, 0},
5311 /* @@@ GP selection voodoo. All of this seems overly complicated and
5312 unnecessary; which is the primary reason it's for ECOFF only. */
5315 maybe_set_gp (asection *sec)
5321 vma = bfd_get_section_vma (foo, sec);
5322 if (vma && vma < alpha_gp_value)
5323 alpha_gp_value = vma;
5327 select_gp_value (void)
5329 gas_assert (alpha_gp_value == 0);
5331 /* Get minus-one in whatever width... */
5335 /* Select the smallest VMA of these existing sections. */
5336 maybe_set_gp (alpha_lita_section);
5338 /* @@ Will a simple 0x8000 work here? If not, why not? */
5339 #define GP_ADJUSTMENT (0x8000 - 0x10)
5341 alpha_gp_value += GP_ADJUSTMENT;
5343 S_SET_VALUE (alpha_gp_symbol, alpha_gp_value);
5346 printf (_("Chose GP value of %lx\n"), alpha_gp_value);
5349 #endif /* OBJ_ECOFF */
5352 /* Map 's' to SHF_ALPHA_GPREL. */
5355 alpha_elf_section_letter (int letter, char **ptr_msg)
5358 return SHF_ALPHA_GPREL;
5360 *ptr_msg = _("bad .section directive: want a,s,w,x,M,S,G,T in string");
5364 /* Map SHF_ALPHA_GPREL to SEC_SMALL_DATA. */
5367 alpha_elf_section_flags (flagword flags, bfd_vma attr, int type ATTRIBUTE_UNUSED)
5369 if (attr & SHF_ALPHA_GPREL)
5370 flags |= SEC_SMALL_DATA;
5373 #endif /* OBJ_ELF */
5375 /* This is called from HANDLE_ALIGN in write.c. Fill in the contents
5376 of an rs_align_code fragment. */
5379 alpha_handle_align (fragS *fragp)
5381 static char const unop[4] = { 0x00, 0x00, 0xfe, 0x2f };
5382 static char const nopunop[8] =
5384 0x1f, 0x04, 0xff, 0x47,
5385 0x00, 0x00, 0xfe, 0x2f
5391 if (fragp->fr_type != rs_align_code)
5394 bytes = fragp->fr_next->fr_address - fragp->fr_address - fragp->fr_fix;
5395 p = fragp->fr_literal + fragp->fr_fix;
5408 memcpy (p, unop, 4);
5414 memcpy (p, nopunop, 8);
5416 fragp->fr_fix += fix;
5420 /* Public interface functions. */
5422 /* This function is called once, at assembler startup time. It sets
5423 up all the tables, etc. that the MD part of the assembler will
5424 need, that can be determined before arguments are parsed. */
5431 /* Verify that X_op field is wide enough. */
5436 gas_assert (e.X_op == O_max);
5439 /* Create the opcode hash table. */
5440 alpha_opcode_hash = hash_new ();
5442 for (i = 0; i < alpha_num_opcodes;)
5444 const char *name, *retval, *slash;
5446 name = alpha_opcodes[i].name;
5447 retval = hash_insert (alpha_opcode_hash, name, (void *) &alpha_opcodes[i]);
5449 as_fatal (_("internal error: can't hash opcode `%s': %s"),
5452 /* Some opcodes include modifiers of various sorts with a "/mod"
5453 syntax, like the architecture manual suggests. However, for
5454 use with gcc at least, we also need access to those same opcodes
5457 if ((slash = strchr (name, '/')) != NULL)
5459 char *p = (char *) xmalloc (strlen (name));
5461 memcpy (p, name, slash - name);
5462 strcpy (p + (slash - name), slash + 1);
5464 (void) hash_insert (alpha_opcode_hash, p, (void *) &alpha_opcodes[i]);
5465 /* Ignore failures -- the opcode table does duplicate some
5466 variants in different forms, like "hw_stq" and "hw_st/q". */
5469 while (++i < alpha_num_opcodes
5470 && (alpha_opcodes[i].name == name
5471 || !strcmp (alpha_opcodes[i].name, name)))
5475 /* Create the macro hash table. */
5476 alpha_macro_hash = hash_new ();
5478 for (i = 0; i < alpha_num_macros;)
5480 const char *name, *retval;
5482 name = alpha_macros[i].name;
5483 retval = hash_insert (alpha_macro_hash, name, (void *) &alpha_macros[i]);
5485 as_fatal (_("internal error: can't hash macro `%s': %s"),
5488 while (++i < alpha_num_macros
5489 && (alpha_macros[i].name == name
5490 || !strcmp (alpha_macros[i].name, name)))
5494 /* Construct symbols for each of the registers. */
5495 for (i = 0; i < 32; ++i)
5499 sprintf (name, "$%d", i);
5500 alpha_register_table[i] = symbol_create (name, reg_section, i,
5501 &zero_address_frag);
5508 sprintf (name, "$f%d", i - 32);
5509 alpha_register_table[i] = symbol_create (name, reg_section, i,
5510 &zero_address_frag);
5513 /* Create the special symbols and sections we'll be using. */
5515 /* So .sbss will get used for tiny objects. */
5516 bfd_set_gp_size (stdoutput, g_switch_value);
5519 create_literal_section (".lita", &alpha_lita_section, &alpha_lita_symbol);
5521 /* For handling the GP, create a symbol that won't be output in the
5522 symbol table. We'll edit it out of relocs later. */
5523 alpha_gp_symbol = symbol_create ("<GP value>", alpha_lita_section, 0x8000,
5524 &zero_address_frag);
5528 create_literal_section (".link", &alpha_link_section, &alpha_link_symbol);
5529 alpha_evax_proc_hash = hash_new ();
5533 if (ECOFF_DEBUGGING)
5535 segT sec = subseg_new (".mdebug", (subsegT) 0);
5536 bfd_set_section_flags (stdoutput, sec, SEC_HAS_CONTENTS | SEC_READONLY);
5537 bfd_set_section_alignment (stdoutput, sec, 3);
5541 /* Create literal lookup hash table. */
5542 alpha_literal_hash = hash_new ();
5544 subseg_set (text_section, 0);
5547 /* The public interface to the instruction assembler. */
5550 md_assemble (char *str)
5552 /* Current maximum is 13. */
5554 expressionS tok[MAX_INSN_ARGS];
5558 /* Split off the opcode. */
5559 opnamelen = strspn (str, "abcdefghijklmnopqrstuvwxyz_/46819");
5560 trunclen = (opnamelen < sizeof (opname) - 1
5562 : sizeof (opname) - 1);
5563 memcpy (opname, str, trunclen);
5564 opname[trunclen] = '\0';
5566 /* Tokenize the rest of the line. */
5567 if ((ntok = tokenize_arguments (str + opnamelen, tok, MAX_INSN_ARGS)) < 0)
5569 if (ntok != TOKENIZE_ERROR_REPORT)
5570 as_bad (_("syntax error"));
5575 /* Finish it off. */
5576 assemble_tokens (opname, tok, ntok, alpha_macros_on);
5579 /* Round up a section's size to the appropriate boundary. */
5582 md_section_align (segT seg, valueT size)
5584 int align = bfd_get_section_alignment (stdoutput, seg);
5585 valueT mask = ((valueT) 1 << align) - 1;
5587 return (size + mask) & ~mask;
5590 /* Turn a string in input_line_pointer into a floating point constant
5591 of type TYPE, and store the appropriate bytes in *LITP. The number
5592 of LITTLENUMS emitted is stored in *SIZEP. An error message is
5593 returned, or NULL on OK. */
5596 md_atof (int type, char *litP, int *sizeP)
5598 extern char *vax_md_atof (int, char *, int *);
5604 /* vax_md_atof() doesn't like "G" for some reason. */
5608 return vax_md_atof (type, litP, sizeP);
5611 return ieee_md_atof (type, litP, sizeP, FALSE);
5615 /* Take care of the target-specific command-line options. */
5618 md_parse_option (int c, char *arg)
5623 alpha_nofloats_on = 1;
5627 alpha_addr32_on = 1;
5635 g_switch_value = atoi (arg);
5640 const struct cpu_type *p;
5642 for (p = cpu_types; p->name; ++p)
5643 if (strcmp (arg, p->name) == 0)
5645 alpha_target_name = p->name, alpha_target = p->flags;
5648 as_warn (_("Unknown CPU identifier `%s'"), arg);
5654 case '+': /* For g++. Hash any name > 63 chars long. */
5655 alpha_flag_hash_long_names = 1;
5658 case 'H': /* Show new symbol after hash truncation. */
5659 alpha_flag_show_after_trunc = 1;
5662 case 'h': /* For gnu-c/vax compatibility. */
5665 case OPTION_REPLACE:
5666 alpha_flag_replace = 1;
5669 case OPTION_NOREPLACE:
5670 alpha_flag_replace = 0;
5675 alpha_flag_relax = 1;
5680 alpha_flag_mdebug = 1;
5682 case OPTION_NO_MDEBUG:
5683 alpha_flag_mdebug = 0;
5694 /* Print a description of the command-line options that we accept. */
5697 md_show_usage (FILE *stream)
5701 -32addr treat addresses as 32-bit values\n\
5702 -F lack floating point instructions support\n\
5703 -mev4 | -mev45 | -mev5 | -mev56 | -mpca56 | -mev6 | -mev67 | -mev68 | -mall\n\
5704 specify variant of Alpha architecture\n\
5705 -m21064 | -m21066 | -m21164 | -m21164a | -m21164pc | -m21264 | -m21264a | -m21264b\n\
5706 these variants include PALcode opcodes\n"),
5711 -+ encode (don't truncate) names longer than 64 characters\n\
5712 -H show new symbol after hash truncation\n\
5713 -replace/-noreplace enable or disable the optimization of procedure calls\n"),
5718 /* Decide from what point a pc-relative relocation is relative to,
5719 relative to the pc-relative fixup. Er, relatively speaking. */
5722 md_pcrel_from (fixS *fixP)
5724 valueT addr = fixP->fx_where + fixP->fx_frag->fr_address;
5726 switch (fixP->fx_r_type)
5728 case BFD_RELOC_23_PCREL_S2:
5729 case BFD_RELOC_ALPHA_HINT:
5730 case BFD_RELOC_ALPHA_BRSGP:
5737 /* Attempt to simplify or even eliminate a fixup. The return value is
5738 ignored; perhaps it was once meaningful, but now it is historical.
5739 To indicate that a fixup has been eliminated, set fixP->fx_done.
5741 For ELF, here it is that we transform the GPDISP_HI16 reloc we used
5742 internally into the GPDISP reloc used externally. We had to do
5743 this so that we'd have the GPDISP_LO16 reloc as a tag to compute
5744 the distance to the "lda" instruction for setting the addend to
5748 md_apply_fix (fixS *fixP, valueT * valP, segT seg)
5750 char * const fixpos = fixP->fx_frag->fr_literal + fixP->fx_where;
5751 valueT value = * valP;
5752 unsigned image, size;
5754 switch (fixP->fx_r_type)
5756 /* The GPDISP relocations are processed internally with a symbol
5757 referring to the current function's section; we need to drop
5758 in a value which, when added to the address of the start of
5759 the function, gives the desired GP. */
5760 case BFD_RELOC_ALPHA_GPDISP_HI16:
5762 fixS *next = fixP->fx_next;
5764 /* With user-specified !gpdisp relocations, we can be missing
5765 the matching LO16 reloc. We will have already issued an
5768 fixP->fx_offset = (next->fx_frag->fr_address + next->fx_where
5769 - fixP->fx_frag->fr_address - fixP->fx_where);
5771 value = (value - sign_extend_16 (value)) >> 16;
5774 fixP->fx_r_type = BFD_RELOC_ALPHA_GPDISP;
5778 case BFD_RELOC_ALPHA_GPDISP_LO16:
5779 value = sign_extend_16 (value);
5780 fixP->fx_offset = 0;
5786 fixP->fx_addsy = section_symbol (seg);
5787 md_number_to_chars (fixpos, value, 2);
5792 fixP->fx_r_type = BFD_RELOC_16_PCREL;
5798 fixP->fx_r_type = BFD_RELOC_32_PCREL;
5804 fixP->fx_r_type = BFD_RELOC_64_PCREL;
5808 if (fixP->fx_pcrel == 0 && fixP->fx_addsy == 0)
5810 md_number_to_chars (fixpos, value, size);
5816 case BFD_RELOC_GPREL32:
5817 gas_assert (fixP->fx_subsy == alpha_gp_symbol);
5819 /* FIXME: inherited this obliviousness of `value' -- why? */
5820 md_number_to_chars (fixpos, -alpha_gp_value, 4);
5823 case BFD_RELOC_GPREL32:
5825 case BFD_RELOC_GPREL16:
5826 case BFD_RELOC_ALPHA_GPREL_HI16:
5827 case BFD_RELOC_ALPHA_GPREL_LO16:
5830 case BFD_RELOC_23_PCREL_S2:
5831 if (fixP->fx_pcrel == 0 && fixP->fx_addsy == 0)
5833 image = bfd_getl32 (fixpos);
5834 image = (image & ~0x1FFFFF) | ((value >> 2) & 0x1FFFFF);
5839 case BFD_RELOC_ALPHA_HINT:
5840 if (fixP->fx_pcrel == 0 && fixP->fx_addsy == 0)
5842 image = bfd_getl32 (fixpos);
5843 image = (image & ~0x3FFF) | ((value >> 2) & 0x3FFF);
5849 case BFD_RELOC_ALPHA_BRSGP:
5852 case BFD_RELOC_ALPHA_TLSGD:
5853 case BFD_RELOC_ALPHA_TLSLDM:
5854 case BFD_RELOC_ALPHA_GOTDTPREL16:
5855 case BFD_RELOC_ALPHA_DTPREL_HI16:
5856 case BFD_RELOC_ALPHA_DTPREL_LO16:
5857 case BFD_RELOC_ALPHA_DTPREL16:
5858 case BFD_RELOC_ALPHA_GOTTPREL16:
5859 case BFD_RELOC_ALPHA_TPREL_HI16:
5860 case BFD_RELOC_ALPHA_TPREL_LO16:
5861 case BFD_RELOC_ALPHA_TPREL16:
5863 S_SET_THREAD_LOCAL (fixP->fx_addsy);
5868 case BFD_RELOC_ALPHA_LITERAL:
5869 md_number_to_chars (fixpos, value, 2);
5872 case BFD_RELOC_ALPHA_ELF_LITERAL:
5873 case BFD_RELOC_ALPHA_LITUSE:
5874 case BFD_RELOC_ALPHA_LINKAGE:
5875 case BFD_RELOC_ALPHA_CODEADDR:
5879 case BFD_RELOC_ALPHA_NOP:
5880 value -= (8 + 4); /* PC-relative, base is jsr+4. */
5882 /* From B.4.5.2 of the OpenVMS Linker Utility Manual:
5883 "Finally, the ETIR$C_STC_BSR command passes the same address
5884 as ETIR$C_STC_NOP (so that they will fail or succeed together),
5885 and the same test is done again." */
5886 if (S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
5888 fixP->fx_addnumber = -value;
5892 if ((abs (value) >> 2) & ~0xfffff)
5896 /* Change to a nop. */
5901 case BFD_RELOC_ALPHA_LDA:
5902 /* fixup_segment sets fixP->fx_addsy to NULL when it can pre-compute
5903 the value for an O_subtract. */
5905 && S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
5907 fixP->fx_addnumber = symbol_get_bfdsym (fixP->fx_subsy)->value;
5911 if ((abs (value)) & ~0x7fff)
5915 /* Change to an lda. */
5916 image = 0x237B0000 | (value & 0xFFFF);
5920 case BFD_RELOC_ALPHA_BSR:
5921 case BFD_RELOC_ALPHA_BOH:
5922 value -= 4; /* PC-relative, base is jsr+4. */
5924 /* See comment in the BFD_RELOC_ALPHA_NOP case above. */
5925 if (S_GET_SEGMENT (fixP->fx_addsy) == undefined_section)
5927 fixP->fx_addnumber = -value;
5931 if ((abs (value) >> 2) & ~0xfffff)
5934 if (fixP->fx_r_type == BFD_RELOC_ALPHA_BOH)
5937 image = bfd_getl32(fixpos);
5938 image = (image & ~0x3FFF) | ((value >> 2) & 0x3FFF);
5945 /* Change to a branch. */
5946 image = 0xD3400000 | ((value >> 2) & 0x1FFFFF);
5951 case BFD_RELOC_VTABLE_INHERIT:
5952 case BFD_RELOC_VTABLE_ENTRY:
5957 const struct alpha_operand *operand;
5959 if ((int) fixP->fx_r_type >= 0)
5960 as_fatal (_("unhandled relocation type %s"),
5961 bfd_get_reloc_code_name (fixP->fx_r_type));
5963 gas_assert (-(int) fixP->fx_r_type < (int) alpha_num_operands);
5964 operand = &alpha_operands[-(int) fixP->fx_r_type];
5966 /* The rest of these fixups only exist internally during symbol
5967 resolution and have no representation in the object file.
5968 Therefore they must be completely resolved as constants. */
5970 if (fixP->fx_addsy != 0
5971 && S_GET_SEGMENT (fixP->fx_addsy) != absolute_section)
5972 as_bad_where (fixP->fx_file, fixP->fx_line,
5973 _("non-absolute expression in constant field"));
5975 image = bfd_getl32 (fixpos);
5976 image = insert_operand (image, operand, (offsetT) value,
5977 fixP->fx_file, fixP->fx_line);
5982 if (fixP->fx_addsy != 0 || fixP->fx_pcrel != 0)
5986 as_warn_where (fixP->fx_file, fixP->fx_line,
5987 _("type %d reloc done?\n"), (int) fixP->fx_r_type);
5992 md_number_to_chars (fixpos, image, 4);
5998 /* Look for a register name in the given symbol. */
6001 md_undefined_symbol (char *name)
6005 int is_float = 0, num;
6010 if (name[1] == 'p' && name[2] == '\0')
6011 return alpha_register_table[AXP_REG_FP];
6016 if (!ISDIGIT (*++name))
6020 case '0': case '1': case '2': case '3': case '4':
6021 case '5': case '6': case '7': case '8': case '9':
6022 if (name[1] == '\0')
6023 num = name[0] - '0';
6024 else if (name[0] != '0' && ISDIGIT (name[1]) && name[2] == '\0')
6026 num = (name[0] - '0') * 10 + name[1] - '0';
6033 if (!alpha_noat_on && (num + is_float) == AXP_REG_AT)
6034 as_warn (_("Used $at without \".set noat\""));
6035 return alpha_register_table[num + is_float];
6038 if (name[1] == 't' && name[2] == '\0')
6041 as_warn (_("Used $at without \".set noat\""));
6042 return alpha_register_table[AXP_REG_AT];
6047 if (name[1] == 'p' && name[2] == '\0')
6048 return alpha_register_table[alpha_gp_register];
6052 if (name[1] == 'p' && name[2] == '\0')
6053 return alpha_register_table[AXP_REG_SP];
6061 /* @@@ Magic ECOFF bits. */
6064 alpha_frob_ecoff_data (void)
6067 /* $zero and $f31 are read-only. */
6068 alpha_gprmask &= ~1;
6069 alpha_fprmask &= ~1;
6073 /* Hook to remember a recently defined label so that the auto-align
6074 code can adjust the symbol after we know what alignment will be
6078 alpha_define_label (symbolS *sym)
6080 alpha_insn_label = sym;
6082 dwarf2_emit_label (sym);
6086 /* Return true if we must always emit a reloc for a type and false if
6087 there is some hope of resolving it at assembly time. */
6090 alpha_force_relocation (fixS *f)
6092 if (alpha_flag_relax)
6095 switch (f->fx_r_type)
6097 case BFD_RELOC_ALPHA_GPDISP_HI16:
6098 case BFD_RELOC_ALPHA_GPDISP_LO16:
6099 case BFD_RELOC_ALPHA_GPDISP:
6100 case BFD_RELOC_ALPHA_LITERAL:
6101 case BFD_RELOC_ALPHA_ELF_LITERAL:
6102 case BFD_RELOC_ALPHA_LITUSE:
6103 case BFD_RELOC_GPREL16:
6104 case BFD_RELOC_GPREL32:
6105 case BFD_RELOC_ALPHA_GPREL_HI16:
6106 case BFD_RELOC_ALPHA_GPREL_LO16:
6107 case BFD_RELOC_ALPHA_LINKAGE:
6108 case BFD_RELOC_ALPHA_CODEADDR:
6109 case BFD_RELOC_ALPHA_BRSGP:
6110 case BFD_RELOC_ALPHA_TLSGD:
6111 case BFD_RELOC_ALPHA_TLSLDM:
6112 case BFD_RELOC_ALPHA_GOTDTPREL16:
6113 case BFD_RELOC_ALPHA_DTPREL_HI16:
6114 case BFD_RELOC_ALPHA_DTPREL_LO16:
6115 case BFD_RELOC_ALPHA_DTPREL16:
6116 case BFD_RELOC_ALPHA_GOTTPREL16:
6117 case BFD_RELOC_ALPHA_TPREL_HI16:
6118 case BFD_RELOC_ALPHA_TPREL_LO16:
6119 case BFD_RELOC_ALPHA_TPREL16:
6121 case BFD_RELOC_ALPHA_NOP:
6122 case BFD_RELOC_ALPHA_BSR:
6123 case BFD_RELOC_ALPHA_LDA:
6124 case BFD_RELOC_ALPHA_BOH:
6132 return generic_force_reloc (f);
6135 /* Return true if we can partially resolve a relocation now. */
6138 alpha_fix_adjustable (fixS *f)
6140 /* Are there any relocation types for which we must generate a
6141 reloc but we can adjust the values contained within it? */
6142 switch (f->fx_r_type)
6144 case BFD_RELOC_ALPHA_GPDISP_HI16:
6145 case BFD_RELOC_ALPHA_GPDISP_LO16:
6146 case BFD_RELOC_ALPHA_GPDISP:
6149 case BFD_RELOC_ALPHA_LITERAL:
6150 case BFD_RELOC_ALPHA_ELF_LITERAL:
6151 case BFD_RELOC_ALPHA_LITUSE:
6152 case BFD_RELOC_ALPHA_LINKAGE:
6153 case BFD_RELOC_ALPHA_CODEADDR:
6156 case BFD_RELOC_VTABLE_ENTRY:
6157 case BFD_RELOC_VTABLE_INHERIT:
6160 case BFD_RELOC_GPREL16:
6161 case BFD_RELOC_GPREL32:
6162 case BFD_RELOC_ALPHA_GPREL_HI16:
6163 case BFD_RELOC_ALPHA_GPREL_LO16:
6164 case BFD_RELOC_23_PCREL_S2:
6168 case BFD_RELOC_ALPHA_HINT:
6171 case BFD_RELOC_ALPHA_TLSGD:
6172 case BFD_RELOC_ALPHA_TLSLDM:
6173 case BFD_RELOC_ALPHA_GOTDTPREL16:
6174 case BFD_RELOC_ALPHA_DTPREL_HI16:
6175 case BFD_RELOC_ALPHA_DTPREL_LO16:
6176 case BFD_RELOC_ALPHA_DTPREL16:
6177 case BFD_RELOC_ALPHA_GOTTPREL16:
6178 case BFD_RELOC_ALPHA_TPREL_HI16:
6179 case BFD_RELOC_ALPHA_TPREL_LO16:
6180 case BFD_RELOC_ALPHA_TPREL16:
6181 /* ??? No idea why we can't return a reference to .tbss+10, but
6182 we're preventing this in the other assemblers. Follow for now. */
6186 case BFD_RELOC_ALPHA_BRSGP:
6187 /* If we have a BRSGP reloc to a local symbol, adjust it to BRADDR and
6188 let it get resolved at assembly time. */
6190 symbolS *sym = f->fx_addsy;
6194 if (generic_force_reloc (f))
6197 switch (S_GET_OTHER (sym) & STO_ALPHA_STD_GPLOAD)
6199 case STO_ALPHA_NOPV:
6201 case STO_ALPHA_STD_GPLOAD:
6205 if (S_IS_LOCAL (sym))
6208 name = S_GET_NAME (sym);
6209 as_bad_where (f->fx_file, f->fx_line,
6210 _("!samegp reloc against symbol without .prologue: %s"),
6214 f->fx_r_type = BFD_RELOC_23_PCREL_S2;
6215 f->fx_offset += offset;
6220 case BFD_RELOC_ALPHA_NOP:
6221 case BFD_RELOC_ALPHA_BSR:
6222 case BFD_RELOC_ALPHA_LDA:
6223 case BFD_RELOC_ALPHA_BOH:
6232 /* Generate the BFD reloc to be stuck in the object file from the
6233 fixup used internally in the assembler. */
6236 tc_gen_reloc (asection *sec ATTRIBUTE_UNUSED,
6241 reloc = (arelent *) xmalloc (sizeof (* reloc));
6242 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
6243 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
6244 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
6246 /* Make sure none of our internal relocations make it this far.
6247 They'd better have been fully resolved by this point. */
6248 gas_assert ((int) fixp->fx_r_type > 0);
6250 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
6251 if (reloc->howto == NULL)
6253 as_bad_where (fixp->fx_file, fixp->fx_line,
6254 _("cannot represent `%s' relocation in object file"),
6255 bfd_get_reloc_code_name (fixp->fx_r_type));
6259 if (!fixp->fx_pcrel != !reloc->howto->pc_relative)
6260 as_fatal (_("internal error? cannot generate `%s' relocation"),
6261 bfd_get_reloc_code_name (fixp->fx_r_type));
6263 gas_assert (!fixp->fx_pcrel == !reloc->howto->pc_relative);
6265 reloc->addend = fixp->fx_offset;
6268 /* Fake out bfd_perform_relocation. sigh. */
6269 /* ??? Better would be to use the special_function hook. */
6270 if (fixp->fx_r_type == BFD_RELOC_ALPHA_LITERAL)
6271 reloc->addend = -alpha_gp_value;
6275 switch (fixp->fx_r_type)
6277 struct evax_private_udata_struct *udata;
6281 case BFD_RELOC_ALPHA_LINKAGE:
6282 /* Copy the linkage index. */
6283 reloc->addend = fixp->fx_addnumber;
6286 case BFD_RELOC_ALPHA_NOP:
6287 case BFD_RELOC_ALPHA_BSR:
6288 case BFD_RELOC_ALPHA_LDA:
6289 case BFD_RELOC_ALPHA_BOH:
6290 pname = symbol_get_bfdsym (fixp->fx_addsy)->name;
6292 /* We need the non-suffixed name of the procedure. Beware that
6293 the main symbol might be equated so look it up and take its name. */
6294 pname_len = strlen (pname);
6295 if (pname_len > 4 && strcmp (pname + pname_len - 4, "..en") == 0)
6298 char *my_pname = xstrdup (pname);
6299 my_pname [pname_len - 4] = 0;
6300 sym = symbol_find (my_pname);
6303 while (symbol_equated_reloc_p (sym))
6305 symbolS *n = symbol_get_value_expression (sym)->X_add_symbol;
6307 /* We must avoid looping, as that can occur with a badly
6313 pname = symbol_get_bfdsym (sym)->name;
6316 udata = (struct evax_private_udata_struct *)
6317 xmalloc (sizeof (struct evax_private_udata_struct));
6318 udata->enbsym = symbol_get_bfdsym (fixp->fx_addsy);
6319 udata->bsym = symbol_get_bfdsym (fixp->tc_fix_data.info->psym);
6320 udata->origname = (char *)pname;
6321 udata->lkindex = ((struct evax_private_udata_struct *)
6322 symbol_get_bfdsym (fixp->tc_fix_data.info->sym)->udata.p)->lkindex;
6323 reloc->sym_ptr_ptr = (void *)udata;
6324 reloc->addend = fixp->fx_addnumber;
6334 /* Parse a register name off of the input_line and return a register
6335 number. Gets md_undefined_symbol above to do the register name
6338 Only called as a part of processing the ECOFF .frame directive. */
6341 tc_get_register (int frame ATTRIBUTE_UNUSED)
6343 int framereg = AXP_REG_SP;
6346 if (*input_line_pointer == '$')
6348 char *s = input_line_pointer;
6349 char c = get_symbol_end ();
6350 symbolS *sym = md_undefined_symbol (s);
6352 *strchr (s, '\0') = c;
6353 if (sym && (framereg = S_GET_VALUE (sym)) <= 31)
6356 as_warn (_("frame reg expected, using $%d."), framereg);
6359 note_gpreg (framereg);
6363 /* This is called before the symbol table is processed. In order to
6364 work with gcc when using mips-tfile, we must keep all local labels.
6365 However, in other cases, we want to discard them. If we were
6366 called with -g, but we didn't see any debugging information, it may
6367 mean that gcc is smuggling debugging information through to
6368 mips-tfile, in which case we must generate all local labels. */
6373 alpha_frob_file_before_adjust (void)
6375 if (alpha_debug != 0
6376 && ! ecoff_debugging_seen)
6377 flag_keep_locals = 1;
6380 #endif /* OBJ_ECOFF */
6382 /* The Alpha has support for some VAX floating point types, as well as for
6383 IEEE floating point. We consider IEEE to be the primary floating point
6384 format, and sneak in the VAX floating point support here. */
6385 #include "config/atof-vax.c"