1 /* tc-alpha.c - Processor-specific code for the DEC Alpha AXP CPU.
2 Copyright 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
5 Contributed by Carnegie Mellon University, 1993.
6 Written by Alessandro Forin, based on earlier gas-1.38 target CPU files.
7 Modified by Ken Raeburn for gas-2.x and ECOFF support.
8 Modified by Richard Henderson for ELF support.
9 Modified by Klaus K"ampf for EVAX (OpenVMS/Alpha) support.
11 This file is part of GAS, the GNU Assembler.
13 GAS is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 3, or (at your option)
18 GAS is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with GAS; see the file COPYING. If not, write to the Free
25 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
28 /* Mach Operating System
29 Copyright (c) 1993 Carnegie Mellon University
32 Permission to use, copy, modify and distribute this software and its
33 documentation is hereby granted, provided that both the copyright
34 notice and this permission notice appear in all copies of the
35 software, derivative works or modified versions, and any portions
36 thereof, and that both notices appear in supporting documentation.
38 CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
39 CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
40 ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
42 Carnegie Mellon requests users of this software to return to
44 Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
45 School of Computer Science
46 Carnegie Mellon University
47 Pittsburgh PA 15213-3890
49 any improvements or extensions that they make and grant Carnegie the
50 rights to redistribute these changes. */
54 #include "struc-symbol.h"
57 #include "opcode/alpha.h"
60 #include "elf/alpha.h"
68 #include "dwarf2dbg.h"
69 #include "dw2gencfi.h"
70 #include "safe-ctype.h"
74 #define TOKENIZE_ERROR -1
75 #define TOKENIZE_ERROR_REPORT -2
76 #define MAX_INSN_FIXUPS 2
77 #define MAX_INSN_ARGS 5
79 /* Used since new relocation types are introduced in this
80 file (DUMMY_RELOC_LITUSE_*) */
81 typedef int extended_bfd_reloc_code_real_type
;
86 /* bfd_reloc_code_real_type reloc; */
87 extended_bfd_reloc_code_real_type reloc
;
89 /* The symbol of the item in the linkage section. */
92 /* The symbol of the procedure descriptor. */
101 struct alpha_fixup fixups
[MAX_INSN_FIXUPS
];
119 void (*emit
) (const expressionS
*, int, const void *);
121 enum alpha_macro_arg argsets
[16];
124 /* Extra expression types. */
126 #define O_pregister O_md1 /* O_register, in parentheses. */
127 #define O_cpregister O_md2 /* + a leading comma. */
129 /* The alpha_reloc_op table below depends on the ordering of these. */
130 #define O_literal O_md3 /* !literal relocation. */
131 #define O_lituse_addr O_md4 /* !lituse_addr relocation. */
132 #define O_lituse_base O_md5 /* !lituse_base relocation. */
133 #define O_lituse_bytoff O_md6 /* !lituse_bytoff relocation. */
134 #define O_lituse_jsr O_md7 /* !lituse_jsr relocation. */
135 #define O_lituse_tlsgd O_md8 /* !lituse_tlsgd relocation. */
136 #define O_lituse_tlsldm O_md9 /* !lituse_tlsldm relocation. */
137 #define O_lituse_jsrdirect O_md10 /* !lituse_jsrdirect relocation. */
138 #define O_gpdisp O_md11 /* !gpdisp relocation. */
139 #define O_gprelhigh O_md12 /* !gprelhigh relocation. */
140 #define O_gprellow O_md13 /* !gprellow relocation. */
141 #define O_gprel O_md14 /* !gprel relocation. */
142 #define O_samegp O_md15 /* !samegp relocation. */
143 #define O_tlsgd O_md16 /* !tlsgd relocation. */
144 #define O_tlsldm O_md17 /* !tlsldm relocation. */
145 #define O_gotdtprel O_md18 /* !gotdtprel relocation. */
146 #define O_dtprelhi O_md19 /* !dtprelhi relocation. */
147 #define O_dtprello O_md20 /* !dtprello relocation. */
148 #define O_dtprel O_md21 /* !dtprel relocation. */
149 #define O_gottprel O_md22 /* !gottprel relocation. */
150 #define O_tprelhi O_md23 /* !tprelhi relocation. */
151 #define O_tprello O_md24 /* !tprello relocation. */
152 #define O_tprel O_md25 /* !tprel relocation. */
154 #define DUMMY_RELOC_LITUSE_ADDR (BFD_RELOC_UNUSED + 1)
155 #define DUMMY_RELOC_LITUSE_BASE (BFD_RELOC_UNUSED + 2)
156 #define DUMMY_RELOC_LITUSE_BYTOFF (BFD_RELOC_UNUSED + 3)
157 #define DUMMY_RELOC_LITUSE_JSR (BFD_RELOC_UNUSED + 4)
158 #define DUMMY_RELOC_LITUSE_TLSGD (BFD_RELOC_UNUSED + 5)
159 #define DUMMY_RELOC_LITUSE_TLSLDM (BFD_RELOC_UNUSED + 6)
160 #define DUMMY_RELOC_LITUSE_JSRDIRECT (BFD_RELOC_UNUSED + 7)
162 #define USER_RELOC_P(R) ((R) >= O_literal && (R) <= O_tprel)
164 /* Macros for extracting the type and number of encoded register tokens. */
166 #define is_ir_num(x) (((x) & 32) == 0)
167 #define is_fpr_num(x) (((x) & 32) != 0)
168 #define regno(x) ((x) & 31)
170 /* Something odd inherited from the old assembler. */
172 #define note_gpreg(R) (alpha_gprmask |= (1 << (R)))
173 #define note_fpreg(R) (alpha_fprmask |= (1 << (R)))
175 /* Predicates for 16- and 32-bit ranges */
176 /* XXX: The non-shift version appears to trigger a compiler bug when
177 cross-assembling from x86 w/ gcc 2.7.2. */
180 #define range_signed_16(x) \
181 (((offsetT) (x) >> 15) == 0 || ((offsetT) (x) >> 15) == -1)
182 #define range_signed_32(x) \
183 (((offsetT) (x) >> 31) == 0 || ((offsetT) (x) >> 31) == -1)
185 #define range_signed_16(x) ((offsetT) (x) >= -(offsetT) 0x8000 && \
186 (offsetT) (x) <= (offsetT) 0x7FFF)
187 #define range_signed_32(x) ((offsetT) (x) >= -(offsetT) 0x80000000 && \
188 (offsetT) (x) <= (offsetT) 0x7FFFFFFF)
191 /* Macros for sign extending from 16- and 32-bits. */
192 /* XXX: The cast macros will work on all the systems that I care about,
193 but really a predicate should be found to use the non-cast forms. */
196 #define sign_extend_16(x) ((short) (x))
197 #define sign_extend_32(x) ((int) (x))
199 #define sign_extend_16(x) ((offsetT) (((x) & 0xFFFF) ^ 0x8000) - 0x8000)
200 #define sign_extend_32(x) ((offsetT) (((x) & 0xFFFFFFFF) \
201 ^ 0x80000000) - 0x80000000)
204 /* Macros to build tokens. */
206 #define set_tok_reg(t, r) (memset (&(t), 0, sizeof (t)), \
207 (t).X_op = O_register, \
208 (t).X_add_number = (r))
209 #define set_tok_preg(t, r) (memset (&(t), 0, sizeof (t)), \
210 (t).X_op = O_pregister, \
211 (t).X_add_number = (r))
212 #define set_tok_cpreg(t, r) (memset (&(t), 0, sizeof (t)), \
213 (t).X_op = O_cpregister, \
214 (t).X_add_number = (r))
215 #define set_tok_freg(t, r) (memset (&(t), 0, sizeof (t)), \
216 (t).X_op = O_register, \
217 (t).X_add_number = (r) + 32)
218 #define set_tok_sym(t, s, a) (memset (&(t), 0, sizeof (t)), \
219 (t).X_op = O_symbol, \
220 (t).X_add_symbol = (s), \
221 (t).X_add_number = (a))
222 #define set_tok_const(t, n) (memset (&(t), 0, sizeof (t)), \
223 (t).X_op = O_constant, \
224 (t).X_add_number = (n))
226 /* Generic assembler global variables which must be defined by all
229 /* Characters which always start a comment. */
230 const char comment_chars
[] = "#";
232 /* Characters which start a comment at the beginning of a line. */
233 const char line_comment_chars
[] = "#";
235 /* Characters which may be used to separate multiple commands on a
237 const char line_separator_chars
[] = ";";
239 /* Characters which are used to indicate an exponent in a floating
241 const char EXP_CHARS
[] = "eE";
243 /* Characters which mean that a number is a floating point constant,
245 /* XXX: Do all of these really get used on the alpha?? */
246 char FLT_CHARS
[] = "rRsSfFdDxXpP";
249 const char *md_shortopts
= "Fm:g+1h:HG:";
251 const char *md_shortopts
= "Fm:gG:";
254 struct option md_longopts
[] =
256 #define OPTION_32ADDR (OPTION_MD_BASE)
257 { "32addr", no_argument
, NULL
, OPTION_32ADDR
},
258 #define OPTION_RELAX (OPTION_32ADDR + 1)
259 { "relax", no_argument
, NULL
, OPTION_RELAX
},
261 #define OPTION_MDEBUG (OPTION_RELAX + 1)
262 #define OPTION_NO_MDEBUG (OPTION_MDEBUG + 1)
263 { "mdebug", no_argument
, NULL
, OPTION_MDEBUG
},
264 { "no-mdebug", no_argument
, NULL
, OPTION_NO_MDEBUG
},
267 #define OPTION_REPLACE (OPTION_RELAX + 1)
268 #define OPTION_NOREPLACE (OPTION_REPLACE+1)
269 { "replace", no_argument
, NULL
, OPTION_REPLACE
},
270 { "noreplace", no_argument
, NULL
, OPTION_NOREPLACE
},
272 { NULL
, no_argument
, NULL
, 0 }
275 size_t md_longopts_size
= sizeof (md_longopts
);
279 #define AXP_REG_R16 16
280 #define AXP_REG_R17 17
282 #define AXP_REG_T9 22
284 #define AXP_REG_T10 23
286 #define AXP_REG_T11 24
288 #define AXP_REG_T12 25
289 #define AXP_REG_AI 25
291 #define AXP_REG_FP 29
294 #define AXP_REG_GP AXP_REG_PV
296 #endif /* OBJ_EVAX */
298 /* The cpu for which we are generating code. */
299 static unsigned alpha_target
= AXP_OPCODE_BASE
;
300 static const char *alpha_target_name
= "<all>";
302 /* The hash table of instruction opcodes. */
303 static struct hash_control
*alpha_opcode_hash
;
305 /* The hash table of macro opcodes. */
306 static struct hash_control
*alpha_macro_hash
;
309 /* The $gp relocation symbol. */
310 static symbolS
*alpha_gp_symbol
;
312 /* XXX: what is this, and why is it exported? */
313 valueT alpha_gp_value
;
316 /* The current $gp register. */
317 static int alpha_gp_register
= AXP_REG_GP
;
319 /* A table of the register symbols. */
320 static symbolS
*alpha_register_table
[64];
322 /* Constant sections, or sections of constants. */
324 static segT alpha_lita_section
;
327 segT alpha_link_section
;
330 static segT alpha_lit8_section
;
333 /* Symbols referring to said sections. */
335 static symbolS
*alpha_lita_symbol
;
338 static symbolS
*alpha_link_symbol
;
341 static symbolS
*alpha_lit8_symbol
;
344 /* Literal for .litX+0x8000 within .lita. */
346 static offsetT alpha_lit8_literal
;
349 /* Is the assembler not allowed to use $at? */
350 static int alpha_noat_on
= 0;
352 /* Are macros enabled? */
353 static int alpha_macros_on
= 1;
355 /* Are floats disabled? */
356 static int alpha_nofloats_on
= 0;
358 /* Are addresses 32 bit? */
359 static int alpha_addr32_on
= 0;
361 /* Symbol labelling the current insn. When the Alpha gas sees
364 and the section happens to not be on an eight byte boundary, it
365 will align both the symbol and the .quad to an eight byte boundary. */
366 static symbolS
*alpha_insn_label
;
367 #if defined(OBJ_ELF) || defined (OBJ_EVAX)
368 static symbolS
*alpha_prologue_label
;
372 /* Symbol associate with the current jsr instruction. */
373 static symbolS
*alpha_linkage_symbol
;
376 /* Whether we should automatically align data generation pseudo-ops.
377 .align 0 will turn this off. */
378 static int alpha_auto_align_on
= 1;
380 /* The known current alignment of the current section. */
381 static int alpha_current_align
;
383 /* These are exported to ECOFF code. */
384 unsigned long alpha_gprmask
, alpha_fprmask
;
386 /* Whether the debugging option was seen. */
387 static int alpha_debug
;
390 /* Whether we are emitting an mdebug section. */
391 int alpha_flag_mdebug
= -1;
395 /* Whether to perform the VMS procedure call optimization. */
396 int alpha_flag_replace
= 1;
399 /* Don't fully resolve relocations, allowing code movement in the linker. */
400 static int alpha_flag_relax
;
402 /* What value to give to bfd_set_gp_size. */
403 static int g_switch_value
= 8;
406 /* Collect information about current procedure here. */
407 struct alpha_evax_procs
409 symbolS
*symbol
; /* Proc pdesc symbol. */
411 int framereg
; /* Register for frame pointer. */
412 int framesize
; /* Size of frame. */
424 /* Linked list of .linkage fixups. */
425 struct alpha_linkage_fixups
*alpha_linkage_fixup_root
;
426 static struct alpha_linkage_fixups
*alpha_linkage_fixup_tail
;
428 /* Current procedure descriptor. */
429 static struct alpha_evax_procs
*alpha_evax_proc
;
430 static struct alpha_evax_procs alpha_evax_proc_data
;
432 static int alpha_flag_hash_long_names
= 0; /* -+ */
433 static int alpha_flag_show_after_trunc
= 0; /* -H */
435 /* If the -+ switch is given, then a hash is appended to any name that is
436 longer than 64 characters, else longer symbol names are truncated. */
441 /* A table to map the spelling of a relocation operand into an appropriate
442 bfd_reloc_code_real_type type. The table is assumed to be ordered such
443 that op-O_literal indexes into it. */
445 #define ALPHA_RELOC_TABLE(op) \
446 (&alpha_reloc_op[ ((!USER_RELOC_P (op)) \
448 : (int) (op) - (int) O_literal) ])
450 #define DEF(NAME, RELOC, REQ, ALLOW) \
451 { #NAME, sizeof(#NAME)-1, O_##NAME, RELOC, REQ, ALLOW}
453 static const struct alpha_reloc_op_tag
455 const char *name
; /* String to lookup. */
456 size_t length
; /* Size of the string. */
457 operatorT op
; /* Which operator to use. */
458 extended_bfd_reloc_code_real_type reloc
;
459 unsigned int require_seq
: 1; /* Require a sequence number. */
460 unsigned int allow_seq
: 1; /* Allow a sequence number. */
464 DEF (literal
, BFD_RELOC_ALPHA_ELF_LITERAL
, 0, 1),
465 DEF (lituse_addr
, DUMMY_RELOC_LITUSE_ADDR
, 1, 1),
466 DEF (lituse_base
, DUMMY_RELOC_LITUSE_BASE
, 1, 1),
467 DEF (lituse_bytoff
, DUMMY_RELOC_LITUSE_BYTOFF
, 1, 1),
468 DEF (lituse_jsr
, DUMMY_RELOC_LITUSE_JSR
, 1, 1),
469 DEF (lituse_tlsgd
, DUMMY_RELOC_LITUSE_TLSGD
, 1, 1),
470 DEF (lituse_tlsldm
, DUMMY_RELOC_LITUSE_TLSLDM
, 1, 1),
471 DEF (lituse_jsrdirect
, DUMMY_RELOC_LITUSE_JSRDIRECT
, 1, 1),
472 DEF (gpdisp
, BFD_RELOC_ALPHA_GPDISP
, 1, 1),
473 DEF (gprelhigh
, BFD_RELOC_ALPHA_GPREL_HI16
, 0, 0),
474 DEF (gprellow
, BFD_RELOC_ALPHA_GPREL_LO16
, 0, 0),
475 DEF (gprel
, BFD_RELOC_GPREL16
, 0, 0),
476 DEF (samegp
, BFD_RELOC_ALPHA_BRSGP
, 0, 0),
477 DEF (tlsgd
, BFD_RELOC_ALPHA_TLSGD
, 0, 1),
478 DEF (tlsldm
, BFD_RELOC_ALPHA_TLSLDM
, 0, 1),
479 DEF (gotdtprel
, BFD_RELOC_ALPHA_GOTDTPREL16
, 0, 0),
480 DEF (dtprelhi
, BFD_RELOC_ALPHA_DTPREL_HI16
, 0, 0),
481 DEF (dtprello
, BFD_RELOC_ALPHA_DTPREL_LO16
, 0, 0),
482 DEF (dtprel
, BFD_RELOC_ALPHA_DTPREL16
, 0, 0),
483 DEF (gottprel
, BFD_RELOC_ALPHA_GOTTPREL16
, 0, 0),
484 DEF (tprelhi
, BFD_RELOC_ALPHA_TPREL_HI16
, 0, 0),
485 DEF (tprello
, BFD_RELOC_ALPHA_TPREL_LO16
, 0, 0),
486 DEF (tprel
, BFD_RELOC_ALPHA_TPREL16
, 0, 0),
491 static const int alpha_num_reloc_op
492 = sizeof (alpha_reloc_op
) / sizeof (*alpha_reloc_op
);
493 #endif /* RELOC_OP_P */
495 /* Maximum # digits needed to hold the largest sequence #. */
496 #define ALPHA_RELOC_DIGITS 25
498 /* Structure to hold explicit sequence information. */
499 struct alpha_reloc_tag
501 fixS
*master
; /* The literal reloc. */
503 struct symbol
*sym
; /* Linkage section item symbol. */
504 struct symbol
*psym
; /* Pdesc symbol. */
506 fixS
*slaves
; /* Head of linked list of lituses. */
507 segT segment
; /* Segment relocs are in or undefined_section. */
508 long sequence
; /* Sequence #. */
509 unsigned n_master
; /* # of literals. */
510 unsigned n_slaves
; /* # of lituses. */
511 unsigned saw_tlsgd
: 1; /* True if ... */
512 unsigned saw_tlsldm
: 1;
513 unsigned saw_lu_tlsgd
: 1;
514 unsigned saw_lu_tlsldm
: 1;
515 unsigned multi_section_p
: 1; /* True if more than one section was used. */
516 char string
[1]; /* Printable form of sequence to hash with. */
519 /* Hash table to link up literals with the appropriate lituse. */
520 static struct hash_control
*alpha_literal_hash
;
522 /* Sequence numbers for internal use by macros. */
523 static long next_sequence_num
= -1;
525 /* A table of CPU names and opcode sets. */
527 static const struct cpu_type
534 /* Ad hoc convention: cpu number gets palcode, process code doesn't.
535 This supports usage under DU 4.0b that does ".arch ev4", and
536 usage in MILO that does -m21064. Probably something more
537 specific like -m21064-pal should be used, but oh well. */
539 { "21064", AXP_OPCODE_BASE
|AXP_OPCODE_EV4
},
540 { "21064a", AXP_OPCODE_BASE
|AXP_OPCODE_EV4
},
541 { "21066", AXP_OPCODE_BASE
|AXP_OPCODE_EV4
},
542 { "21068", AXP_OPCODE_BASE
|AXP_OPCODE_EV4
},
543 { "21164", AXP_OPCODE_BASE
|AXP_OPCODE_EV5
},
544 { "21164a", AXP_OPCODE_BASE
|AXP_OPCODE_EV5
|AXP_OPCODE_BWX
},
545 { "21164pc", (AXP_OPCODE_BASE
|AXP_OPCODE_EV5
|AXP_OPCODE_BWX
547 { "21264", (AXP_OPCODE_BASE
|AXP_OPCODE_EV6
|AXP_OPCODE_BWX
548 |AXP_OPCODE_MAX
|AXP_OPCODE_CIX
) },
549 { "21264a", (AXP_OPCODE_BASE
|AXP_OPCODE_EV6
|AXP_OPCODE_BWX
550 |AXP_OPCODE_MAX
|AXP_OPCODE_CIX
) },
551 { "21264b", (AXP_OPCODE_BASE
|AXP_OPCODE_EV6
|AXP_OPCODE_BWX
552 |AXP_OPCODE_MAX
|AXP_OPCODE_CIX
) },
554 { "ev4", AXP_OPCODE_BASE
},
555 { "ev45", AXP_OPCODE_BASE
},
556 { "lca45", AXP_OPCODE_BASE
},
557 { "ev5", AXP_OPCODE_BASE
},
558 { "ev56", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
},
559 { "pca56", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
|AXP_OPCODE_MAX
},
560 { "ev6", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
|AXP_OPCODE_MAX
|AXP_OPCODE_CIX
},
561 { "ev67", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
|AXP_OPCODE_MAX
|AXP_OPCODE_CIX
},
562 { "ev68", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
|AXP_OPCODE_MAX
|AXP_OPCODE_CIX
},
564 { "all", AXP_OPCODE_BASE
},
568 /* Some instruction sets indexed by lg(size). */
569 static const char * const sextX_op
[] = { "sextb", "sextw", "sextl", NULL
};
570 static const char * const insXl_op
[] = { "insbl", "inswl", "insll", "insql" };
571 static const char * const insXh_op
[] = { NULL
, "inswh", "inslh", "insqh" };
572 static const char * const extXl_op
[] = { "extbl", "extwl", "extll", "extql" };
573 static const char * const extXh_op
[] = { NULL
, "extwh", "extlh", "extqh" };
574 static const char * const mskXl_op
[] = { "mskbl", "mskwl", "mskll", "mskql" };
575 static const char * const mskXh_op
[] = { NULL
, "mskwh", "msklh", "mskqh" };
576 static const char * const stX_op
[] = { "stb", "stw", "stl", "stq" };
577 static const char * const ldXu_op
[] = { "ldbu", "ldwu", NULL
, NULL
};
579 static void assemble_insn (const struct alpha_opcode
*, const expressionS
*, int, struct alpha_insn
*, extended_bfd_reloc_code_real_type
);
580 static void emit_insn (struct alpha_insn
*);
581 static void assemble_tokens (const char *, const expressionS
*, int, int);
583 static char *s_alpha_section_name (void);
584 static symbolS
*add_to_link_pool (symbolS
*, offsetT
);
587 static struct alpha_reloc_tag
*
588 get_alpha_reloc_tag (long sequence
)
590 char buffer
[ALPHA_RELOC_DIGITS
];
591 struct alpha_reloc_tag
*info
;
593 sprintf (buffer
, "!%ld", sequence
);
595 info
= (struct alpha_reloc_tag
*) hash_find (alpha_literal_hash
, buffer
);
598 size_t len
= strlen (buffer
);
601 info
= (struct alpha_reloc_tag
*)
602 xcalloc (sizeof (struct alpha_reloc_tag
) + len
, 1);
604 info
->segment
= now_seg
;
605 info
->sequence
= sequence
;
606 strcpy (info
->string
, buffer
);
607 errmsg
= hash_insert (alpha_literal_hash
, info
->string
, (void *) info
);
609 as_fatal ("%s", errmsg
);
622 alpha_adjust_relocs (bfd
*abfd ATTRIBUTE_UNUSED
,
624 void * ptr ATTRIBUTE_UNUSED
)
626 segment_info_type
*seginfo
= seg_info (sec
);
632 /* If seginfo is NULL, we did not create this section; don't do
633 anything with it. By using a pointer to a pointer, we can update
634 the links in place. */
638 /* If there are no relocations, skip the section. */
639 if (! seginfo
->fix_root
)
642 /* First rebuild the fixup chain without the explicit lituse and
643 gpdisp_lo16 relocs. */
644 prevP
= &seginfo
->fix_root
;
645 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= next
)
647 next
= fixp
->fx_next
;
648 fixp
->fx_next
= (fixS
*) 0;
650 switch (fixp
->fx_r_type
)
652 case BFD_RELOC_ALPHA_LITUSE
:
653 if (fixp
->tc_fix_data
.info
->n_master
== 0)
654 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
655 _("No !literal!%ld was found"),
656 fixp
->tc_fix_data
.info
->sequence
);
658 if (fixp
->fx_offset
== LITUSE_ALPHA_TLSGD
)
660 if (! fixp
->tc_fix_data
.info
->saw_tlsgd
)
661 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
662 _("No !tlsgd!%ld was found"),
663 fixp
->tc_fix_data
.info
->sequence
);
665 else if (fixp
->fx_offset
== LITUSE_ALPHA_TLSLDM
)
667 if (! fixp
->tc_fix_data
.info
->saw_tlsldm
)
668 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
669 _("No !tlsldm!%ld was found"),
670 fixp
->tc_fix_data
.info
->sequence
);
675 case BFD_RELOC_ALPHA_GPDISP_LO16
:
676 if (fixp
->tc_fix_data
.info
->n_master
== 0)
677 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
678 _("No ldah !gpdisp!%ld was found"),
679 fixp
->tc_fix_data
.info
->sequence
);
682 case BFD_RELOC_ALPHA_ELF_LITERAL
:
683 if (fixp
->tc_fix_data
.info
684 && (fixp
->tc_fix_data
.info
->saw_tlsgd
685 || fixp
->tc_fix_data
.info
->saw_tlsldm
))
691 prevP
= &fixp
->fx_next
;
696 /* Go back and re-chain dependent relocations. They are currently
697 linked through the next_reloc field in reverse order, so as we
698 go through the next_reloc chain, we effectively reverse the chain
701 Except if there is more than one !literal for a given sequence
702 number. In that case, the programmer and/or compiler is not sure
703 how control flows from literal to lituse, and we can't be sure to
704 get the relaxation correct.
706 ??? Well, actually we could, if there are enough lituses such that
707 we can make each literal have at least one of each lituse type
708 present. Not implemented.
710 Also suppress the optimization if the !literals/!lituses are spread
711 in different segments. This can happen with "intersting" uses of
712 inline assembly; examples are present in the Linux kernel semaphores. */
714 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= next
)
716 next
= fixp
->fx_next
;
717 switch (fixp
->fx_r_type
)
719 case BFD_RELOC_ALPHA_TLSGD
:
720 case BFD_RELOC_ALPHA_TLSLDM
:
721 if (!fixp
->tc_fix_data
.info
)
723 if (fixp
->tc_fix_data
.info
->n_master
== 0)
725 else if (fixp
->tc_fix_data
.info
->n_master
> 1)
727 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
728 _("too many !literal!%ld for %s"),
729 fixp
->tc_fix_data
.info
->sequence
,
730 (fixp
->fx_r_type
== BFD_RELOC_ALPHA_TLSGD
731 ? "!tlsgd" : "!tlsldm"));
735 fixp
->tc_fix_data
.info
->master
->fx_next
= fixp
->fx_next
;
736 fixp
->fx_next
= fixp
->tc_fix_data
.info
->master
;
737 fixp
= fixp
->fx_next
;
740 case BFD_RELOC_ALPHA_ELF_LITERAL
:
741 if (fixp
->tc_fix_data
.info
742 && fixp
->tc_fix_data
.info
->n_master
== 1
743 && ! fixp
->tc_fix_data
.info
->multi_section_p
)
745 for (slave
= fixp
->tc_fix_data
.info
->slaves
;
747 slave
= slave
->tc_fix_data
.next_reloc
)
749 slave
->fx_next
= fixp
->fx_next
;
750 fixp
->fx_next
= slave
;
755 case BFD_RELOC_ALPHA_GPDISP_HI16
:
756 if (fixp
->tc_fix_data
.info
->n_slaves
== 0)
757 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
758 _("No lda !gpdisp!%ld was found"),
759 fixp
->tc_fix_data
.info
->sequence
);
762 slave
= fixp
->tc_fix_data
.info
->slaves
;
763 slave
->fx_next
= next
;
764 fixp
->fx_next
= slave
;
774 /* Before the relocations are written, reorder them, so that user
775 supplied !lituse relocations follow the appropriate !literal
776 relocations, and similarly for !gpdisp relocations. */
779 alpha_before_fix (void)
781 if (alpha_literal_hash
)
782 bfd_map_over_sections (stdoutput
, alpha_adjust_relocs
, NULL
);
789 debug_exp (expressionS tok
[], int ntok
)
793 fprintf (stderr
, "debug_exp: %d tokens", ntok
);
794 for (i
= 0; i
< ntok
; i
++)
796 expressionS
*t
= &tok
[i
];
801 default: name
= "unknown"; break;
802 case O_illegal
: name
= "O_illegal"; break;
803 case O_absent
: name
= "O_absent"; break;
804 case O_constant
: name
= "O_constant"; break;
805 case O_symbol
: name
= "O_symbol"; break;
806 case O_symbol_rva
: name
= "O_symbol_rva"; break;
807 case O_register
: name
= "O_register"; break;
808 case O_big
: name
= "O_big"; break;
809 case O_uminus
: name
= "O_uminus"; break;
810 case O_bit_not
: name
= "O_bit_not"; break;
811 case O_logical_not
: name
= "O_logical_not"; break;
812 case O_multiply
: name
= "O_multiply"; break;
813 case O_divide
: name
= "O_divide"; break;
814 case O_modulus
: name
= "O_modulus"; break;
815 case O_left_shift
: name
= "O_left_shift"; break;
816 case O_right_shift
: name
= "O_right_shift"; break;
817 case O_bit_inclusive_or
: name
= "O_bit_inclusive_or"; break;
818 case O_bit_or_not
: name
= "O_bit_or_not"; break;
819 case O_bit_exclusive_or
: name
= "O_bit_exclusive_or"; break;
820 case O_bit_and
: name
= "O_bit_and"; break;
821 case O_add
: name
= "O_add"; break;
822 case O_subtract
: name
= "O_subtract"; break;
823 case O_eq
: name
= "O_eq"; break;
824 case O_ne
: name
= "O_ne"; break;
825 case O_lt
: name
= "O_lt"; break;
826 case O_le
: name
= "O_le"; break;
827 case O_ge
: name
= "O_ge"; break;
828 case O_gt
: name
= "O_gt"; break;
829 case O_logical_and
: name
= "O_logical_and"; break;
830 case O_logical_or
: name
= "O_logical_or"; break;
831 case O_index
: name
= "O_index"; break;
832 case O_pregister
: name
= "O_pregister"; break;
833 case O_cpregister
: name
= "O_cpregister"; break;
834 case O_literal
: name
= "O_literal"; break;
835 case O_lituse_addr
: name
= "O_lituse_addr"; break;
836 case O_lituse_base
: name
= "O_lituse_base"; break;
837 case O_lituse_bytoff
: name
= "O_lituse_bytoff"; break;
838 case O_lituse_jsr
: name
= "O_lituse_jsr"; break;
839 case O_lituse_tlsgd
: name
= "O_lituse_tlsgd"; break;
840 case O_lituse_tlsldm
: name
= "O_lituse_tlsldm"; break;
841 case O_lituse_jsrdirect
: name
= "O_lituse_jsrdirect"; break;
842 case O_gpdisp
: name
= "O_gpdisp"; break;
843 case O_gprelhigh
: name
= "O_gprelhigh"; break;
844 case O_gprellow
: name
= "O_gprellow"; break;
845 case O_gprel
: name
= "O_gprel"; break;
846 case O_samegp
: name
= "O_samegp"; break;
847 case O_tlsgd
: name
= "O_tlsgd"; break;
848 case O_tlsldm
: name
= "O_tlsldm"; break;
849 case O_gotdtprel
: name
= "O_gotdtprel"; break;
850 case O_dtprelhi
: name
= "O_dtprelhi"; break;
851 case O_dtprello
: name
= "O_dtprello"; break;
852 case O_dtprel
: name
= "O_dtprel"; break;
853 case O_gottprel
: name
= "O_gottprel"; break;
854 case O_tprelhi
: name
= "O_tprelhi"; break;
855 case O_tprello
: name
= "O_tprello"; break;
856 case O_tprel
: name
= "O_tprel"; break;
859 fprintf (stderr
, ", %s(%s, %s, %d)", name
,
860 (t
->X_add_symbol
) ? S_GET_NAME (t
->X_add_symbol
) : "--",
861 (t
->X_op_symbol
) ? S_GET_NAME (t
->X_op_symbol
) : "--",
862 (int) t
->X_add_number
);
864 fprintf (stderr
, "\n");
869 /* Parse the arguments to an opcode. */
872 tokenize_arguments (char *str
,
876 expressionS
*end_tok
= tok
+ ntok
;
877 char *old_input_line_pointer
;
878 int saw_comma
= 0, saw_arg
= 0;
880 expressionS
*orig_tok
= tok
;
884 const struct alpha_reloc_op_tag
*r
;
887 int reloc_found_p
= 0;
890 memset (tok
, 0, sizeof (*tok
) * ntok
);
892 /* Save and restore input_line_pointer around this function. */
893 old_input_line_pointer
= input_line_pointer
;
894 input_line_pointer
= str
;
897 /* ??? Wrest control of ! away from the regular expression parser. */
898 is_end_of_line
[(unsigned char) '!'] = 1;
901 while (tok
< end_tok
&& *input_line_pointer
)
904 switch (*input_line_pointer
)
911 /* A relocation operand can be placed after the normal operand on an
912 assembly language statement, and has the following form:
913 !relocation_type!sequence_number. */
916 /* Only support one relocation op per insn. */
917 as_bad (_("More than one relocation op per insn"));
924 ++input_line_pointer
;
926 p
= input_line_pointer
;
927 c
= get_symbol_end ();
929 /* Parse !relocation_type. */
930 len
= input_line_pointer
- p
;
933 as_bad (_("No relocation operand"));
937 r
= &alpha_reloc_op
[0];
938 for (i
= alpha_num_reloc_op
- 1; i
>= 0; i
--, r
++)
939 if (len
== r
->length
&& memcmp (p
, r
->name
, len
) == 0)
943 as_bad (_("Unknown relocation operand: !%s"), p
);
947 *input_line_pointer
= c
;
949 if (*input_line_pointer
!= '!')
953 as_bad (_("no sequence number after !%s"), p
);
957 tok
->X_add_number
= 0;
963 as_bad (_("!%s does not use a sequence number"), p
);
967 input_line_pointer
++;
969 /* Parse !sequence_number. */
971 if (tok
->X_op
!= O_constant
|| tok
->X_add_number
<= 0)
973 as_bad (_("Bad sequence number: !%s!%s"),
974 r
->name
, input_line_pointer
);
983 #endif /* RELOC_OP_P */
986 ++input_line_pointer
;
987 if (saw_comma
|| !saw_arg
)
994 char *hold
= input_line_pointer
++;
996 /* First try for parenthesized register ... */
998 if (*input_line_pointer
== ')' && tok
->X_op
== O_register
)
1000 tok
->X_op
= (saw_comma
? O_cpregister
: O_pregister
);
1003 ++input_line_pointer
;
1008 /* ... then fall through to plain expression. */
1009 input_line_pointer
= hold
;
1013 if (saw_arg
&& !saw_comma
)
1017 if (tok
->X_op
== O_illegal
|| tok
->X_op
== O_absent
)
1030 input_line_pointer
= old_input_line_pointer
;
1033 debug_exp (orig_tok
, ntok
- (end_tok
- tok
));
1036 is_end_of_line
[(unsigned char) '!'] = 0;
1039 return ntok
- (end_tok
- tok
);
1043 is_end_of_line
[(unsigned char) '!'] = 0;
1045 input_line_pointer
= old_input_line_pointer
;
1046 return TOKENIZE_ERROR
;
1050 is_end_of_line
[(unsigned char) '!'] = 0;
1052 input_line_pointer
= old_input_line_pointer
;
1053 return TOKENIZE_ERROR_REPORT
;
1056 /* Search forward through all variants of an opcode looking for a
1059 static const struct alpha_opcode
*
1060 find_opcode_match (const struct alpha_opcode
*first_opcode
,
1061 const expressionS
*tok
,
1065 const struct alpha_opcode
*opcode
= first_opcode
;
1067 int got_cpu_match
= 0;
1071 const unsigned char *opidx
;
1074 /* Don't match opcodes that don't exist on this architecture. */
1075 if (!(opcode
->flags
& alpha_target
))
1080 for (opidx
= opcode
->operands
; *opidx
; ++opidx
)
1082 const struct alpha_operand
*operand
= &alpha_operands
[*opidx
];
1084 /* Only take input from real operands. */
1085 if (operand
->flags
& AXP_OPERAND_FAKE
)
1088 /* When we expect input, make sure we have it. */
1091 if ((operand
->flags
& AXP_OPERAND_OPTIONAL_MASK
) == 0)
1096 /* Match operand type with expression type. */
1097 switch (operand
->flags
& AXP_OPERAND_TYPECHECK_MASK
)
1099 case AXP_OPERAND_IR
:
1100 if (tok
[tokidx
].X_op
!= O_register
1101 || !is_ir_num (tok
[tokidx
].X_add_number
))
1104 case AXP_OPERAND_FPR
:
1105 if (tok
[tokidx
].X_op
!= O_register
1106 || !is_fpr_num (tok
[tokidx
].X_add_number
))
1109 case AXP_OPERAND_IR
| AXP_OPERAND_PARENS
:
1110 if (tok
[tokidx
].X_op
!= O_pregister
1111 || !is_ir_num (tok
[tokidx
].X_add_number
))
1114 case AXP_OPERAND_IR
| AXP_OPERAND_PARENS
| AXP_OPERAND_COMMA
:
1115 if (tok
[tokidx
].X_op
!= O_cpregister
1116 || !is_ir_num (tok
[tokidx
].X_add_number
))
1120 case AXP_OPERAND_RELATIVE
:
1121 case AXP_OPERAND_SIGNED
:
1122 case AXP_OPERAND_UNSIGNED
:
1123 switch (tok
[tokidx
].X_op
)
1138 /* Everything else should have been fake. */
1144 /* Possible match -- did we use all of our input? */
1153 while (++opcode
- alpha_opcodes
< (int) alpha_num_opcodes
1154 && !strcmp (opcode
->name
, first_opcode
->name
));
1157 *pcpumatch
= got_cpu_match
;
1162 /* Given an opcode name and a pre-tokenized set of arguments, assemble
1163 the insn, but do not emit it.
1165 Note that this implies no macros allowed, since we can't store more
1166 than one insn in an insn structure. */
1169 assemble_tokens_to_insn (const char *opname
,
1170 const expressionS
*tok
,
1172 struct alpha_insn
*insn
)
1174 const struct alpha_opcode
*opcode
;
1176 /* Search opcodes. */
1177 opcode
= (const struct alpha_opcode
*) hash_find (alpha_opcode_hash
, opname
);
1181 opcode
= find_opcode_match (opcode
, tok
, &ntok
, &cpumatch
);
1184 assemble_insn (opcode
, tok
, ntok
, insn
, BFD_RELOC_UNUSED
);
1188 as_bad (_("inappropriate arguments for opcode `%s'"), opname
);
1190 as_bad (_("opcode `%s' not supported for target %s"), opname
,
1194 as_bad (_("unknown opcode `%s'"), opname
);
1197 /* Build a BFD section with its flags set appropriately for the .lita,
1198 .lit8, or .lit4 sections. */
1201 create_literal_section (const char *name
,
1205 segT current_section
= now_seg
;
1206 int current_subsec
= now_subseg
;
1209 *secp
= new_sec
= subseg_new (name
, 0);
1210 subseg_set (current_section
, current_subsec
);
1211 bfd_set_section_alignment (stdoutput
, new_sec
, 4);
1212 bfd_set_section_flags (stdoutput
, new_sec
,
1213 SEC_RELOC
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1216 S_CLEAR_EXTERNAL (*symp
= section_symbol (new_sec
));
1219 /* Load a (partial) expression into a target register.
1221 If poffset is not null, after the call it will either contain
1222 O_constant 0, or a 16-bit offset appropriate for any MEM format
1223 instruction. In addition, pbasereg will be modified to point to
1224 the base register to use in that MEM format instruction.
1226 In any case, *pbasereg should contain a base register to add to the
1227 expression. This will normally be either AXP_REG_ZERO or
1228 alpha_gp_register. Symbol addresses will always be loaded via $gp,
1229 so "foo($0)" is interpreted as adding the address of foo to $0;
1230 i.e. "ldq $targ, LIT($gp); addq $targ, $0, $targ". Odd, perhaps,
1231 but this is what OSF/1 does.
1233 If explicit relocations of the form !literal!<number> are allowed,
1234 and used, then explicit_reloc with be an expression pointer.
1236 Finally, the return value is nonzero if the calling macro may emit
1237 a LITUSE reloc if otherwise appropriate; the return value is the
1238 sequence number to use. */
1241 load_expression (int targreg
,
1242 const expressionS
*exp
,
1244 expressionS
*poffset
,
1247 long emit_lituse
= 0;
1248 offsetT addend
= exp
->X_add_number
;
1249 int basereg
= *pbasereg
;
1250 struct alpha_insn insn
;
1251 expressionS newtok
[3];
1260 /* Attempt to reduce .lit load by splitting the offset from
1261 its symbol when possible, but don't create a situation in
1263 if (!range_signed_32 (addend
) &&
1264 (alpha_noat_on
|| targreg
== AXP_REG_AT
))
1266 lit
= add_to_literal_pool (exp
->X_add_symbol
, addend
,
1267 alpha_lita_section
, 8);
1271 lit
= add_to_literal_pool (exp
->X_add_symbol
, 0,
1272 alpha_lita_section
, 8);
1275 as_fatal (_("overflow in literal (.lita) table"));
1277 /* Emit "ldq r, lit(gp)". */
1279 if (basereg
!= alpha_gp_register
&& targreg
== basereg
)
1282 as_bad (_("macro requires $at register while noat in effect"));
1283 if (targreg
== AXP_REG_AT
)
1284 as_bad (_("macro requires $at while $at in use"));
1286 set_tok_reg (newtok
[0], AXP_REG_AT
);
1289 set_tok_reg (newtok
[0], targreg
);
1291 set_tok_sym (newtok
[1], alpha_lita_symbol
, lit
);
1292 set_tok_preg (newtok
[2], alpha_gp_register
);
1294 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1296 gas_assert (insn
.nfixups
== 1);
1297 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_LITERAL
;
1298 insn
.sequence
= emit_lituse
= next_sequence_num
--;
1299 #endif /* OBJ_ECOFF */
1301 /* Emit "ldq r, gotoff(gp)". */
1303 if (basereg
!= alpha_gp_register
&& targreg
== basereg
)
1306 as_bad (_("macro requires $at register while noat in effect"));
1307 if (targreg
== AXP_REG_AT
)
1308 as_bad (_("macro requires $at while $at in use"));
1310 set_tok_reg (newtok
[0], AXP_REG_AT
);
1313 set_tok_reg (newtok
[0], targreg
);
1315 /* XXX: Disable this .got minimizing optimization so that we can get
1316 better instruction offset knowledge in the compiler. This happens
1317 very infrequently anyway. */
1319 || (!range_signed_32 (addend
)
1320 && (alpha_noat_on
|| targreg
== AXP_REG_AT
)))
1326 set_tok_sym (newtok
[1], exp
->X_add_symbol
, 0);
1328 set_tok_preg (newtok
[2], alpha_gp_register
);
1330 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1332 gas_assert (insn
.nfixups
== 1);
1333 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_ELF_LITERAL
;
1334 insn
.sequence
= emit_lituse
= next_sequence_num
--;
1335 #endif /* OBJ_ELF */
1337 /* Find symbol or symbol pointer in link section. */
1339 if (exp
->X_add_symbol
== alpha_evax_proc
->symbol
)
1341 /* Linkage-relative expression. */
1342 set_tok_reg (newtok
[0], targreg
);
1344 if (range_signed_16 (addend
))
1346 set_tok_const (newtok
[1], addend
);
1351 set_tok_const (newtok
[1], 0);
1353 set_tok_preg (newtok
[2], basereg
);
1354 assemble_tokens_to_insn ("lda", newtok
, 3, &insn
);
1358 const char *symname
= S_GET_NAME (exp
->X_add_symbol
);
1359 const char *ptr1
, *ptr2
;
1360 int symlen
= strlen (symname
);
1363 strcmp (ptr2
= &symname
[symlen
- 4], "..lk") == 0))
1365 /* Access to an item whose address is stored in the linkage
1366 section. Just read the address. */
1367 set_tok_reg (newtok
[0], targreg
);
1370 newtok
[1].X_op
= O_subtract
;
1371 newtok
[1].X_op_symbol
= alpha_evax_proc
->symbol
;
1373 set_tok_preg (newtok
[2], basereg
);
1374 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1375 alpha_linkage_symbol
= exp
->X_add_symbol
;
1378 set_tok_const (*poffset
, 0);
1380 if (alpha_flag_replace
&& targreg
== 26)
1382 /* Add a NOP fixup for 'ldX $26,YYY..NAME..lk'. */
1386 /* Build the entry name as 'NAME..en'. */
1387 ptr1
= strstr (symname
, "..") + 2;
1390 ensymname
= (char *) alloca (ptr2
- ptr1
+ 5);
1391 memcpy (ensymname
, ptr1
, ptr2
- ptr1
);
1392 memcpy (ensymname
+ (ptr2
- ptr1
), "..en", 5);
1394 gas_assert (insn
.nfixups
+ 1 <= MAX_INSN_FIXUPS
);
1395 insn
.fixups
[insn
.nfixups
].reloc
= BFD_RELOC_ALPHA_NOP
;
1396 ensym
= symbol_find_or_make (ensymname
);
1398 /* The fixup must be the same as the BFD_RELOC_ALPHA_BOH
1399 case in emit_jsrjmp. See B.4.5.2 of the OpenVMS Linker
1401 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_symbol
;
1402 insn
.fixups
[insn
.nfixups
].exp
.X_add_symbol
= ensym
;
1403 insn
.fixups
[insn
.nfixups
].exp
.X_add_number
= 0;
1404 insn
.fixups
[insn
.nfixups
].xtrasym
= alpha_linkage_symbol
;
1405 insn
.fixups
[insn
.nfixups
].procsym
= alpha_evax_proc
->symbol
;
1408 /* ??? Force bsym to be instantiated now, as it will be
1409 too late to do so in tc_gen_reloc. */
1410 symbol_get_bfdsym (exp
->X_add_symbol
);
1412 else if (alpha_flag_replace
&& targreg
== 27)
1414 /* Add a lda fixup for 'ldX $27,YYY.NAME..lk+8'. */
1419 ptr1
= strstr (symname
, "..") + 2;
1422 psymname
= (char *) alloca (ptr2
- ptr1
+ 1);
1423 memcpy (psymname
, ptr1
, ptr2
- ptr1
);
1424 psymname
[ptr2
- ptr1
] = 0;
1426 gas_assert (insn
.nfixups
+ 1 <= MAX_INSN_FIXUPS
);
1427 insn
.fixups
[insn
.nfixups
].reloc
= BFD_RELOC_ALPHA_LDA
;
1428 psym
= symbol_find_or_make (psymname
);
1430 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_subtract
;
1431 insn
.fixups
[insn
.nfixups
].exp
.X_add_symbol
= psym
;
1432 insn
.fixups
[insn
.nfixups
].exp
.X_op_symbol
= alpha_evax_proc
->symbol
;
1433 insn
.fixups
[insn
.nfixups
].exp
.X_add_number
= 0;
1434 insn
.fixups
[insn
.nfixups
].xtrasym
= alpha_linkage_symbol
;
1435 insn
.fixups
[insn
.nfixups
].procsym
= alpha_evax_proc
->symbol
;
1444 /* Not in the linkage section. Put the value into the linkage
1448 if (!range_signed_32 (addend
))
1449 addend
= sign_extend_32 (addend
);
1450 linkexp
= add_to_link_pool (exp
->X_add_symbol
, 0);
1451 set_tok_reg (newtok
[0], targreg
);
1452 set_tok_sym (newtok
[1], linkexp
, 0);
1453 set_tok_preg (newtok
[2], basereg
);
1454 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1457 #endif /* OBJ_EVAX */
1462 if (basereg
!= alpha_gp_register
&& basereg
!= AXP_REG_ZERO
)
1464 /* Emit "addq r, base, r". */
1466 set_tok_reg (newtok
[1], basereg
);
1467 set_tok_reg (newtok
[2], targreg
);
1468 assemble_tokens ("addq", newtok
, 3, 0);
1479 /* Assume that this difference expression will be resolved to an
1480 absolute value and that that value will fit in 16 bits. */
1482 set_tok_reg (newtok
[0], targreg
);
1484 set_tok_preg (newtok
[2], basereg
);
1485 assemble_tokens (opname
, newtok
, 3, 0);
1488 set_tok_const (*poffset
, 0);
1492 if (exp
->X_add_number
> 0)
1493 as_bad (_("bignum invalid; zero assumed"));
1495 as_bad (_("floating point number invalid; zero assumed"));
1500 as_bad (_("can't handle expression"));
1505 if (!range_signed_32 (addend
))
1511 long seq_num
= next_sequence_num
--;
1514 /* For 64-bit addends, just put it in the literal pool. */
1516 /* Emit "ldq targreg, lit(basereg)". */
1517 litexp
= add_to_link_pool (section_symbol (absolute_section
), addend
);
1518 set_tok_reg (newtok
[0], targreg
);
1519 set_tok_sym (newtok
[1], litexp
, 0);
1520 set_tok_preg (newtok
[2], alpha_gp_register
);
1521 assemble_tokens ("ldq", newtok
, 3, 0);
1524 if (alpha_lit8_section
== NULL
)
1526 create_literal_section (".lit8",
1527 &alpha_lit8_section
,
1528 &alpha_lit8_symbol
);
1531 alpha_lit8_literal
= add_to_literal_pool (alpha_lit8_symbol
, 0x8000,
1532 alpha_lita_section
, 8);
1533 if (alpha_lit8_literal
>= 0x8000)
1534 as_fatal (_("overflow in literal (.lita) table"));
1538 lit
= add_to_literal_pool (NULL
, addend
, alpha_lit8_section
, 8) - 0x8000;
1540 as_fatal (_("overflow in literal (.lit8) table"));
1542 /* Emit "lda litreg, .lit8+0x8000". */
1544 if (targreg
== basereg
)
1547 as_bad (_("macro requires $at register while noat in effect"));
1548 if (targreg
== AXP_REG_AT
)
1549 as_bad (_("macro requires $at while $at in use"));
1551 set_tok_reg (newtok
[0], AXP_REG_AT
);
1554 set_tok_reg (newtok
[0], targreg
);
1556 set_tok_sym (newtok
[1], alpha_lita_symbol
, alpha_lit8_literal
);
1559 set_tok_sym (newtok
[1], alpha_lit8_symbol
, 0x8000);
1561 set_tok_preg (newtok
[2], alpha_gp_register
);
1563 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1565 gas_assert (insn
.nfixups
== 1);
1567 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_LITERAL
;
1570 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_ELF_LITERAL
;
1572 insn
.sequence
= seq_num
;
1576 /* Emit "ldq litreg, lit(litreg)". */
1578 set_tok_const (newtok
[1], lit
);
1579 set_tok_preg (newtok
[2], newtok
[0].X_add_number
);
1581 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1583 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
1584 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
1585 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
1587 insn
.sequence
= seq_num
;
1592 /* Emit "addq litreg, base, target". */
1594 if (basereg
!= AXP_REG_ZERO
)
1596 set_tok_reg (newtok
[1], basereg
);
1597 set_tok_reg (newtok
[2], targreg
);
1598 assemble_tokens ("addq", newtok
, 3, 0);
1600 #endif /* !OBJ_EVAX */
1603 set_tok_const (*poffset
, 0);
1604 *pbasereg
= targreg
;
1608 offsetT low
, high
, extra
, tmp
;
1610 /* For 32-bit operands, break up the addend. */
1612 low
= sign_extend_16 (addend
);
1614 high
= sign_extend_16 (tmp
>> 16);
1616 if (tmp
- (high
<< 16))
1620 high
= sign_extend_16 (tmp
>> 16);
1625 set_tok_reg (newtok
[0], targreg
);
1626 set_tok_preg (newtok
[2], basereg
);
1630 /* Emit "ldah r, extra(r). */
1631 set_tok_const (newtok
[1], extra
);
1632 assemble_tokens ("ldah", newtok
, 3, 0);
1633 set_tok_preg (newtok
[2], basereg
= targreg
);
1638 /* Emit "ldah r, high(r). */
1639 set_tok_const (newtok
[1], high
);
1640 assemble_tokens ("ldah", newtok
, 3, 0);
1642 set_tok_preg (newtok
[2], basereg
);
1645 if ((low
&& !poffset
) || (!poffset
&& basereg
!= targreg
))
1647 /* Emit "lda r, low(base)". */
1648 set_tok_const (newtok
[1], low
);
1649 assemble_tokens ("lda", newtok
, 3, 0);
1655 set_tok_const (*poffset
, low
);
1656 *pbasereg
= basereg
;
1662 /* The lda macro differs from the lda instruction in that it handles
1663 most simple expressions, particularly symbol address loads and
1667 emit_lda (const expressionS
*tok
,
1669 const void * unused ATTRIBUTE_UNUSED
)
1674 basereg
= (tok
[1].X_op
== O_constant
? AXP_REG_ZERO
: alpha_gp_register
);
1676 basereg
= tok
[2].X_add_number
;
1678 (void) load_expression (tok
[0].X_add_number
, &tok
[1], &basereg
, NULL
, "lda");
1681 /* The ldah macro differs from the ldah instruction in that it has $31
1682 as an implied base register. */
1685 emit_ldah (const expressionS
*tok
,
1686 int ntok ATTRIBUTE_UNUSED
,
1687 const void * unused ATTRIBUTE_UNUSED
)
1689 expressionS newtok
[3];
1693 set_tok_preg (newtok
[2], AXP_REG_ZERO
);
1695 assemble_tokens ("ldah", newtok
, 3, 0);
1698 /* Called internally to handle all alignment needs. This takes care
1699 of eliding calls to frag_align if'n the cached current alignment
1700 says we've already got it, as well as taking care of the auto-align
1701 feature wrt labels. */
1707 int force ATTRIBUTE_UNUSED
)
1709 if (alpha_current_align
>= n
)
1714 if (subseg_text_p (now_seg
))
1715 frag_align_code (n
, 0);
1717 frag_align (n
, 0, 0);
1720 frag_align (n
, *pfill
, 0);
1722 alpha_current_align
= n
;
1724 if (label
!= NULL
&& S_GET_SEGMENT (label
) == now_seg
)
1726 symbol_set_frag (label
, frag_now
);
1727 S_SET_VALUE (label
, (valueT
) frag_now_fix ());
1730 record_alignment (now_seg
, n
);
1732 /* ??? If alpha_flag_relax && force && elf, record the requested alignment
1733 in a reloc for the linker to see. */
1736 /* Actually output an instruction with its fixup. */
1739 emit_insn (struct alpha_insn
*insn
)
1744 /* Take care of alignment duties. */
1745 if (alpha_auto_align_on
&& alpha_current_align
< 2)
1746 alpha_align (2, (char *) NULL
, alpha_insn_label
, 0);
1747 if (alpha_current_align
> 2)
1748 alpha_current_align
= 2;
1749 alpha_insn_label
= NULL
;
1751 /* Write out the instruction. */
1753 md_number_to_chars (f
, insn
->insn
, 4);
1756 dwarf2_emit_insn (4);
1759 /* Apply the fixups in order. */
1760 for (i
= 0; i
< insn
->nfixups
; ++i
)
1762 const struct alpha_operand
*operand
= (const struct alpha_operand
*) 0;
1763 struct alpha_fixup
*fixup
= &insn
->fixups
[i
];
1764 struct alpha_reloc_tag
*info
= NULL
;
1768 /* Some fixups are only used internally and so have no howto. */
1769 if ((int) fixup
->reloc
< 0)
1771 operand
= &alpha_operands
[-(int) fixup
->reloc
];
1773 pcrel
= ((operand
->flags
& AXP_OPERAND_RELATIVE
) != 0);
1775 else if (fixup
->reloc
> BFD_RELOC_UNUSED
1776 || fixup
->reloc
== BFD_RELOC_ALPHA_GPDISP_HI16
1777 || fixup
->reloc
== BFD_RELOC_ALPHA_GPDISP_LO16
)
1784 reloc_howto_type
*reloc_howto
=
1785 bfd_reloc_type_lookup (stdoutput
,
1786 (bfd_reloc_code_real_type
) fixup
->reloc
);
1787 gas_assert (reloc_howto
);
1789 size
= bfd_get_reloc_size (reloc_howto
);
1791 switch (fixup
->reloc
)
1794 case BFD_RELOC_ALPHA_NOP
:
1795 case BFD_RELOC_ALPHA_BSR
:
1796 case BFD_RELOC_ALPHA_LDA
:
1797 case BFD_RELOC_ALPHA_BOH
:
1801 gas_assert (size
>= 1 && size
<= 4);
1804 pcrel
= reloc_howto
->pc_relative
;
1807 fixP
= fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, size
,
1808 &fixup
->exp
, pcrel
, (bfd_reloc_code_real_type
) fixup
->reloc
);
1810 /* Turn off complaints that the addend is too large for some fixups,
1811 and copy in the sequence number for the explicit relocations. */
1812 switch (fixup
->reloc
)
1814 case BFD_RELOC_ALPHA_HINT
:
1815 case BFD_RELOC_GPREL32
:
1816 case BFD_RELOC_GPREL16
:
1817 case BFD_RELOC_ALPHA_GPREL_HI16
:
1818 case BFD_RELOC_ALPHA_GPREL_LO16
:
1819 case BFD_RELOC_ALPHA_GOTDTPREL16
:
1820 case BFD_RELOC_ALPHA_DTPREL_HI16
:
1821 case BFD_RELOC_ALPHA_DTPREL_LO16
:
1822 case BFD_RELOC_ALPHA_DTPREL16
:
1823 case BFD_RELOC_ALPHA_GOTTPREL16
:
1824 case BFD_RELOC_ALPHA_TPREL_HI16
:
1825 case BFD_RELOC_ALPHA_TPREL_LO16
:
1826 case BFD_RELOC_ALPHA_TPREL16
:
1827 fixP
->fx_no_overflow
= 1;
1830 case BFD_RELOC_ALPHA_GPDISP_HI16
:
1831 fixP
->fx_no_overflow
= 1;
1832 fixP
->fx_addsy
= section_symbol (now_seg
);
1833 fixP
->fx_offset
= 0;
1835 info
= get_alpha_reloc_tag (insn
->sequence
);
1836 if (++info
->n_master
> 1)
1837 as_bad (_("too many ldah insns for !gpdisp!%ld"), insn
->sequence
);
1838 if (info
->segment
!= now_seg
)
1839 as_bad (_("both insns for !gpdisp!%ld must be in the same section"),
1841 fixP
->tc_fix_data
.info
= info
;
1844 case BFD_RELOC_ALPHA_GPDISP_LO16
:
1845 fixP
->fx_no_overflow
= 1;
1847 info
= get_alpha_reloc_tag (insn
->sequence
);
1848 if (++info
->n_slaves
> 1)
1849 as_bad (_("too many lda insns for !gpdisp!%ld"), insn
->sequence
);
1850 if (info
->segment
!= now_seg
)
1851 as_bad (_("both insns for !gpdisp!%ld must be in the same section"),
1853 fixP
->tc_fix_data
.info
= info
;
1854 info
->slaves
= fixP
;
1857 case BFD_RELOC_ALPHA_LITERAL
:
1858 case BFD_RELOC_ALPHA_ELF_LITERAL
:
1859 fixP
->fx_no_overflow
= 1;
1861 if (insn
->sequence
== 0)
1863 info
= get_alpha_reloc_tag (insn
->sequence
);
1864 info
->master
= fixP
;
1866 if (info
->segment
!= now_seg
)
1867 info
->multi_section_p
= 1;
1868 fixP
->tc_fix_data
.info
= info
;
1872 case DUMMY_RELOC_LITUSE_ADDR
:
1873 fixP
->fx_offset
= LITUSE_ALPHA_ADDR
;
1875 case DUMMY_RELOC_LITUSE_BASE
:
1876 fixP
->fx_offset
= LITUSE_ALPHA_BASE
;
1878 case DUMMY_RELOC_LITUSE_BYTOFF
:
1879 fixP
->fx_offset
= LITUSE_ALPHA_BYTOFF
;
1881 case DUMMY_RELOC_LITUSE_JSR
:
1882 fixP
->fx_offset
= LITUSE_ALPHA_JSR
;
1884 case DUMMY_RELOC_LITUSE_TLSGD
:
1885 fixP
->fx_offset
= LITUSE_ALPHA_TLSGD
;
1887 case DUMMY_RELOC_LITUSE_TLSLDM
:
1888 fixP
->fx_offset
= LITUSE_ALPHA_TLSLDM
;
1890 case DUMMY_RELOC_LITUSE_JSRDIRECT
:
1891 fixP
->fx_offset
= LITUSE_ALPHA_JSRDIRECT
;
1894 fixP
->fx_addsy
= section_symbol (now_seg
);
1895 fixP
->fx_r_type
= BFD_RELOC_ALPHA_LITUSE
;
1897 info
= get_alpha_reloc_tag (insn
->sequence
);
1898 if (fixup
->reloc
== DUMMY_RELOC_LITUSE_TLSGD
)
1899 info
->saw_lu_tlsgd
= 1;
1900 else if (fixup
->reloc
== DUMMY_RELOC_LITUSE_TLSLDM
)
1901 info
->saw_lu_tlsldm
= 1;
1902 if (++info
->n_slaves
> 1)
1904 if (info
->saw_lu_tlsgd
)
1905 as_bad (_("too many lituse insns for !lituse_tlsgd!%ld"),
1907 else if (info
->saw_lu_tlsldm
)
1908 as_bad (_("too many lituse insns for !lituse_tlsldm!%ld"),
1911 fixP
->tc_fix_data
.info
= info
;
1912 fixP
->tc_fix_data
.next_reloc
= info
->slaves
;
1913 info
->slaves
= fixP
;
1914 if (info
->segment
!= now_seg
)
1915 info
->multi_section_p
= 1;
1918 case BFD_RELOC_ALPHA_TLSGD
:
1919 fixP
->fx_no_overflow
= 1;
1921 if (insn
->sequence
== 0)
1923 info
= get_alpha_reloc_tag (insn
->sequence
);
1924 if (info
->saw_tlsgd
)
1925 as_bad (_("duplicate !tlsgd!%ld"), insn
->sequence
);
1926 else if (info
->saw_tlsldm
)
1927 as_bad (_("sequence number in use for !tlsldm!%ld"),
1930 info
->saw_tlsgd
= 1;
1931 fixP
->tc_fix_data
.info
= info
;
1934 case BFD_RELOC_ALPHA_TLSLDM
:
1935 fixP
->fx_no_overflow
= 1;
1937 if (insn
->sequence
== 0)
1939 info
= get_alpha_reloc_tag (insn
->sequence
);
1940 if (info
->saw_tlsldm
)
1941 as_bad (_("duplicate !tlsldm!%ld"), insn
->sequence
);
1942 else if (info
->saw_tlsgd
)
1943 as_bad (_("sequence number in use for !tlsgd!%ld"),
1946 info
->saw_tlsldm
= 1;
1947 fixP
->tc_fix_data
.info
= info
;
1951 case BFD_RELOC_ALPHA_NOP
:
1952 case BFD_RELOC_ALPHA_LDA
:
1953 case BFD_RELOC_ALPHA_BSR
:
1954 case BFD_RELOC_ALPHA_BOH
:
1955 info
= get_alpha_reloc_tag (next_sequence_num
--);
1956 fixP
->tc_fix_data
.info
= info
;
1957 fixP
->tc_fix_data
.info
->sym
= fixup
->xtrasym
;
1958 fixP
->tc_fix_data
.info
->psym
= fixup
->procsym
;
1963 if ((int) fixup
->reloc
< 0)
1965 if (operand
->flags
& AXP_OPERAND_NOOVERFLOW
)
1966 fixP
->fx_no_overflow
= 1;
1973 /* Insert an operand value into an instruction. */
1976 insert_operand (unsigned insn
,
1977 const struct alpha_operand
*operand
,
1982 if (operand
->bits
!= 32 && !(operand
->flags
& AXP_OPERAND_NOOVERFLOW
))
1986 if (operand
->flags
& AXP_OPERAND_SIGNED
)
1988 max
= (1 << (operand
->bits
- 1)) - 1;
1989 min
= -(1 << (operand
->bits
- 1));
1993 max
= (1 << operand
->bits
) - 1;
1997 if (val
< min
|| val
> max
)
1998 as_warn_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
2001 if (operand
->insert
)
2003 const char *errmsg
= NULL
;
2005 insn
= (*operand
->insert
) (insn
, val
, &errmsg
);
2007 as_warn ("%s", errmsg
);
2010 insn
|= ((val
& ((1 << operand
->bits
) - 1)) << operand
->shift
);
2015 /* Turn an opcode description and a set of arguments into
2016 an instruction and a fixup. */
2019 assemble_insn (const struct alpha_opcode
*opcode
,
2020 const expressionS
*tok
,
2022 struct alpha_insn
*insn
,
2023 extended_bfd_reloc_code_real_type reloc
)
2025 const struct alpha_operand
*reloc_operand
= NULL
;
2026 const expressionS
*reloc_exp
= NULL
;
2027 const unsigned char *argidx
;
2031 memset (insn
, 0, sizeof (*insn
));
2032 image
= opcode
->opcode
;
2034 for (argidx
= opcode
->operands
; *argidx
; ++argidx
)
2036 const struct alpha_operand
*operand
= &alpha_operands
[*argidx
];
2037 const expressionS
*t
= (const expressionS
*) 0;
2039 if (operand
->flags
& AXP_OPERAND_FAKE
)
2041 /* Fake operands take no value and generate no fixup. */
2042 image
= insert_operand (image
, operand
, 0, NULL
, 0);
2048 switch (operand
->flags
& AXP_OPERAND_OPTIONAL_MASK
)
2050 case AXP_OPERAND_DEFAULT_FIRST
:
2053 case AXP_OPERAND_DEFAULT_SECOND
:
2056 case AXP_OPERAND_DEFAULT_ZERO
:
2058 static expressionS zero_exp
;
2060 zero_exp
.X_op
= O_constant
;
2061 zero_exp
.X_unsigned
= 1;
2076 image
= insert_operand (image
, operand
, regno (t
->X_add_number
),
2081 image
= insert_operand (image
, operand
, t
->X_add_number
, NULL
, 0);
2082 gas_assert (reloc_operand
== NULL
);
2083 reloc_operand
= operand
;
2088 /* This is only 0 for fields that should contain registers,
2089 which means this pattern shouldn't have matched. */
2090 if (operand
->default_reloc
== 0)
2093 /* There is one special case for which an insn receives two
2094 relocations, and thus the user-supplied reloc does not
2095 override the operand reloc. */
2096 if (operand
->default_reloc
== BFD_RELOC_ALPHA_HINT
)
2098 struct alpha_fixup
*fixup
;
2100 if (insn
->nfixups
>= MAX_INSN_FIXUPS
)
2101 as_fatal (_("too many fixups"));
2103 fixup
= &insn
->fixups
[insn
->nfixups
++];
2105 fixup
->reloc
= BFD_RELOC_ALPHA_HINT
;
2109 if (reloc
== BFD_RELOC_UNUSED
)
2110 reloc
= operand
->default_reloc
;
2112 gas_assert (reloc_operand
== NULL
);
2113 reloc_operand
= operand
;
2120 if (reloc
!= BFD_RELOC_UNUSED
)
2122 struct alpha_fixup
*fixup
;
2124 if (insn
->nfixups
>= MAX_INSN_FIXUPS
)
2125 as_fatal (_("too many fixups"));
2127 /* ??? My but this is hacky. But the OSF/1 assembler uses the same
2128 relocation tag for both ldah and lda with gpdisp. Choose the
2129 correct internal relocation based on the opcode. */
2130 if (reloc
== BFD_RELOC_ALPHA_GPDISP
)
2132 if (strcmp (opcode
->name
, "ldah") == 0)
2133 reloc
= BFD_RELOC_ALPHA_GPDISP_HI16
;
2134 else if (strcmp (opcode
->name
, "lda") == 0)
2135 reloc
= BFD_RELOC_ALPHA_GPDISP_LO16
;
2137 as_bad (_("invalid relocation for instruction"));
2140 /* If this is a real relocation (as opposed to a lituse hint), then
2141 the relocation width should match the operand width.
2142 Take care of -MDISP in operand table. */
2143 else if (reloc
< BFD_RELOC_UNUSED
&& reloc
> 0)
2145 reloc_howto_type
*reloc_howto
2146 = bfd_reloc_type_lookup (stdoutput
,
2147 (bfd_reloc_code_real_type
) reloc
);
2148 if (reloc_operand
== NULL
2149 || reloc_howto
->bitsize
!= reloc_operand
->bits
)
2151 as_bad (_("invalid relocation for field"));
2156 fixup
= &insn
->fixups
[insn
->nfixups
++];
2158 fixup
->exp
= *reloc_exp
;
2160 fixup
->exp
.X_op
= O_absent
;
2161 fixup
->reloc
= reloc
;
2167 /* Handle all "simple" integer register loads -- ldq, ldq_l, ldq_u,
2168 etc. They differ from the real instructions in that they do simple
2169 expressions like the lda macro. */
2172 emit_ir_load (const expressionS
*tok
,
2174 const void * opname
)
2178 expressionS newtok
[3];
2179 struct alpha_insn insn
;
2181 = tok
[1].X_add_symbol
? S_GET_NAME (tok
[1].X_add_symbol
): "";
2182 int symlen
= strlen (symname
);
2185 basereg
= (tok
[1].X_op
== O_constant
? AXP_REG_ZERO
: alpha_gp_register
);
2187 basereg
= tok
[2].X_add_number
;
2189 lituse
= load_expression (tok
[0].X_add_number
, &tok
[1],
2190 &basereg
, &newtok
[1], (const char *) opname
);
2192 if (basereg
== alpha_gp_register
&&
2193 (symlen
> 4 && strcmp (&symname
[symlen
- 4], "..lk") == 0))
2197 set_tok_preg (newtok
[2], basereg
);
2199 assemble_tokens_to_insn ((const char *) opname
, newtok
, 3, &insn
);
2203 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2204 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2205 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2207 insn
.sequence
= lituse
;
2213 /* Handle fp register loads, and both integer and fp register stores.
2214 Again, we handle simple expressions. */
2217 emit_loadstore (const expressionS
*tok
,
2219 const void * opname
)
2223 expressionS newtok
[3];
2224 struct alpha_insn insn
;
2227 basereg
= (tok
[1].X_op
== O_constant
? AXP_REG_ZERO
: alpha_gp_register
);
2229 basereg
= tok
[2].X_add_number
;
2231 if (tok
[1].X_op
!= O_constant
|| !range_signed_16 (tok
[1].X_add_number
))
2234 as_bad (_("macro requires $at register while noat in effect"));
2236 lituse
= load_expression (AXP_REG_AT
, &tok
[1],
2237 &basereg
, &newtok
[1], (const char *) opname
);
2246 set_tok_preg (newtok
[2], basereg
);
2248 assemble_tokens_to_insn ((const char *) opname
, newtok
, 3, &insn
);
2252 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2253 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2254 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2256 insn
.sequence
= lituse
;
2262 /* Load a half-word or byte as an unsigned value. */
2265 emit_ldXu (const expressionS
*tok
,
2267 const void * vlgsize
)
2269 if (alpha_target
& AXP_OPCODE_BWX
)
2270 emit_ir_load (tok
, ntok
, ldXu_op
[(long) vlgsize
]);
2273 expressionS newtok
[3];
2274 struct alpha_insn insn
;
2279 as_bad (_("macro requires $at register while noat in effect"));
2282 basereg
= (tok
[1].X_op
== O_constant
2283 ? AXP_REG_ZERO
: alpha_gp_register
);
2285 basereg
= tok
[2].X_add_number
;
2287 /* Emit "lda $at, exp". */
2288 lituse
= load_expression (AXP_REG_AT
, &tok
[1], &basereg
, NULL
, "lda");
2290 /* Emit "ldq_u targ, 0($at)". */
2292 set_tok_const (newtok
[1], 0);
2293 set_tok_preg (newtok
[2], basereg
);
2294 assemble_tokens_to_insn ("ldq_u", newtok
, 3, &insn
);
2298 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2299 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2300 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2302 insn
.sequence
= lituse
;
2307 /* Emit "extXl targ, $at, targ". */
2308 set_tok_reg (newtok
[1], basereg
);
2309 newtok
[2] = newtok
[0];
2310 assemble_tokens_to_insn (extXl_op
[(long) vlgsize
], newtok
, 3, &insn
);
2314 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2315 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BYTOFF
;
2316 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2318 insn
.sequence
= lituse
;
2325 /* Load a half-word or byte as a signed value. */
2328 emit_ldX (const expressionS
*tok
,
2330 const void * vlgsize
)
2332 emit_ldXu (tok
, ntok
, vlgsize
);
2333 assemble_tokens (sextX_op
[(long) vlgsize
], tok
, 1, 1);
2336 /* Load an integral value from an unaligned address as an unsigned
2340 emit_uldXu (const expressionS
*tok
,
2342 const void * vlgsize
)
2344 long lgsize
= (long) vlgsize
;
2345 expressionS newtok
[3];
2348 as_bad (_("macro requires $at register while noat in effect"));
2350 /* Emit "lda $at, exp". */
2351 memcpy (newtok
, tok
, sizeof (expressionS
) * ntok
);
2352 newtok
[0].X_add_number
= AXP_REG_AT
;
2353 assemble_tokens ("lda", newtok
, ntok
, 1);
2355 /* Emit "ldq_u $t9, 0($at)". */
2356 set_tok_reg (newtok
[0], AXP_REG_T9
);
2357 set_tok_const (newtok
[1], 0);
2358 set_tok_preg (newtok
[2], AXP_REG_AT
);
2359 assemble_tokens ("ldq_u", newtok
, 3, 1);
2361 /* Emit "ldq_u $t10, size-1($at)". */
2362 set_tok_reg (newtok
[0], AXP_REG_T10
);
2363 set_tok_const (newtok
[1], (1 << lgsize
) - 1);
2364 assemble_tokens ("ldq_u", newtok
, 3, 1);
2366 /* Emit "extXl $t9, $at, $t9". */
2367 set_tok_reg (newtok
[0], AXP_REG_T9
);
2368 set_tok_reg (newtok
[1], AXP_REG_AT
);
2369 set_tok_reg (newtok
[2], AXP_REG_T9
);
2370 assemble_tokens (extXl_op
[lgsize
], newtok
, 3, 1);
2372 /* Emit "extXh $t10, $at, $t10". */
2373 set_tok_reg (newtok
[0], AXP_REG_T10
);
2374 set_tok_reg (newtok
[2], AXP_REG_T10
);
2375 assemble_tokens (extXh_op
[lgsize
], newtok
, 3, 1);
2377 /* Emit "or $t9, $t10, targ". */
2378 set_tok_reg (newtok
[0], AXP_REG_T9
);
2379 set_tok_reg (newtok
[1], AXP_REG_T10
);
2381 assemble_tokens ("or", newtok
, 3, 1);
2384 /* Load an integral value from an unaligned address as a signed value.
2385 Note that quads should get funneled to the unsigned load since we
2386 don't have to do the sign extension. */
2389 emit_uldX (const expressionS
*tok
,
2391 const void * vlgsize
)
2393 emit_uldXu (tok
, ntok
, vlgsize
);
2394 assemble_tokens (sextX_op
[(long) vlgsize
], tok
, 1, 1);
2397 /* Implement the ldil macro. */
2400 emit_ldil (const expressionS
*tok
,
2402 const void * unused ATTRIBUTE_UNUSED
)
2404 expressionS newtok
[2];
2406 memcpy (newtok
, tok
, sizeof (newtok
));
2407 newtok
[1].X_add_number
= sign_extend_32 (tok
[1].X_add_number
);
2409 assemble_tokens ("lda", newtok
, ntok
, 1);
2412 /* Store a half-word or byte. */
2415 emit_stX (const expressionS
*tok
,
2417 const void * vlgsize
)
2419 int lgsize
= (int) (long) vlgsize
;
2421 if (alpha_target
& AXP_OPCODE_BWX
)
2422 emit_loadstore (tok
, ntok
, stX_op
[lgsize
]);
2425 expressionS newtok
[3];
2426 struct alpha_insn insn
;
2431 as_bad (_("macro requires $at register while noat in effect"));
2434 basereg
= (tok
[1].X_op
== O_constant
2435 ? AXP_REG_ZERO
: alpha_gp_register
);
2437 basereg
= tok
[2].X_add_number
;
2439 /* Emit "lda $at, exp". */
2440 lituse
= load_expression (AXP_REG_AT
, &tok
[1], &basereg
, NULL
, "lda");
2442 /* Emit "ldq_u $t9, 0($at)". */
2443 set_tok_reg (newtok
[0], AXP_REG_T9
);
2444 set_tok_const (newtok
[1], 0);
2445 set_tok_preg (newtok
[2], basereg
);
2446 assemble_tokens_to_insn ("ldq_u", newtok
, 3, &insn
);
2450 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2451 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2452 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2454 insn
.sequence
= lituse
;
2459 /* Emit "insXl src, $at, $t10". */
2461 set_tok_reg (newtok
[1], basereg
);
2462 set_tok_reg (newtok
[2], AXP_REG_T10
);
2463 assemble_tokens_to_insn (insXl_op
[lgsize
], newtok
, 3, &insn
);
2467 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2468 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BYTOFF
;
2469 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2471 insn
.sequence
= lituse
;
2476 /* Emit "mskXl $t9, $at, $t9". */
2477 set_tok_reg (newtok
[0], AXP_REG_T9
);
2478 newtok
[2] = newtok
[0];
2479 assemble_tokens_to_insn (mskXl_op
[lgsize
], newtok
, 3, &insn
);
2483 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2484 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BYTOFF
;
2485 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2487 insn
.sequence
= lituse
;
2492 /* Emit "or $t9, $t10, $t9". */
2493 set_tok_reg (newtok
[1], AXP_REG_T10
);
2494 assemble_tokens ("or", newtok
, 3, 1);
2496 /* Emit "stq_u $t9, 0($at). */
2497 set_tok_const(newtok
[1], 0);
2498 set_tok_preg (newtok
[2], AXP_REG_AT
);
2499 assemble_tokens_to_insn ("stq_u", newtok
, 3, &insn
);
2503 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2504 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2505 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2507 insn
.sequence
= lituse
;
2514 /* Store an integer to an unaligned address. */
2517 emit_ustX (const expressionS
*tok
,
2519 const void * vlgsize
)
2521 int lgsize
= (int) (long) vlgsize
;
2522 expressionS newtok
[3];
2524 /* Emit "lda $at, exp". */
2525 memcpy (newtok
, tok
, sizeof (expressionS
) * ntok
);
2526 newtok
[0].X_add_number
= AXP_REG_AT
;
2527 assemble_tokens ("lda", newtok
, ntok
, 1);
2529 /* Emit "ldq_u $9, 0($at)". */
2530 set_tok_reg (newtok
[0], AXP_REG_T9
);
2531 set_tok_const (newtok
[1], 0);
2532 set_tok_preg (newtok
[2], AXP_REG_AT
);
2533 assemble_tokens ("ldq_u", newtok
, 3, 1);
2535 /* Emit "ldq_u $10, size-1($at)". */
2536 set_tok_reg (newtok
[0], AXP_REG_T10
);
2537 set_tok_const (newtok
[1], (1 << lgsize
) - 1);
2538 assemble_tokens ("ldq_u", newtok
, 3, 1);
2540 /* Emit "insXl src, $at, $t11". */
2542 set_tok_reg (newtok
[1], AXP_REG_AT
);
2543 set_tok_reg (newtok
[2], AXP_REG_T11
);
2544 assemble_tokens (insXl_op
[lgsize
], newtok
, 3, 1);
2546 /* Emit "insXh src, $at, $t12". */
2547 set_tok_reg (newtok
[2], AXP_REG_T12
);
2548 assemble_tokens (insXh_op
[lgsize
], newtok
, 3, 1);
2550 /* Emit "mskXl $t9, $at, $t9". */
2551 set_tok_reg (newtok
[0], AXP_REG_T9
);
2552 newtok
[2] = newtok
[0];
2553 assemble_tokens (mskXl_op
[lgsize
], newtok
, 3, 1);
2555 /* Emit "mskXh $t10, $at, $t10". */
2556 set_tok_reg (newtok
[0], AXP_REG_T10
);
2557 newtok
[2] = newtok
[0];
2558 assemble_tokens (mskXh_op
[lgsize
], newtok
, 3, 1);
2560 /* Emit "or $t9, $t11, $t9". */
2561 set_tok_reg (newtok
[0], AXP_REG_T9
);
2562 set_tok_reg (newtok
[1], AXP_REG_T11
);
2563 newtok
[2] = newtok
[0];
2564 assemble_tokens ("or", newtok
, 3, 1);
2566 /* Emit "or $t10, $t12, $t10". */
2567 set_tok_reg (newtok
[0], AXP_REG_T10
);
2568 set_tok_reg (newtok
[1], AXP_REG_T12
);
2569 newtok
[2] = newtok
[0];
2570 assemble_tokens ("or", newtok
, 3, 1);
2572 /* Emit "stq_u $t10, size-1($at)". */
2573 set_tok_reg (newtok
[0], AXP_REG_T10
);
2574 set_tok_const (newtok
[1], (1 << lgsize
) - 1);
2575 set_tok_preg (newtok
[2], AXP_REG_AT
);
2576 assemble_tokens ("stq_u", newtok
, 3, 1);
2578 /* Emit "stq_u $t9, 0($at)". */
2579 set_tok_reg (newtok
[0], AXP_REG_T9
);
2580 set_tok_const (newtok
[1], 0);
2581 assemble_tokens ("stq_u", newtok
, 3, 1);
2584 /* Sign extend a half-word or byte. The 32-bit sign extend is
2585 implemented as "addl $31, $r, $t" in the opcode table. */
2588 emit_sextX (const expressionS
*tok
,
2590 const void * vlgsize
)
2592 long lgsize
= (long) vlgsize
;
2594 if (alpha_target
& AXP_OPCODE_BWX
)
2595 assemble_tokens (sextX_op
[lgsize
], tok
, ntok
, 0);
2598 int bitshift
= 64 - 8 * (1 << lgsize
);
2599 expressionS newtok
[3];
2601 /* Emit "sll src,bits,dst". */
2603 set_tok_const (newtok
[1], bitshift
);
2604 newtok
[2] = tok
[ntok
- 1];
2605 assemble_tokens ("sll", newtok
, 3, 1);
2607 /* Emit "sra dst,bits,dst". */
2608 newtok
[0] = newtok
[2];
2609 assemble_tokens ("sra", newtok
, 3, 1);
2613 /* Implement the division and modulus macros. */
2617 /* Make register usage like in normal procedure call.
2618 Don't clobber PV and RA. */
2621 emit_division (const expressionS
*tok
,
2623 const void * symname
)
2625 /* DIVISION and MODULUS. Yech.
2630 mov x,R16 # if x != R16
2631 mov y,R17 # if y != R17
2636 with appropriate optimizations if R0,R16,R17 are the registers
2637 specified by the compiler. */
2641 expressionS newtok
[3];
2643 xr
= regno (tok
[0].X_add_number
);
2644 yr
= regno (tok
[1].X_add_number
);
2649 rr
= regno (tok
[2].X_add_number
);
2651 /* Move the operands into the right place. */
2652 if (yr
== AXP_REG_R16
&& xr
== AXP_REG_R17
)
2654 /* They are in exactly the wrong order -- swap through AT. */
2656 as_bad (_("macro requires $at register while noat in effect"));
2658 set_tok_reg (newtok
[0], AXP_REG_R16
);
2659 set_tok_reg (newtok
[1], AXP_REG_AT
);
2660 assemble_tokens ("mov", newtok
, 2, 1);
2662 set_tok_reg (newtok
[0], AXP_REG_R17
);
2663 set_tok_reg (newtok
[1], AXP_REG_R16
);
2664 assemble_tokens ("mov", newtok
, 2, 1);
2666 set_tok_reg (newtok
[0], AXP_REG_AT
);
2667 set_tok_reg (newtok
[1], AXP_REG_R17
);
2668 assemble_tokens ("mov", newtok
, 2, 1);
2672 if (yr
== AXP_REG_R16
)
2674 set_tok_reg (newtok
[0], AXP_REG_R16
);
2675 set_tok_reg (newtok
[1], AXP_REG_R17
);
2676 assemble_tokens ("mov", newtok
, 2, 1);
2679 if (xr
!= AXP_REG_R16
)
2681 set_tok_reg (newtok
[0], xr
);
2682 set_tok_reg (newtok
[1], AXP_REG_R16
);
2683 assemble_tokens ("mov", newtok
, 2, 1);
2686 if (yr
!= AXP_REG_R16
&& yr
!= AXP_REG_R17
)
2688 set_tok_reg (newtok
[0], yr
);
2689 set_tok_reg (newtok
[1], AXP_REG_R17
);
2690 assemble_tokens ("mov", newtok
, 2, 1);
2694 sym
= symbol_find_or_make ((const char *) symname
);
2696 set_tok_reg (newtok
[0], AXP_REG_AT
);
2697 set_tok_sym (newtok
[1], sym
, 0);
2698 assemble_tokens ("lda", newtok
, 2, 1);
2700 /* Call the division routine. */
2701 set_tok_reg (newtok
[0], AXP_REG_AT
);
2702 set_tok_cpreg (newtok
[1], AXP_REG_AT
);
2703 set_tok_const (newtok
[2], 0);
2704 assemble_tokens ("jsr", newtok
, 3, 1);
2706 /* Move the result to the right place. */
2707 if (rr
!= AXP_REG_R0
)
2709 set_tok_reg (newtok
[0], AXP_REG_R0
);
2710 set_tok_reg (newtok
[1], rr
);
2711 assemble_tokens ("mov", newtok
, 2, 1);
2715 #else /* !OBJ_EVAX */
2718 emit_division (const expressionS
*tok
,
2720 const void * symname
)
2722 /* DIVISION and MODULUS. Yech.
2732 with appropriate optimizations if t10,t11,t12 are the registers
2733 specified by the compiler. */
2737 expressionS newtok
[3];
2739 xr
= regno (tok
[0].X_add_number
);
2740 yr
= regno (tok
[1].X_add_number
);
2745 rr
= regno (tok
[2].X_add_number
);
2747 sym
= symbol_find_or_make ((const char *) symname
);
2749 /* Move the operands into the right place. */
2750 if (yr
== AXP_REG_T10
&& xr
== AXP_REG_T11
)
2752 /* They are in exactly the wrong order -- swap through AT. */
2754 as_bad (_("macro requires $at register while noat in effect"));
2756 set_tok_reg (newtok
[0], AXP_REG_T10
);
2757 set_tok_reg (newtok
[1], AXP_REG_AT
);
2758 assemble_tokens ("mov", newtok
, 2, 1);
2760 set_tok_reg (newtok
[0], AXP_REG_T11
);
2761 set_tok_reg (newtok
[1], AXP_REG_T10
);
2762 assemble_tokens ("mov", newtok
, 2, 1);
2764 set_tok_reg (newtok
[0], AXP_REG_AT
);
2765 set_tok_reg (newtok
[1], AXP_REG_T11
);
2766 assemble_tokens ("mov", newtok
, 2, 1);
2770 if (yr
== AXP_REG_T10
)
2772 set_tok_reg (newtok
[0], AXP_REG_T10
);
2773 set_tok_reg (newtok
[1], AXP_REG_T11
);
2774 assemble_tokens ("mov", newtok
, 2, 1);
2777 if (xr
!= AXP_REG_T10
)
2779 set_tok_reg (newtok
[0], xr
);
2780 set_tok_reg (newtok
[1], AXP_REG_T10
);
2781 assemble_tokens ("mov", newtok
, 2, 1);
2784 if (yr
!= AXP_REG_T10
&& yr
!= AXP_REG_T11
)
2786 set_tok_reg (newtok
[0], yr
);
2787 set_tok_reg (newtok
[1], AXP_REG_T11
);
2788 assemble_tokens ("mov", newtok
, 2, 1);
2792 /* Call the division routine. */
2793 set_tok_reg (newtok
[0], AXP_REG_T9
);
2794 set_tok_sym (newtok
[1], sym
, 0);
2795 assemble_tokens ("jsr", newtok
, 2, 1);
2797 /* Reload the GP register. */
2801 #if defined(OBJ_ECOFF) || defined(OBJ_ELF)
2802 set_tok_reg (newtok
[0], alpha_gp_register
);
2803 set_tok_const (newtok
[1], 0);
2804 set_tok_preg (newtok
[2], AXP_REG_T9
);
2805 assemble_tokens ("ldgp", newtok
, 3, 1);
2808 /* Move the result to the right place. */
2809 if (rr
!= AXP_REG_T12
)
2811 set_tok_reg (newtok
[0], AXP_REG_T12
);
2812 set_tok_reg (newtok
[1], rr
);
2813 assemble_tokens ("mov", newtok
, 2, 1);
2817 #endif /* !OBJ_EVAX */
2819 /* The jsr and jmp macros differ from their instruction counterparts
2820 in that they can load the target address and default most
2824 emit_jsrjmp (const expressionS
*tok
,
2826 const void * vopname
)
2828 const char *opname
= (const char *) vopname
;
2829 struct alpha_insn insn
;
2830 expressionS newtok
[3];
2834 if (tokidx
< ntok
&& tok
[tokidx
].X_op
== O_register
)
2835 r
= regno (tok
[tokidx
++].X_add_number
);
2837 r
= strcmp (opname
, "jmp") == 0 ? AXP_REG_ZERO
: AXP_REG_RA
;
2839 set_tok_reg (newtok
[0], r
);
2841 if (tokidx
< ntok
&&
2842 (tok
[tokidx
].X_op
== O_pregister
|| tok
[tokidx
].X_op
== O_cpregister
))
2843 r
= regno (tok
[tokidx
++].X_add_number
);
2845 /* Keep register if jsr $n.<sym>. */
2849 int basereg
= alpha_gp_register
;
2850 lituse
= load_expression (r
= AXP_REG_PV
, &tok
[tokidx
],
2851 &basereg
, NULL
, opname
);
2855 set_tok_cpreg (newtok
[1], r
);
2859 newtok
[2] = tok
[tokidx
];
2862 set_tok_const (newtok
[2], 0);
2864 assemble_tokens_to_insn (opname
, newtok
, 3, &insn
);
2868 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2869 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_JSR
;
2870 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2872 insn
.sequence
= lituse
;
2876 if (alpha_flag_replace
2878 && tok
[tokidx
].X_add_symbol
2879 && alpha_linkage_symbol
)
2881 /* Create a BOH reloc for 'jsr $27,NAME'. */
2882 const char *symname
= S_GET_NAME (tok
[tokidx
].X_add_symbol
);
2883 int symlen
= strlen (symname
);
2886 /* Build the entry name as 'NAME..en'. */
2887 ensymname
= (char *) alloca (symlen
+ 5);
2888 memcpy (ensymname
, symname
, symlen
);
2889 memcpy (ensymname
+ symlen
, "..en", 5);
2891 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2892 if (insn
.nfixups
> 0)
2894 memmove (&insn
.fixups
[1], &insn
.fixups
[0],
2895 sizeof(struct alpha_fixup
) * insn
.nfixups
);
2898 /* The fixup must be the same as the BFD_RELOC_ALPHA_NOP
2899 case in load_expression. See B.4.5.2 of the OpenVMS
2900 Linker Utility Manual. */
2901 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_BOH
;
2902 insn
.fixups
[0].exp
.X_op
= O_symbol
;
2903 insn
.fixups
[0].exp
.X_add_symbol
= symbol_find_or_make (ensymname
);
2904 insn
.fixups
[0].exp
.X_add_number
= 0;
2905 insn
.fixups
[0].xtrasym
= alpha_linkage_symbol
;
2906 insn
.fixups
[0].procsym
= alpha_evax_proc
->symbol
;
2908 alpha_linkage_symbol
= 0;
2915 /* The ret and jcr instructions differ from their instruction
2916 counterparts in that everything can be defaulted. */
2919 emit_retjcr (const expressionS
*tok
,
2921 const void * vopname
)
2923 const char *opname
= (const char *) vopname
;
2924 expressionS newtok
[3];
2927 if (tokidx
< ntok
&& tok
[tokidx
].X_op
== O_register
)
2928 r
= regno (tok
[tokidx
++].X_add_number
);
2932 set_tok_reg (newtok
[0], r
);
2934 if (tokidx
< ntok
&&
2935 (tok
[tokidx
].X_op
== O_pregister
|| tok
[tokidx
].X_op
== O_cpregister
))
2936 r
= regno (tok
[tokidx
++].X_add_number
);
2940 set_tok_cpreg (newtok
[1], r
);
2943 newtok
[2] = tok
[tokidx
];
2945 set_tok_const (newtok
[2], strcmp (opname
, "ret") == 0);
2947 assemble_tokens (opname
, newtok
, 3, 0);
2950 /* Implement the ldgp macro. */
2953 emit_ldgp (const expressionS
*tok ATTRIBUTE_UNUSED
,
2954 int ntok ATTRIBUTE_UNUSED
,
2955 const void * unused ATTRIBUTE_UNUSED
)
2960 #if defined(OBJ_ECOFF) || defined(OBJ_ELF)
2961 /* from "ldgp r1,n(r2)", generate "ldah r1,X(R2); lda r1,Y(r1)"
2962 with appropriate constants and relocations. */
2963 struct alpha_insn insn
;
2964 expressionS newtok
[3];
2968 if (regno (tok
[2].X_add_number
) == AXP_REG_PV
)
2969 ecoff_set_gp_prolog_size (0);
2973 set_tok_const (newtok
[1], 0);
2976 assemble_tokens_to_insn ("ldah", newtok
, 3, &insn
);
2981 if (addend
.X_op
!= O_constant
)
2982 as_bad (_("can not resolve expression"));
2983 addend
.X_op
= O_symbol
;
2984 addend
.X_add_symbol
= alpha_gp_symbol
;
2988 insn
.fixups
[0].exp
= addend
;
2989 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_GPDISP_HI16
;
2990 insn
.sequence
= next_sequence_num
;
2994 set_tok_preg (newtok
[2], tok
[0].X_add_number
);
2996 assemble_tokens_to_insn ("lda", newtok
, 3, &insn
);
2999 addend
.X_add_number
+= 4;
3003 insn
.fixups
[0].exp
= addend
;
3004 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_GPDISP_LO16
;
3005 insn
.sequence
= next_sequence_num
--;
3008 #endif /* OBJ_ECOFF || OBJ_ELF */
3011 /* The macro table. */
3013 static const struct alpha_macro alpha_macros
[] =
3015 /* Load/Store macros. */
3016 { "lda", emit_lda
, NULL
,
3017 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3018 { "ldah", emit_ldah
, NULL
,
3019 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
} },
3021 { "ldl", emit_ir_load
, "ldl",
3022 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3023 { "ldl_l", emit_ir_load
, "ldl_l",
3024 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3025 { "ldq", emit_ir_load
, "ldq",
3026 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3027 { "ldq_l", emit_ir_load
, "ldq_l",
3028 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3029 { "ldq_u", emit_ir_load
, "ldq_u",
3030 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3031 { "ldf", emit_loadstore
, "ldf",
3032 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3033 { "ldg", emit_loadstore
, "ldg",
3034 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3035 { "lds", emit_loadstore
, "lds",
3036 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3037 { "ldt", emit_loadstore
, "ldt",
3038 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3040 { "ldb", emit_ldX
, (void *) 0,
3041 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3042 { "ldbu", emit_ldXu
, (void *) 0,
3043 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3044 { "ldw", emit_ldX
, (void *) 1,
3045 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3046 { "ldwu", emit_ldXu
, (void *) 1,
3047 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3049 { "uldw", emit_uldX
, (void *) 1,
3050 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3051 { "uldwu", emit_uldXu
, (void *) 1,
3052 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3053 { "uldl", emit_uldX
, (void *) 2,
3054 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3055 { "uldlu", emit_uldXu
, (void *) 2,
3056 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3057 { "uldq", emit_uldXu
, (void *) 3,
3058 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3060 { "ldgp", emit_ldgp
, NULL
,
3061 { MACRO_IR
, MACRO_EXP
, MACRO_PIR
, MACRO_EOA
} },
3063 { "ldi", emit_lda
, NULL
,
3064 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
} },
3065 { "ldil", emit_ldil
, NULL
,
3066 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
} },
3067 { "ldiq", emit_lda
, NULL
,
3068 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
} },
3070 { "stl", emit_loadstore
, "stl",
3071 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3072 { "stl_c", emit_loadstore
, "stl_c",
3073 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3074 { "stq", emit_loadstore
, "stq",
3075 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3076 { "stq_c", emit_loadstore
, "stq_c",
3077 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3078 { "stq_u", emit_loadstore
, "stq_u",
3079 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3080 { "stf", emit_loadstore
, "stf",
3081 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3082 { "stg", emit_loadstore
, "stg",
3083 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3084 { "sts", emit_loadstore
, "sts",
3085 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3086 { "stt", emit_loadstore
, "stt",
3087 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3089 { "stb", emit_stX
, (void *) 0,
3090 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3091 { "stw", emit_stX
, (void *) 1,
3092 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3093 { "ustw", emit_ustX
, (void *) 1,
3094 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3095 { "ustl", emit_ustX
, (void *) 2,
3096 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3097 { "ustq", emit_ustX
, (void *) 3,
3098 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3100 /* Arithmetic macros. */
3102 { "sextb", emit_sextX
, (void *) 0,
3103 { MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3104 MACRO_IR
, MACRO_EOA
,
3105 /* MACRO_EXP, MACRO_IR, MACRO_EOA */ } },
3106 { "sextw", emit_sextX
, (void *) 1,
3107 { MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3108 MACRO_IR
, MACRO_EOA
,
3109 /* MACRO_EXP, MACRO_IR, MACRO_EOA */ } },
3111 { "divl", emit_division
, "__divl",
3112 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3113 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3114 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3115 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3116 { "divlu", emit_division
, "__divlu",
3117 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3118 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3119 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3120 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3121 { "divq", emit_division
, "__divq",
3122 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3123 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3124 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3125 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3126 { "divqu", emit_division
, "__divqu",
3127 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3128 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3129 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3130 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3131 { "reml", emit_division
, "__reml",
3132 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3133 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3134 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3135 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3136 { "remlu", emit_division
, "__remlu",
3137 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3138 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3139 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3140 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3141 { "remq", emit_division
, "__remq",
3142 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3143 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3144 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3145 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3146 { "remqu", emit_division
, "__remqu",
3147 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3148 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3149 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3150 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3152 { "jsr", emit_jsrjmp
, "jsr",
3153 { MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3154 MACRO_PIR
, MACRO_EOA
,
3155 MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3156 MACRO_EXP
, MACRO_EOA
} },
3157 { "jmp", emit_jsrjmp
, "jmp",
3158 { MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3159 MACRO_PIR
, MACRO_EOA
,
3160 MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3161 MACRO_EXP
, MACRO_EOA
} },
3162 { "ret", emit_retjcr
, "ret",
3163 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3164 MACRO_IR
, MACRO_EOA
,
3165 MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3166 MACRO_PIR
, MACRO_EOA
,
3167 MACRO_EXP
, MACRO_EOA
,
3169 { "jcr", emit_retjcr
, "jcr",
3170 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3171 MACRO_IR
, MACRO_EOA
,
3172 MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3173 MACRO_PIR
, MACRO_EOA
,
3174 MACRO_EXP
, MACRO_EOA
,
3176 { "jsr_coroutine", emit_retjcr
, "jcr",
3177 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3178 MACRO_IR
, MACRO_EOA
,
3179 MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3180 MACRO_PIR
, MACRO_EOA
,
3181 MACRO_EXP
, MACRO_EOA
,
3185 static const unsigned int alpha_num_macros
3186 = sizeof (alpha_macros
) / sizeof (*alpha_macros
);
3188 /* Search forward through all variants of a macro looking for a syntax
3191 static const struct alpha_macro
*
3192 find_macro_match (const struct alpha_macro
*first_macro
,
3193 const expressionS
*tok
,
3197 const struct alpha_macro
*macro
= first_macro
;
3202 const enum alpha_macro_arg
*arg
= macro
->argsets
;
3216 /* Index register. */
3218 if (tokidx
>= ntok
|| tok
[tokidx
].X_op
!= O_register
3219 || !is_ir_num (tok
[tokidx
].X_add_number
))
3224 /* Parenthesized index register. */
3226 if (tokidx
>= ntok
|| tok
[tokidx
].X_op
!= O_pregister
3227 || !is_ir_num (tok
[tokidx
].X_add_number
))
3232 /* Optional parenthesized index register. */
3234 if (tokidx
< ntok
&& tok
[tokidx
].X_op
== O_pregister
3235 && is_ir_num (tok
[tokidx
].X_add_number
))
3239 /* Leading comma with a parenthesized index register. */
3241 if (tokidx
>= ntok
|| tok
[tokidx
].X_op
!= O_cpregister
3242 || !is_ir_num (tok
[tokidx
].X_add_number
))
3247 /* Floating point register. */
3249 if (tokidx
>= ntok
|| tok
[tokidx
].X_op
!= O_register
3250 || !is_fpr_num (tok
[tokidx
].X_add_number
))
3255 /* Normal expression. */
3259 switch (tok
[tokidx
].X_op
)
3268 case O_lituse_bytoff
:
3284 while (*arg
!= MACRO_EOA
)
3292 while (++macro
- alpha_macros
< (int) alpha_num_macros
3293 && !strcmp (macro
->name
, first_macro
->name
));
3298 /* Given an opcode name and a pre-tokenized set of arguments, take the
3299 opcode all the way through emission. */
3302 assemble_tokens (const char *opname
,
3303 const expressionS
*tok
,
3305 int local_macros_on
)
3307 int found_something
= 0;
3308 const struct alpha_opcode
*opcode
;
3309 const struct alpha_macro
*macro
;
3311 extended_bfd_reloc_code_real_type reloc
= BFD_RELOC_UNUSED
;
3314 /* If a user-specified relocation is present, this is not a macro. */
3315 if (ntok
&& USER_RELOC_P (tok
[ntok
- 1].X_op
))
3317 reloc
= ALPHA_RELOC_TABLE (tok
[ntok
- 1].X_op
)->reloc
;
3322 if (local_macros_on
)
3324 macro
= ((const struct alpha_macro
*)
3325 hash_find (alpha_macro_hash
, opname
));
3328 found_something
= 1;
3329 macro
= find_macro_match (macro
, tok
, &ntok
);
3332 (*macro
->emit
) (tok
, ntok
, macro
->arg
);
3338 /* Search opcodes. */
3339 opcode
= (const struct alpha_opcode
*) hash_find (alpha_opcode_hash
, opname
);
3342 found_something
= 1;
3343 opcode
= find_opcode_match (opcode
, tok
, &ntok
, &cpumatch
);
3346 struct alpha_insn insn
;
3347 assemble_insn (opcode
, tok
, ntok
, &insn
, reloc
);
3349 /* Copy the sequence number for the reloc from the reloc token. */
3350 if (reloc
!= BFD_RELOC_UNUSED
)
3351 insn
.sequence
= tok
[ntok
].X_add_number
;
3358 if (found_something
)
3361 as_bad (_("inappropriate arguments for opcode `%s'"), opname
);
3363 as_bad (_("opcode `%s' not supported for target %s"), opname
,
3367 as_bad (_("unknown opcode `%s'"), opname
);
3372 /* Add sym+addend to link pool.
3373 Return offset from curent procedure value (pv) to entry in link pool.
3375 Add new fixup only if offset isn't 16bit. */
3378 add_to_link_pool (symbolS
*sym
, offsetT addend
)
3381 segT current_section
= now_seg
;
3382 int current_subsec
= now_subseg
;
3384 segment_info_type
*seginfo
= seg_info (alpha_link_section
);
3386 symbolS
*linksym
, *expsym
;
3389 basesym
= alpha_evax_proc
->symbol
;
3391 /* @@ This assumes all entries in a given section will be of the same
3392 size... Probably correct, but unwise to rely on. */
3393 /* This must always be called with the same subsegment. */
3395 if (seginfo
->frchainP
)
3396 for (fixp
= seginfo
->frchainP
->fix_root
;
3397 fixp
!= (fixS
*) NULL
;
3398 fixp
= fixp
->fx_next
)
3400 if (fixp
->fx_addsy
== sym
3401 && fixp
->fx_offset
== (valueT
)addend
3402 && fixp
->tc_fix_data
.info
3403 && fixp
->tc_fix_data
.info
->sym
3404 && fixp
->tc_fix_data
.info
->sym
->sy_value
.X_op_symbol
== basesym
)
3405 return fixp
->tc_fix_data
.info
->sym
;
3408 /* Not found, add a new entry. */
3409 subseg_set (alpha_link_section
, 0);
3410 linksym
= symbol_new
3411 (FAKE_LABEL_NAME
, now_seg
, (valueT
) frag_now_fix (), frag_now
);
3415 /* Create the basesym - linksym expression (offset of the added entry). */
3416 e
.X_op
= O_subtract
;
3417 e
.X_add_symbol
= linksym
;
3418 e
.X_op_symbol
= basesym
;
3420 expsym
= make_expr_symbol (&e
);
3423 (frag_now
, p
- frag_now
->fr_literal
, 8, sym
, addend
, 0, BFD_RELOC_64
);
3424 fixp
->tc_fix_data
.info
= get_alpha_reloc_tag (next_sequence_num
--);
3425 fixp
->tc_fix_data
.info
->sym
= expsym
;
3427 subseg_set (current_section
, current_subsec
);
3430 #endif /* OBJ_EVAX */
3432 /* Assembler directives. */
3434 /* Handle the .text pseudo-op. This is like the usual one, but it
3435 clears alpha_insn_label and restores auto alignment. */
3438 s_alpha_text (int i
)
3449 symbolP
= symbol_find (".text");
3450 if (symbolP
== NULL
)
3452 symbolP
= symbol_make (".text");
3453 S_SET_SEGMENT (symbolP
, text_section
);
3454 symbol_table_insert (symbolP
);
3458 alpha_insn_label
= NULL
;
3459 alpha_auto_align_on
= 1;
3460 alpha_current_align
= 0;
3463 /* Handle the .data pseudo-op. This is like the usual one, but it
3464 clears alpha_insn_label and restores auto alignment. */
3467 s_alpha_data (int i
)
3474 alpha_insn_label
= NULL
;
3475 alpha_auto_align_on
= 1;
3476 alpha_current_align
= 0;
3479 #if defined (OBJ_ECOFF) || defined (OBJ_EVAX)
3481 /* Handle the OSF/1 and openVMS .comm pseudo quirks. */
3484 s_alpha_comm (int ignore ATTRIBUTE_UNUSED
)
3496 name
= input_line_pointer
;
3497 c
= get_symbol_end ();
3499 /* Just after name is now '\0'. */
3500 p
= input_line_pointer
;
3505 /* Alpha OSF/1 compiler doesn't provide the comma, gcc does. */
3506 if (*input_line_pointer
== ',')
3508 input_line_pointer
++;
3511 if ((size
= get_absolute_expression ()) < 0)
3513 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
3514 ignore_rest_of_line ();
3519 symbolP
= symbol_find_or_make (name
);
3522 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
3524 as_bad (_("Ignoring attempt to re-define symbol"));
3525 ignore_rest_of_line ();
3530 if (*input_line_pointer
!= ',')
3531 temp
= 8; /* Default alignment. */
3534 input_line_pointer
++;
3536 temp
= get_absolute_expression ();
3539 /* ??? Unlike on OSF/1, the alignment factor is not in log units. */
3540 while ((temp
>>= 1) != 0)
3543 if (*input_line_pointer
== ',')
3545 /* Extended form of the directive
3547 .comm symbol, size, alignment, section
3549 where the "common" semantics is transferred to the section.
3550 The symbol is effectively an alias for the section name. */
3554 symbolS
*sec_symbol
;
3555 segT current_seg
= now_seg
;
3556 subsegT current_subseg
= now_subseg
;
3559 input_line_pointer
++;
3561 sec_name
= s_alpha_section_name ();
3562 sec_symbol
= symbol_find_or_make (sec_name
);
3563 sec
= subseg_new (sec_name
, 0);
3564 S_SET_SEGMENT (sec_symbol
, sec
);
3565 symbol_get_bfdsym (sec_symbol
)->flags
|= BSF_SECTION_SYM
;
3566 bfd_vms_set_section_flags (stdoutput
, sec
, 0,
3567 EGPS__V_OVR
| EGPS__V_GBL
| EGPS__V_NOMOD
);
3568 record_alignment (sec
, log_align
);
3570 /* Reuse stab_string_size to store the size of the section. */
3571 cur_size
= seg_info (sec
)->stabu
.stab_string_size
;
3572 if ((int) size
> cur_size
)
3575 = frag_var (rs_fill
, 1, 1, (relax_substateT
)0, NULL
,
3576 (valueT
)size
- (valueT
)cur_size
, NULL
);
3578 seg_info (sec
)->stabu
.stab_string_size
= (int)size
;
3581 S_SET_SEGMENT (symbolP
, sec
);
3583 subseg_set (current_seg
, current_subseg
);
3587 /* Regular form of the directive
3589 .comm symbol, size, alignment
3591 where the "common" semantics in on the symbol.
3592 These symbols are assembled in the .bss section. */
3595 segT current_seg
= now_seg
;
3596 subsegT current_subseg
= now_subseg
;
3598 subseg_set (bss_section
, 1);
3599 frag_align (log_align
, 0, 0);
3600 record_alignment (bss_section
, log_align
);
3602 symbolP
->sy_frag
= frag_now
;
3603 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
3607 S_SET_SEGMENT (symbolP
, bss_section
);
3609 subseg_set (current_seg
, current_subseg
);
3613 if (S_GET_VALUE (symbolP
))
3615 if (S_GET_VALUE (symbolP
) != (valueT
) size
)
3616 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
3617 S_GET_NAME (symbolP
),
3618 (long) S_GET_VALUE (symbolP
),
3624 S_SET_VALUE (symbolP
, (valueT
) size
);
3626 S_SET_EXTERNAL (symbolP
);
3630 know (symbolP
->sy_frag
== &zero_address_frag
);
3632 demand_empty_rest_of_line ();
3635 #endif /* ! OBJ_ELF */
3639 /* Handle the .rdata pseudo-op. This is like the usual one, but it
3640 clears alpha_insn_label and restores auto alignment. */
3643 s_alpha_rdata (int ignore ATTRIBUTE_UNUSED
)
3645 get_absolute_expression ();
3646 subseg_new (".rdata", 0);
3647 demand_empty_rest_of_line ();
3648 alpha_insn_label
= NULL
;
3649 alpha_auto_align_on
= 1;
3650 alpha_current_align
= 0;
3657 /* Handle the .sdata pseudo-op. This is like the usual one, but it
3658 clears alpha_insn_label and restores auto alignment. */
3661 s_alpha_sdata (int ignore ATTRIBUTE_UNUSED
)
3663 get_absolute_expression ();
3664 subseg_new (".sdata", 0);
3665 demand_empty_rest_of_line ();
3666 alpha_insn_label
= NULL
;
3667 alpha_auto_align_on
= 1;
3668 alpha_current_align
= 0;
3673 struct alpha_elf_frame_data
3676 symbolS
*func_end_sym
;
3677 symbolS
*prologue_sym
;
3683 offsetT mask_offset
;
3684 offsetT fmask_offset
;
3686 struct alpha_elf_frame_data
*next
;
3689 static struct alpha_elf_frame_data
*all_frame_data
;
3690 static struct alpha_elf_frame_data
**plast_frame_data
= &all_frame_data
;
3691 static struct alpha_elf_frame_data
*cur_frame_data
;
3693 /* Handle the .section pseudo-op. This is like the usual one, but it
3694 clears alpha_insn_label and restores auto alignment. */
3697 s_alpha_section (int ignore ATTRIBUTE_UNUSED
)
3699 obj_elf_section (ignore
);
3701 alpha_insn_label
= NULL
;
3702 alpha_auto_align_on
= 1;
3703 alpha_current_align
= 0;
3707 s_alpha_ent (int dummy ATTRIBUTE_UNUSED
)
3709 if (ECOFF_DEBUGGING
)
3710 ecoff_directive_ent (0);
3713 char *name
, name_end
;
3714 name
= input_line_pointer
;
3715 name_end
= get_symbol_end ();
3717 if (! is_name_beginner (*name
))
3719 as_warn (_(".ent directive has no name"));
3720 *input_line_pointer
= name_end
;
3727 as_warn (_("nested .ent directives"));
3729 sym
= symbol_find_or_make (name
);
3730 symbol_get_bfdsym (sym
)->flags
|= BSF_FUNCTION
;
3732 cur_frame_data
= (struct alpha_elf_frame_data
*)
3733 calloc (1, sizeof (*cur_frame_data
));
3734 cur_frame_data
->func_sym
= sym
;
3736 /* Provide sensible defaults. */
3737 cur_frame_data
->fp_regno
= 30; /* sp */
3738 cur_frame_data
->ra_regno
= 26; /* ra */
3740 *plast_frame_data
= cur_frame_data
;
3741 plast_frame_data
= &cur_frame_data
->next
;
3743 /* The .ent directive is sometimes followed by a number. Not sure
3744 what it really means, but ignore it. */
3745 *input_line_pointer
= name_end
;
3747 if (*input_line_pointer
== ',')
3749 input_line_pointer
++;
3752 if (ISDIGIT (*input_line_pointer
) || *input_line_pointer
== '-')
3753 (void) get_absolute_expression ();
3755 demand_empty_rest_of_line ();
3760 s_alpha_end (int dummy ATTRIBUTE_UNUSED
)
3762 if (ECOFF_DEBUGGING
)
3763 ecoff_directive_end (0);
3766 char *name
, name_end
;
3767 name
= input_line_pointer
;
3768 name_end
= get_symbol_end ();
3770 if (! is_name_beginner (*name
))
3772 as_warn (_(".end directive has no name"));
3773 *input_line_pointer
= name_end
;
3779 sym
= symbol_find (name
);
3780 if (!cur_frame_data
)
3781 as_warn (_(".end directive without matching .ent"));
3782 else if (sym
!= cur_frame_data
->func_sym
)
3783 as_warn (_(".end directive names different symbol than .ent"));
3785 /* Create an expression to calculate the size of the function. */
3786 if (sym
&& cur_frame_data
)
3788 OBJ_SYMFIELD_TYPE
*obj
= symbol_get_obj (sym
);
3789 expressionS
*exp
= (expressionS
*) xmalloc (sizeof (expressionS
));
3792 exp
->X_op
= O_subtract
;
3793 exp
->X_add_symbol
= symbol_temp_new_now ();
3794 exp
->X_op_symbol
= sym
;
3795 exp
->X_add_number
= 0;
3797 cur_frame_data
->func_end_sym
= exp
->X_add_symbol
;
3800 cur_frame_data
= NULL
;
3802 *input_line_pointer
= name_end
;
3804 demand_empty_rest_of_line ();
3809 s_alpha_mask (int fp
)
3811 if (ECOFF_DEBUGGING
)
3814 ecoff_directive_fmask (0);
3816 ecoff_directive_mask (0);
3823 if (!cur_frame_data
)
3826 as_warn (_(".fmask outside of .ent"));
3828 as_warn (_(".mask outside of .ent"));
3829 discard_rest_of_line ();
3833 if (get_absolute_expression_and_terminator (&val
) != ',')
3836 as_warn (_("bad .fmask directive"));
3838 as_warn (_("bad .mask directive"));
3839 --input_line_pointer
;
3840 discard_rest_of_line ();
3844 offset
= get_absolute_expression ();
3845 demand_empty_rest_of_line ();
3849 cur_frame_data
->fmask
= val
;
3850 cur_frame_data
->fmask_offset
= offset
;
3854 cur_frame_data
->mask
= val
;
3855 cur_frame_data
->mask_offset
= offset
;
3861 s_alpha_frame (int dummy ATTRIBUTE_UNUSED
)
3863 if (ECOFF_DEBUGGING
)
3864 ecoff_directive_frame (0);
3869 if (!cur_frame_data
)
3871 as_warn (_(".frame outside of .ent"));
3872 discard_rest_of_line ();
3876 cur_frame_data
->fp_regno
= tc_get_register (1);
3879 if (*input_line_pointer
++ != ','
3880 || get_absolute_expression_and_terminator (&val
) != ',')
3882 as_warn (_("bad .frame directive"));
3883 --input_line_pointer
;
3884 discard_rest_of_line ();
3887 cur_frame_data
->frame_size
= val
;
3889 cur_frame_data
->ra_regno
= tc_get_register (0);
3891 /* Next comes the "offset of saved $a0 from $sp". In gcc terms
3892 this is current_function_pretend_args_size. There's no place
3893 to put this value, so ignore it. */
3899 s_alpha_prologue (int ignore ATTRIBUTE_UNUSED
)
3904 arg
= get_absolute_expression ();
3905 demand_empty_rest_of_line ();
3906 alpha_prologue_label
= symbol_new
3907 (FAKE_LABEL_NAME
, now_seg
, (valueT
) frag_now_fix (), frag_now
);
3909 if (ECOFF_DEBUGGING
)
3910 sym
= ecoff_get_cur_proc_sym ();
3912 sym
= cur_frame_data
? cur_frame_data
->func_sym
: NULL
;
3916 as_bad (_(".prologue directive without a preceding .ent directive"));
3922 case 0: /* No PV required. */
3923 S_SET_OTHER (sym
, STO_ALPHA_NOPV
3924 | (S_GET_OTHER (sym
) & ~STO_ALPHA_STD_GPLOAD
));
3926 case 1: /* Std GP load. */
3927 S_SET_OTHER (sym
, STO_ALPHA_STD_GPLOAD
3928 | (S_GET_OTHER (sym
) & ~STO_ALPHA_STD_GPLOAD
));
3930 case 2: /* Non-std use of PV. */
3934 as_bad (_("Invalid argument %d to .prologue."), arg
);
3939 cur_frame_data
->prologue_sym
= symbol_temp_new_now ();
3942 static char *first_file_directive
;
3945 s_alpha_file (int ignore ATTRIBUTE_UNUSED
)
3947 /* Save the first .file directive we see, so that we can change our
3948 minds about whether ecoff debugging should or shouldn't be enabled. */
3949 if (alpha_flag_mdebug
< 0 && ! first_file_directive
)
3951 char *start
= input_line_pointer
;
3954 discard_rest_of_line ();
3956 len
= input_line_pointer
- start
;
3957 first_file_directive
= (char *) xmalloc (len
+ 1);
3958 memcpy (first_file_directive
, start
, len
);
3959 first_file_directive
[len
] = '\0';
3961 input_line_pointer
= start
;
3964 if (ECOFF_DEBUGGING
)
3965 ecoff_directive_file (0);
3967 dwarf2_directive_file (0);
3971 s_alpha_loc (int ignore ATTRIBUTE_UNUSED
)
3973 if (ECOFF_DEBUGGING
)
3974 ecoff_directive_loc (0);
3976 dwarf2_directive_loc (0);
3980 s_alpha_stab (int n
)
3982 /* If we've been undecided about mdebug, make up our minds in favour. */
3983 if (alpha_flag_mdebug
< 0)
3985 segT sec
= subseg_new (".mdebug", 0);
3986 bfd_set_section_flags (stdoutput
, sec
, SEC_HAS_CONTENTS
| SEC_READONLY
);
3987 bfd_set_section_alignment (stdoutput
, sec
, 3);
3989 ecoff_read_begin_hook ();
3991 if (first_file_directive
)
3993 char *save_ilp
= input_line_pointer
;
3994 input_line_pointer
= first_file_directive
;
3995 ecoff_directive_file (0);
3996 input_line_pointer
= save_ilp
;
3997 free (first_file_directive
);
4000 alpha_flag_mdebug
= 1;
4006 s_alpha_coff_wrapper (int which
)
4008 static void (* const fns
[]) (int) = {
4009 ecoff_directive_begin
,
4010 ecoff_directive_bend
,
4011 ecoff_directive_def
,
4012 ecoff_directive_dim
,
4013 ecoff_directive_endef
,
4014 ecoff_directive_scl
,
4015 ecoff_directive_tag
,
4016 ecoff_directive_val
,
4019 gas_assert (which
>= 0 && which
< (int) (sizeof (fns
)/sizeof (*fns
)));
4021 if (ECOFF_DEBUGGING
)
4025 as_bad (_("ECOFF debugging is disabled."));
4026 ignore_rest_of_line ();
4030 /* Called at the end of assembly. Here we emit unwind info for frames
4031 unless the compiler has done it for us. */
4034 alpha_elf_md_end (void)
4036 struct alpha_elf_frame_data
*p
;
4039 as_warn (_(".ent directive without matching .end"));
4041 /* If someone has generated the unwind info themselves, great. */
4042 if (bfd_get_section_by_name (stdoutput
, ".eh_frame") != NULL
)
4045 /* ??? In theory we could look for functions for which we have
4046 generated unwind info via CFI directives, and those we have not.
4047 Those we have not could still get their unwind info from here.
4048 For now, do nothing if we've seen any CFI directives. Note that
4049 the above test will not trigger, as we've not emitted data yet. */
4050 if (all_fde_data
!= NULL
)
4053 /* Generate .eh_frame data for the unwind directives specified. */
4054 for (p
= all_frame_data
; p
; p
= p
->next
)
4055 if (p
->prologue_sym
)
4057 /* Create a temporary symbol at the same location as our
4058 function symbol. This prevents problems with globals. */
4059 cfi_new_fde (symbol_temp_new (S_GET_SEGMENT (p
->func_sym
),
4060 S_GET_VALUE (p
->func_sym
),
4061 symbol_get_frag (p
->func_sym
)));
4063 cfi_set_return_column (p
->ra_regno
);
4064 cfi_add_CFA_def_cfa_register (30);
4065 if (p
->fp_regno
!= 30 || p
->mask
|| p
->fmask
|| p
->frame_size
)
4070 cfi_add_advance_loc (p
->prologue_sym
);
4072 if (p
->fp_regno
!= 30)
4073 if (p
->frame_size
!= 0)
4074 cfi_add_CFA_def_cfa (p
->fp_regno
, p
->frame_size
);
4076 cfi_add_CFA_def_cfa_register (p
->fp_regno
);
4077 else if (p
->frame_size
!= 0)
4078 cfi_add_CFA_def_cfa_offset (p
->frame_size
);
4081 offset
= p
->mask_offset
;
4083 /* Recall that $26 is special-cased and stored first. */
4084 if ((mask
>> 26) & 1)
4086 cfi_add_CFA_offset (26, offset
);
4097 cfi_add_CFA_offset (i
, offset
);
4102 offset
= p
->fmask_offset
;
4110 cfi_add_CFA_offset (i
+ 32, offset
);
4115 cfi_end_fde (p
->func_end_sym
);
4120 s_alpha_usepv (int unused ATTRIBUTE_UNUSED
)
4122 char *name
, name_end
;
4123 char *which
, which_end
;
4127 name
= input_line_pointer
;
4128 name_end
= get_symbol_end ();
4130 if (! is_name_beginner (*name
))
4132 as_bad (_(".usepv directive has no name"));
4133 *input_line_pointer
= name_end
;
4134 ignore_rest_of_line ();
4138 sym
= symbol_find_or_make (name
);
4139 *input_line_pointer
++ = name_end
;
4141 if (name_end
!= ',')
4143 as_bad (_(".usepv directive has no type"));
4144 ignore_rest_of_line ();
4149 which
= input_line_pointer
;
4150 which_end
= get_symbol_end ();
4152 if (strcmp (which
, "no") == 0)
4153 other
= STO_ALPHA_NOPV
;
4154 else if (strcmp (which
, "std") == 0)
4155 other
= STO_ALPHA_STD_GPLOAD
;
4158 as_bad (_("unknown argument for .usepv"));
4162 *input_line_pointer
= which_end
;
4163 demand_empty_rest_of_line ();
4165 S_SET_OTHER (sym
, other
| (S_GET_OTHER (sym
) & ~STO_ALPHA_STD_GPLOAD
));
4167 #endif /* OBJ_ELF */
4169 /* Standard calling conventions leaves the CFA at $30 on entry. */
4172 alpha_cfi_frame_initial_instructions (void)
4174 cfi_add_CFA_def_cfa_register (30);
4179 /* Get name of section. */
4181 s_alpha_section_name (void)
4186 if (*input_line_pointer
== '"')
4190 name
= demand_copy_C_string (&dummy
);
4193 ignore_rest_of_line ();
4199 char *end
= input_line_pointer
;
4201 while (0 == strchr ("\n\t,; ", *end
))
4203 if (end
== input_line_pointer
)
4205 as_warn (_("missing name"));
4206 ignore_rest_of_line ();
4210 name
= xmalloc (end
- input_line_pointer
+ 1);
4211 memcpy (name
, input_line_pointer
, end
- input_line_pointer
);
4212 name
[end
- input_line_pointer
] = '\0';
4213 input_line_pointer
= end
;
4219 /* Put clear/set flags in one flagword. The LSBs are flags to be set,
4220 the MSBs are the flags to be cleared. */
4222 #define EGPS__V_NO_SHIFT 16
4223 #define EGPS__V_MASK 0xffff
4225 /* Parse one VMS section flag. */
4228 s_alpha_section_word (char *str
, size_t len
)
4233 if (len
== 5 && strncmp (str
, "NO", 2) == 0)
4242 if (strncmp (str
, "PIC", 3) == 0)
4244 else if (strncmp (str
, "LIB", 3) == 0)
4246 else if (strncmp (str
, "OVR", 3) == 0)
4248 else if (strncmp (str
, "REL", 3) == 0)
4250 else if (strncmp (str
, "GBL", 3) == 0)
4252 else if (strncmp (str
, "SHR", 3) == 0)
4254 else if (strncmp (str
, "EXE", 3) == 0)
4256 else if (strncmp (str
, "WRT", 3) == 0)
4258 else if (strncmp (str
, "VEC", 3) == 0)
4260 else if (strncmp (str
, "MOD", 3) == 0)
4262 flag
= no
? EGPS__V_NOMOD
: EGPS__V_NOMOD
<< EGPS__V_NO_SHIFT
;
4265 else if (strncmp (str
, "COM", 3) == 0)
4273 as_warn (_("unknown section attribute %s"), str
);
4279 return flag
<< EGPS__V_NO_SHIFT
;
4284 /* Handle the section specific pseudo-op. */
4286 #define EVAX_SECTION_COUNT 5
4288 static char *section_name
[EVAX_SECTION_COUNT
+ 1] =
4289 { "NULL", ".rdata", ".comm", ".link", ".ctors", ".dtors" };
4292 s_alpha_section (int secid
)
4296 flagword vms_flags
= 0;
4301 name
= s_alpha_section_name ();
4304 sec
= subseg_new (name
, 0);
4305 if (*input_line_pointer
== ',')
4307 /* Skip the comma. */
4308 ++input_line_pointer
;
4316 beg
= input_line_pointer
;
4317 c
= get_symbol_end ();
4318 *input_line_pointer
= c
;
4320 vms_flags
|= s_alpha_section_word (beg
, input_line_pointer
- beg
);
4324 while (*input_line_pointer
++ == ',');
4325 --input_line_pointer
;
4328 symbol
= symbol_find_or_make (name
);
4329 S_SET_SEGMENT (symbol
, sec
);
4330 symbol_get_bfdsym (symbol
)->flags
|= BSF_SECTION_SYM
;
4331 bfd_vms_set_section_flags
4333 (vms_flags
>> EGPS__V_NO_SHIFT
) & EGPS__V_MASK
,
4334 vms_flags
& EGPS__V_MASK
);
4338 get_absolute_expression ();
4339 subseg_new (section_name
[secid
], 0);
4342 demand_empty_rest_of_line ();
4343 alpha_insn_label
= NULL
;
4344 alpha_auto_align_on
= 1;
4345 alpha_current_align
= 0;
4349 s_alpha_literals (int ignore ATTRIBUTE_UNUSED
)
4351 subseg_new (".literals", 0);
4352 demand_empty_rest_of_line ();
4353 alpha_insn_label
= NULL
;
4354 alpha_auto_align_on
= 1;
4355 alpha_current_align
= 0;
4358 /* Parse .ent directives. */
4361 s_alpha_ent (int ignore ATTRIBUTE_UNUSED
)
4364 expressionS symexpr
;
4366 if (alpha_evax_proc
!= NULL
)
4367 as_bad (_("previous .ent not closed by a .end"));
4369 alpha_evax_proc
= &alpha_evax_proc_data
;
4371 alpha_evax_proc
->pdsckind
= 0;
4372 alpha_evax_proc
->framereg
= -1;
4373 alpha_evax_proc
->framesize
= 0;
4374 alpha_evax_proc
->rsa_offset
= 0;
4375 alpha_evax_proc
->ra_save
= AXP_REG_RA
;
4376 alpha_evax_proc
->fp_save
= -1;
4377 alpha_evax_proc
->imask
= 0;
4378 alpha_evax_proc
->fmask
= 0;
4379 alpha_evax_proc
->prologue
= 0;
4380 alpha_evax_proc
->type
= 0;
4381 alpha_evax_proc
->handler
= 0;
4382 alpha_evax_proc
->handler_data
= 0;
4384 expression (&symexpr
);
4386 if (symexpr
.X_op
!= O_symbol
)
4388 as_fatal (_(".ent directive has no symbol"));
4389 demand_empty_rest_of_line ();
4393 symbol
= make_expr_symbol (&symexpr
);
4394 symbol_get_bfdsym (symbol
)->flags
|= BSF_FUNCTION
;
4395 alpha_evax_proc
->symbol
= symbol
;
4397 demand_empty_rest_of_line ();
4401 s_alpha_handler (int is_data
)
4404 alpha_evax_proc
->handler_data
= get_absolute_expression ();
4407 char *name
, name_end
;
4408 name
= input_line_pointer
;
4409 name_end
= get_symbol_end ();
4411 if (! is_name_beginner (*name
))
4413 as_warn (_(".handler directive has no name"));
4414 *input_line_pointer
= name_end
;
4420 sym
= symbol_find_or_make (name
);
4421 symbol_get_bfdsym (sym
)->flags
|= BSF_FUNCTION
;
4422 alpha_evax_proc
->handler
= sym
;
4423 *input_line_pointer
= name_end
;
4426 demand_empty_rest_of_line ();
4429 /* Parse .frame <framreg>,<framesize>,RA,<rsa_offset> directives. */
4432 s_alpha_frame (int ignore ATTRIBUTE_UNUSED
)
4436 alpha_evax_proc
->framereg
= tc_get_register (1);
4439 if (*input_line_pointer
++ != ','
4440 || get_absolute_expression_and_terminator (&val
) != ',')
4442 as_warn (_("Bad .frame directive 1./2. param"));
4443 --input_line_pointer
;
4444 demand_empty_rest_of_line ();
4448 alpha_evax_proc
->framesize
= val
;
4450 (void) tc_get_register (1);
4452 if (*input_line_pointer
++ != ',')
4454 as_warn (_("Bad .frame directive 3./4. param"));
4455 --input_line_pointer
;
4456 demand_empty_rest_of_line ();
4459 alpha_evax_proc
->rsa_offset
= get_absolute_expression ();
4462 /* Parse .prologue. */
4465 s_alpha_prologue (int ignore ATTRIBUTE_UNUSED
)
4467 get_absolute_expression ();
4468 demand_empty_rest_of_line ();
4469 alpha_prologue_label
= symbol_new
4470 (FAKE_LABEL_NAME
, now_seg
, (valueT
) frag_now_fix (), frag_now
);
4473 /* Parse .pdesc <entry_name>.
4474 Insert a procedure descriptor. */
4477 s_alpha_pdesc (int ignore ATTRIBUTE_UNUSED
)
4484 const char *entry_sym_name
;
4485 const char *pdesc_sym_name
;
4489 if (now_seg
!= alpha_link_section
)
4491 as_bad (_(".pdesc directive not in link (.link) section"));
4496 if (exp
.X_op
!= O_symbol
)
4498 as_bad (_(".pdesc directive has no entry symbol"));
4502 entry_sym
= make_expr_symbol (&exp
);
4503 entry_sym_name
= S_GET_NAME (entry_sym
);
4506 len
= strlen (entry_sym_name
);
4507 if (len
< 4 || strcmp (entry_sym_name
+ len
- 4, "..en") != 0)
4509 as_bad (_(".pdesc has a bad entry symbol"));
4513 pdesc_sym_name
= S_GET_NAME (alpha_evax_proc
->symbol
);
4515 if (!alpha_evax_proc
4516 || !S_IS_DEFINED (alpha_evax_proc
->symbol
)
4517 || strlen (pdesc_sym_name
) != len
4518 || memcmp (entry_sym_name
, pdesc_sym_name
, len
) != 0)
4520 as_fatal (_(".pdesc doesn't match with last .ent"));
4524 /* Define pdesc symbol. */
4525 symbol_set_value_now (alpha_evax_proc
->symbol
);
4527 /* Save bfd symbol of proc entry in function symbol. */
4528 ((struct evax_private_udata_struct
*)
4529 symbol_get_bfdsym (alpha_evax_proc
->symbol
)->udata
.p
)->enbsym
4530 = symbol_get_bfdsym (entry_sym
);
4533 if (*input_line_pointer
++ != ',')
4535 as_warn (_("No comma after .pdesc <entryname>"));
4536 demand_empty_rest_of_line ();
4541 name
= input_line_pointer
;
4542 name_end
= get_symbol_end ();
4544 if (strncmp (name
, "stack", 5) == 0)
4545 alpha_evax_proc
->pdsckind
= PDSC_S_K_KIND_FP_STACK
;
4547 else if (strncmp (name
, "reg", 3) == 0)
4548 alpha_evax_proc
->pdsckind
= PDSC_S_K_KIND_FP_REGISTER
;
4550 else if (strncmp (name
, "null", 4) == 0)
4551 alpha_evax_proc
->pdsckind
= PDSC_S_K_KIND_NULL
;
4555 as_fatal (_("unknown procedure kind"));
4556 demand_empty_rest_of_line ();
4560 *input_line_pointer
= name_end
;
4561 demand_empty_rest_of_line ();
4563 #ifdef md_flush_pending_output
4564 md_flush_pending_output ();
4567 frag_align (3, 0, 0);
4569 fixp
= fix_new (frag_now
, p
- frag_now
->fr_literal
, 8, 0, 0, 0, 0);
4572 *p
= alpha_evax_proc
->pdsckind
4573 | ((alpha_evax_proc
->framereg
== 29) ? PDSC_S_M_BASE_REG_IS_FP
: 0)
4574 | ((alpha_evax_proc
->handler
) ? PDSC_S_M_HANDLER_VALID
: 0)
4575 | ((alpha_evax_proc
->handler_data
) ? PDSC_S_M_HANDLER_DATA_VALID
: 0);
4576 *(p
+ 1) = PDSC_S_M_NATIVE
| PDSC_S_M_NO_JACKET
;
4578 switch (alpha_evax_proc
->pdsckind
)
4580 case PDSC_S_K_KIND_NULL
:
4584 case PDSC_S_K_KIND_FP_REGISTER
:
4585 *(p
+ 2) = alpha_evax_proc
->fp_save
;
4586 *(p
+ 3) = alpha_evax_proc
->ra_save
;
4588 case PDSC_S_K_KIND_FP_STACK
:
4589 md_number_to_chars (p
+ 2, (valueT
) alpha_evax_proc
->rsa_offset
, 2);
4591 default: /* impossible */
4596 *(p
+ 5) = alpha_evax_proc
->type
& 0x0f;
4598 /* Signature offset. */
4599 md_number_to_chars (p
+ 6, (valueT
) 0, 2);
4601 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ 8,
4602 8, &exp
, 0, BFD_RELOC_64
);
4604 if (alpha_evax_proc
->pdsckind
== PDSC_S_K_KIND_NULL
)
4607 /* pdesc+16: Size. */
4609 md_number_to_chars (p
, (valueT
) alpha_evax_proc
->framesize
, 4);
4610 md_number_to_chars (p
+ 4, (valueT
) 0, 2);
4613 exp
.X_op
= O_subtract
;
4614 exp
.X_add_symbol
= alpha_prologue_label
;
4615 exp
.X_op_symbol
= entry_sym
;
4616 emit_expr (&exp
, 2);
4618 if (alpha_evax_proc
->pdsckind
== PDSC_S_K_KIND_FP_REGISTER
)
4621 /* pdesc+24: register masks. */
4623 md_number_to_chars (p
, alpha_evax_proc
->imask
, 4);
4624 md_number_to_chars (p
+ 4, alpha_evax_proc
->fmask
, 4);
4626 if (alpha_evax_proc
->handler
)
4629 fixp
= fix_new (frag_now
, p
- frag_now
->fr_literal
, 8,
4630 alpha_evax_proc
->handler
, 0, 0, BFD_RELOC_64
);
4633 if (alpha_evax_proc
->handler_data
)
4636 md_number_to_chars (p
, alpha_evax_proc
->handler_data
, 8);
4640 /* Support for crash debug on vms. */
4643 s_alpha_name (int ignore ATTRIBUTE_UNUSED
)
4648 if (now_seg
!= alpha_link_section
)
4650 as_bad (_(".name directive not in link (.link) section"));
4651 demand_empty_rest_of_line ();
4656 if (exp
.X_op
!= O_symbol
)
4658 as_warn (_(".name directive has no symbol"));
4659 demand_empty_rest_of_line ();
4663 demand_empty_rest_of_line ();
4665 #ifdef md_flush_pending_output
4666 md_flush_pending_output ();
4669 frag_align (3, 0, 0);
4672 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 8, &exp
, 0, BFD_RELOC_64
);
4675 /* Parse .linkage <symbol>.
4676 Create a linkage pair relocation. */
4679 s_alpha_linkage (int ignore ATTRIBUTE_UNUSED
)
4685 #ifdef md_flush_pending_output
4686 md_flush_pending_output ();
4690 if (exp
.X_op
!= O_symbol
)
4692 as_fatal (_("No symbol after .linkage"));
4696 struct alpha_linkage_fixups
*linkage_fixup
;
4698 p
= frag_more (LKP_S_K_SIZE
);
4699 memset (p
, 0, LKP_S_K_SIZE
);
4701 (frag_now
, p
- frag_now
->fr_literal
, LKP_S_K_SIZE
, &exp
, 0,\
4702 BFD_RELOC_ALPHA_LINKAGE
);
4704 linkage_fixup
= (struct alpha_linkage_fixups
*)
4705 xmalloc (sizeof (struct alpha_linkage_fixups
));
4707 linkage_fixup
->fixp
= fixp
;
4708 linkage_fixup
->next
= 0;
4710 if (alpha_insn_label
== 0)
4711 alpha_insn_label
= symbol_new
4712 (FAKE_LABEL_NAME
, now_seg
, (valueT
) frag_now_fix (), frag_now
);
4713 linkage_fixup
->label
= alpha_insn_label
;
4715 if (alpha_linkage_fixup_root
== 0)
4717 alpha_linkage_fixup_root
= alpha_linkage_fixup_tail
= linkage_fixup
;
4718 alpha_linkage_fixup_tail
->next
= 0;
4722 alpha_linkage_fixup_tail
->next
= linkage_fixup
;
4723 alpha_linkage_fixup_tail
= linkage_fixup
;
4724 alpha_linkage_fixup_tail
->next
= 0;
4727 demand_empty_rest_of_line ();
4730 /* Parse .code_address <symbol>.
4731 Create a code address relocation. */
4734 s_alpha_code_address (int ignore ATTRIBUTE_UNUSED
)
4739 #ifdef md_flush_pending_output
4740 md_flush_pending_output ();
4744 if (exp
.X_op
!= O_symbol
)
4745 as_fatal (_("No symbol after .code_address"));
4750 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 8, &exp
, 0,\
4751 BFD_RELOC_ALPHA_CODEADDR
);
4753 demand_empty_rest_of_line ();
4757 s_alpha_fp_save (int ignore ATTRIBUTE_UNUSED
)
4760 alpha_evax_proc
->fp_save
= tc_get_register (1);
4762 demand_empty_rest_of_line ();
4766 s_alpha_mask (int ignore ATTRIBUTE_UNUSED
)
4770 if (get_absolute_expression_and_terminator (&val
) != ',')
4772 as_warn (_("Bad .mask directive"));
4773 --input_line_pointer
;
4777 alpha_evax_proc
->imask
= val
;
4778 (void) get_absolute_expression ();
4780 demand_empty_rest_of_line ();
4784 s_alpha_fmask (int ignore ATTRIBUTE_UNUSED
)
4788 if (get_absolute_expression_and_terminator (&val
) != ',')
4790 as_warn (_("Bad .fmask directive"));
4791 --input_line_pointer
;
4795 alpha_evax_proc
->fmask
= val
;
4796 (void) get_absolute_expression ();
4798 demand_empty_rest_of_line ();
4802 s_alpha_end (int ignore ATTRIBUTE_UNUSED
)
4806 c
= get_symbol_end ();
4807 *input_line_pointer
= c
;
4808 demand_empty_rest_of_line ();
4809 alpha_evax_proc
= NULL
;
4813 s_alpha_file (int ignore ATTRIBUTE_UNUSED
)
4817 static char case_hack
[32];
4819 sprintf (case_hack
, "<CASE:%01d%01d>",
4820 alpha_flag_hash_long_names
, alpha_flag_show_after_trunc
);
4822 s
= symbol_find_or_make (case_hack
);
4823 symbol_get_bfdsym (s
)->flags
|= BSF_FILE
;
4825 get_absolute_expression ();
4826 s
= symbol_find_or_make (demand_copy_string (&length
));
4827 symbol_get_bfdsym (s
)->flags
|= BSF_FILE
;
4828 demand_empty_rest_of_line ();
4830 #endif /* OBJ_EVAX */
4832 /* Handle the .gprel32 pseudo op. */
4835 s_alpha_gprel32 (int ignore ATTRIBUTE_UNUSED
)
4847 e
.X_add_symbol
= section_symbol (absolute_section
);
4860 e
.X_add_symbol
= section_symbol (absolute_section
);
4863 e
.X_op
= O_subtract
;
4864 e
.X_op_symbol
= alpha_gp_symbol
;
4872 if (alpha_auto_align_on
&& alpha_current_align
< 2)
4873 alpha_align (2, (char *) NULL
, alpha_insn_label
, 0);
4874 if (alpha_current_align
> 2)
4875 alpha_current_align
= 2;
4876 alpha_insn_label
= NULL
;
4880 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 4,
4881 &e
, 0, BFD_RELOC_GPREL32
);
4884 /* Handle floating point allocation pseudo-ops. This is like the
4885 generic vresion, but it makes sure the current label, if any, is
4886 correctly aligned. */
4889 s_alpha_float_cons (int type
)
4915 if (alpha_auto_align_on
&& alpha_current_align
< log_size
)
4916 alpha_align (log_size
, (char *) NULL
, alpha_insn_label
, 0);
4917 if (alpha_current_align
> log_size
)
4918 alpha_current_align
= log_size
;
4919 alpha_insn_label
= NULL
;
4924 /* Handle the .proc pseudo op. We don't really do much with it except
4928 s_alpha_proc (int is_static ATTRIBUTE_UNUSED
)
4936 /* Takes ".proc name,nargs". */
4938 name
= input_line_pointer
;
4939 c
= get_symbol_end ();
4940 p
= input_line_pointer
;
4941 symbolP
= symbol_find_or_make (name
);
4944 if (*input_line_pointer
!= ',')
4947 as_warn (_("Expected comma after name \"%s\""), name
);
4950 ignore_rest_of_line ();
4954 input_line_pointer
++;
4955 temp
= get_absolute_expression ();
4957 /* *symbol_get_obj (symbolP) = (signed char) temp; */
4959 as_warn (_("unhandled: .proc %s,%d"), name
, temp
);
4960 demand_empty_rest_of_line ();
4963 /* Handle the .set pseudo op. This is used to turn on and off most of
4964 the assembler features. */
4967 s_alpha_set (int x ATTRIBUTE_UNUSED
)
4973 name
= input_line_pointer
;
4974 ch
= get_symbol_end ();
4977 if (s
[0] == 'n' && s
[1] == 'o')
4982 if (!strcmp ("reorder", s
))
4984 else if (!strcmp ("at", s
))
4985 alpha_noat_on
= !yesno
;
4986 else if (!strcmp ("macro", s
))
4987 alpha_macros_on
= yesno
;
4988 else if (!strcmp ("move", s
))
4990 else if (!strcmp ("volatile", s
))
4993 as_warn (_("Tried to .set unrecognized mode `%s'"), name
);
4995 *input_line_pointer
= ch
;
4996 demand_empty_rest_of_line ();
4999 /* Handle the .base pseudo op. This changes the assembler's notion of
5000 the $gp register. */
5003 s_alpha_base (int ignore ATTRIBUTE_UNUSED
)
5007 if (*input_line_pointer
== '$')
5010 input_line_pointer
++;
5011 if (*input_line_pointer
== 'r')
5012 input_line_pointer
++;
5015 alpha_gp_register
= get_absolute_expression ();
5016 if (alpha_gp_register
< 0 || alpha_gp_register
> 31)
5018 alpha_gp_register
= AXP_REG_GP
;
5019 as_warn (_("Bad base register, using $%d."), alpha_gp_register
);
5022 demand_empty_rest_of_line ();
5025 /* Handle the .align pseudo-op. This aligns to a power of two. It
5026 also adjusts any current instruction label. We treat this the same
5027 way the MIPS port does: .align 0 turns off auto alignment. */
5030 s_alpha_align (int ignore ATTRIBUTE_UNUSED
)
5034 long max_alignment
= 16;
5036 align
= get_absolute_expression ();
5037 if (align
> max_alignment
)
5039 align
= max_alignment
;
5040 as_bad (_("Alignment too large: %d. assumed"), align
);
5044 as_warn (_("Alignment negative: 0 assumed"));
5048 if (*input_line_pointer
== ',')
5050 input_line_pointer
++;
5051 fill
= get_absolute_expression ();
5059 alpha_auto_align_on
= 1;
5060 alpha_align (align
, pfill
, NULL
, 1);
5064 alpha_auto_align_on
= 0;
5066 alpha_insn_label
= NULL
;
5068 demand_empty_rest_of_line ();
5071 /* Hook the normal string processor to reset known alignment. */
5074 s_alpha_stringer (int terminate
)
5076 alpha_current_align
= 0;
5077 alpha_insn_label
= NULL
;
5078 stringer (8 + terminate
);
5081 /* Hook the normal space processing to reset known alignment. */
5084 s_alpha_space (int ignore
)
5086 alpha_current_align
= 0;
5087 alpha_insn_label
= NULL
;
5091 /* Hook into cons for auto-alignment. */
5094 alpha_cons_align (int size
)
5099 while ((size
>>= 1) != 0)
5102 if (alpha_auto_align_on
&& alpha_current_align
< log_size
)
5103 alpha_align (log_size
, (char *) NULL
, alpha_insn_label
, 0);
5104 if (alpha_current_align
> log_size
)
5105 alpha_current_align
= log_size
;
5106 alpha_insn_label
= NULL
;
5109 /* Here come the .uword, .ulong, and .uquad explicitly unaligned
5110 pseudos. We just turn off auto-alignment and call down to cons. */
5113 s_alpha_ucons (int bytes
)
5115 int hold
= alpha_auto_align_on
;
5116 alpha_auto_align_on
= 0;
5118 alpha_auto_align_on
= hold
;
5121 /* Switch the working cpu type. */
5124 s_alpha_arch (int ignored ATTRIBUTE_UNUSED
)
5127 const struct cpu_type
*p
;
5130 name
= input_line_pointer
;
5131 ch
= get_symbol_end ();
5133 for (p
= cpu_types
; p
->name
; ++p
)
5134 if (strcmp (name
, p
->name
) == 0)
5136 alpha_target_name
= p
->name
, alpha_target
= p
->flags
;
5139 as_warn (_("Unknown CPU identifier `%s'"), name
);
5142 *input_line_pointer
= ch
;
5143 demand_empty_rest_of_line ();
5147 /* print token expression with alpha specific extension. */
5150 alpha_print_token (FILE *f
, const expressionS
*exp
)
5160 expressionS nexp
= *exp
;
5161 nexp
.X_op
= O_register
;
5162 print_expr_1 (f
, &nexp
);
5167 print_expr_1 (f
, exp
);
5173 /* The target specific pseudo-ops which we support. */
5175 const pseudo_typeS md_pseudo_table
[] =
5178 {"comm", s_alpha_comm
, 0}, /* OSF1 compiler does this. */
5179 {"rdata", s_alpha_rdata
, 0},
5181 {"text", s_alpha_text
, 0},
5182 {"data", s_alpha_data
, 0},
5184 {"sdata", s_alpha_sdata
, 0},
5187 {"section", s_alpha_section
, 0},
5188 {"section.s", s_alpha_section
, 0},
5189 {"sect", s_alpha_section
, 0},
5190 {"sect.s", s_alpha_section
, 0},
5193 {"section", s_alpha_section
, 0},
5194 {"literals", s_alpha_literals
, 0},
5195 {"pdesc", s_alpha_pdesc
, 0},
5196 {"name", s_alpha_name
, 0},
5197 {"linkage", s_alpha_linkage
, 0},
5198 {"code_address", s_alpha_code_address
, 0},
5199 {"ent", s_alpha_ent
, 0},
5200 {"frame", s_alpha_frame
, 0},
5201 {"fp_save", s_alpha_fp_save
, 0},
5202 {"mask", s_alpha_mask
, 0},
5203 {"fmask", s_alpha_fmask
, 0},
5204 {"end", s_alpha_end
, 0},
5205 {"file", s_alpha_file
, 0},
5206 {"rdata", s_alpha_section
, 1},
5207 {"comm", s_alpha_comm
, 0},
5208 {"link", s_alpha_section
, 3},
5209 {"ctors", s_alpha_section
, 4},
5210 {"dtors", s_alpha_section
, 5},
5211 {"handler", s_alpha_handler
, 0},
5212 {"handler_data", s_alpha_handler
, 1},
5215 /* Frame related pseudos. */
5216 {"ent", s_alpha_ent
, 0},
5217 {"end", s_alpha_end
, 0},
5218 {"mask", s_alpha_mask
, 0},
5219 {"fmask", s_alpha_mask
, 1},
5220 {"frame", s_alpha_frame
, 0},
5221 {"prologue", s_alpha_prologue
, 0},
5222 {"file", s_alpha_file
, 5},
5223 {"loc", s_alpha_loc
, 9},
5224 {"stabs", s_alpha_stab
, 's'},
5225 {"stabn", s_alpha_stab
, 'n'},
5226 {"usepv", s_alpha_usepv
, 0},
5227 /* COFF debugging related pseudos. */
5228 {"begin", s_alpha_coff_wrapper
, 0},
5229 {"bend", s_alpha_coff_wrapper
, 1},
5230 {"def", s_alpha_coff_wrapper
, 2},
5231 {"dim", s_alpha_coff_wrapper
, 3},
5232 {"endef", s_alpha_coff_wrapper
, 4},
5233 {"scl", s_alpha_coff_wrapper
, 5},
5234 {"tag", s_alpha_coff_wrapper
, 6},
5235 {"val", s_alpha_coff_wrapper
, 7},
5238 {"prologue", s_alpha_prologue
, 0},
5240 {"prologue", s_ignore
, 0},
5243 {"gprel32", s_alpha_gprel32
, 0},
5244 {"t_floating", s_alpha_float_cons
, 'd'},
5245 {"s_floating", s_alpha_float_cons
, 'f'},
5246 {"f_floating", s_alpha_float_cons
, 'F'},
5247 {"g_floating", s_alpha_float_cons
, 'G'},
5248 {"d_floating", s_alpha_float_cons
, 'D'},
5250 {"proc", s_alpha_proc
, 0},
5251 {"aproc", s_alpha_proc
, 1},
5252 {"set", s_alpha_set
, 0},
5253 {"reguse", s_ignore
, 0},
5254 {"livereg", s_ignore
, 0},
5255 {"base", s_alpha_base
, 0}, /*??*/
5256 {"option", s_ignore
, 0},
5257 {"aent", s_ignore
, 0},
5258 {"ugen", s_ignore
, 0},
5259 {"eflag", s_ignore
, 0},
5261 {"align", s_alpha_align
, 0},
5262 {"double", s_alpha_float_cons
, 'd'},
5263 {"float", s_alpha_float_cons
, 'f'},
5264 {"single", s_alpha_float_cons
, 'f'},
5265 {"ascii", s_alpha_stringer
, 0},
5266 {"asciz", s_alpha_stringer
, 1},
5267 {"string", s_alpha_stringer
, 1},
5268 {"space", s_alpha_space
, 0},
5269 {"skip", s_alpha_space
, 0},
5270 {"zero", s_alpha_space
, 0},
5272 /* Unaligned data pseudos. */
5273 {"uword", s_alpha_ucons
, 2},
5274 {"ulong", s_alpha_ucons
, 4},
5275 {"uquad", s_alpha_ucons
, 8},
5278 /* Dwarf wants these versions of unaligned. */
5279 {"2byte", s_alpha_ucons
, 2},
5280 {"4byte", s_alpha_ucons
, 4},
5281 {"8byte", s_alpha_ucons
, 8},
5284 /* We don't do any optimizing, so we can safely ignore these. */
5285 {"noalias", s_ignore
, 0},
5286 {"alias", s_ignore
, 0},
5288 {"arch", s_alpha_arch
, 0},
5295 /* @@@ GP selection voodoo. All of this seems overly complicated and
5296 unnecessary; which is the primary reason it's for ECOFF only. */
5299 maybe_set_gp (asection
*sec
)
5305 vma
= bfd_get_section_vma (foo
, sec
);
5306 if (vma
&& vma
< alpha_gp_value
)
5307 alpha_gp_value
= vma
;
5311 select_gp_value (void)
5313 gas_assert (alpha_gp_value
== 0);
5315 /* Get minus-one in whatever width... */
5319 /* Select the smallest VMA of these existing sections. */
5320 maybe_set_gp (alpha_lita_section
);
5322 /* @@ Will a simple 0x8000 work here? If not, why not? */
5323 #define GP_ADJUSTMENT (0x8000 - 0x10)
5325 alpha_gp_value
+= GP_ADJUSTMENT
;
5327 S_SET_VALUE (alpha_gp_symbol
, alpha_gp_value
);
5330 printf (_("Chose GP value of %lx\n"), alpha_gp_value
);
5333 #endif /* OBJ_ECOFF */
5336 /* Map 's' to SHF_ALPHA_GPREL. */
5339 alpha_elf_section_letter (int letter
, char **ptr_msg
)
5342 return SHF_ALPHA_GPREL
;
5344 *ptr_msg
= _("bad .section directive: want a,s,w,x,M,S,G,T in string");
5348 /* Map SHF_ALPHA_GPREL to SEC_SMALL_DATA. */
5351 alpha_elf_section_flags (flagword flags
, bfd_vma attr
, int type ATTRIBUTE_UNUSED
)
5353 if (attr
& SHF_ALPHA_GPREL
)
5354 flags
|= SEC_SMALL_DATA
;
5357 #endif /* OBJ_ELF */
5359 /* This is called from HANDLE_ALIGN in write.c. Fill in the contents
5360 of an rs_align_code fragment. */
5363 alpha_handle_align (fragS
*fragp
)
5365 static char const unop
[4] = { 0x00, 0x00, 0xfe, 0x2f };
5366 static char const nopunop
[8] =
5368 0x1f, 0x04, 0xff, 0x47,
5369 0x00, 0x00, 0xfe, 0x2f
5375 if (fragp
->fr_type
!= rs_align_code
)
5378 bytes
= fragp
->fr_next
->fr_address
- fragp
->fr_address
- fragp
->fr_fix
;
5379 p
= fragp
->fr_literal
+ fragp
->fr_fix
;
5392 memcpy (p
, unop
, 4);
5398 memcpy (p
, nopunop
, 8);
5400 fragp
->fr_fix
+= fix
;
5404 /* Public interface functions. */
5406 /* This function is called once, at assembler startup time. It sets
5407 up all the tables, etc. that the MD part of the assembler will
5408 need, that can be determined before arguments are parsed. */
5415 /* Verify that X_op field is wide enough. */
5420 gas_assert (e
.X_op
== O_max
);
5423 /* Create the opcode hash table. */
5424 alpha_opcode_hash
= hash_new ();
5426 for (i
= 0; i
< alpha_num_opcodes
;)
5428 const char *name
, *retval
, *slash
;
5430 name
= alpha_opcodes
[i
].name
;
5431 retval
= hash_insert (alpha_opcode_hash
, name
, (void *) &alpha_opcodes
[i
]);
5433 as_fatal (_("internal error: can't hash opcode `%s': %s"),
5436 /* Some opcodes include modifiers of various sorts with a "/mod"
5437 syntax, like the architecture manual suggests. However, for
5438 use with gcc at least, we also need access to those same opcodes
5441 if ((slash
= strchr (name
, '/')) != NULL
)
5443 char *p
= (char *) xmalloc (strlen (name
));
5445 memcpy (p
, name
, slash
- name
);
5446 strcpy (p
+ (slash
- name
), slash
+ 1);
5448 (void) hash_insert (alpha_opcode_hash
, p
, (void *) &alpha_opcodes
[i
]);
5449 /* Ignore failures -- the opcode table does duplicate some
5450 variants in different forms, like "hw_stq" and "hw_st/q". */
5453 while (++i
< alpha_num_opcodes
5454 && (alpha_opcodes
[i
].name
== name
5455 || !strcmp (alpha_opcodes
[i
].name
, name
)))
5459 /* Create the macro hash table. */
5460 alpha_macro_hash
= hash_new ();
5462 for (i
= 0; i
< alpha_num_macros
;)
5464 const char *name
, *retval
;
5466 name
= alpha_macros
[i
].name
;
5467 retval
= hash_insert (alpha_macro_hash
, name
, (void *) &alpha_macros
[i
]);
5469 as_fatal (_("internal error: can't hash macro `%s': %s"),
5472 while (++i
< alpha_num_macros
5473 && (alpha_macros
[i
].name
== name
5474 || !strcmp (alpha_macros
[i
].name
, name
)))
5478 /* Construct symbols for each of the registers. */
5479 for (i
= 0; i
< 32; ++i
)
5483 sprintf (name
, "$%d", i
);
5484 alpha_register_table
[i
] = symbol_create (name
, reg_section
, i
,
5485 &zero_address_frag
);
5492 sprintf (name
, "$f%d", i
- 32);
5493 alpha_register_table
[i
] = symbol_create (name
, reg_section
, i
,
5494 &zero_address_frag
);
5497 /* Create the special symbols and sections we'll be using. */
5499 /* So .sbss will get used for tiny objects. */
5500 bfd_set_gp_size (stdoutput
, g_switch_value
);
5503 create_literal_section (".lita", &alpha_lita_section
, &alpha_lita_symbol
);
5505 /* For handling the GP, create a symbol that won't be output in the
5506 symbol table. We'll edit it out of relocs later. */
5507 alpha_gp_symbol
= symbol_create ("<GP value>", alpha_lita_section
, 0x8000,
5508 &zero_address_frag
);
5512 create_literal_section (".link", &alpha_link_section
, &alpha_link_symbol
);
5516 if (ECOFF_DEBUGGING
)
5518 segT sec
= subseg_new (".mdebug", (subsegT
) 0);
5519 bfd_set_section_flags (stdoutput
, sec
, SEC_HAS_CONTENTS
| SEC_READONLY
);
5520 bfd_set_section_alignment (stdoutput
, sec
, 3);
5524 /* Create literal lookup hash table. */
5525 alpha_literal_hash
= hash_new ();
5527 subseg_set (text_section
, 0);
5530 /* The public interface to the instruction assembler. */
5533 md_assemble (char *str
)
5535 /* Current maximum is 13. */
5537 expressionS tok
[MAX_INSN_ARGS
];
5541 /* Split off the opcode. */
5542 opnamelen
= strspn (str
, "abcdefghijklmnopqrstuvwxyz_/46819");
5543 trunclen
= (opnamelen
< sizeof (opname
) - 1
5545 : sizeof (opname
) - 1);
5546 memcpy (opname
, str
, trunclen
);
5547 opname
[trunclen
] = '\0';
5549 /* Tokenize the rest of the line. */
5550 if ((ntok
= tokenize_arguments (str
+ opnamelen
, tok
, MAX_INSN_ARGS
)) < 0)
5552 if (ntok
!= TOKENIZE_ERROR_REPORT
)
5553 as_bad (_("syntax error"));
5558 /* Finish it off. */
5559 assemble_tokens (opname
, tok
, ntok
, alpha_macros_on
);
5562 /* Round up a section's size to the appropriate boundary. */
5565 md_section_align (segT seg
, valueT size
)
5567 int align
= bfd_get_section_alignment (stdoutput
, seg
);
5568 valueT mask
= ((valueT
) 1 << align
) - 1;
5570 return (size
+ mask
) & ~mask
;
5573 /* Turn a string in input_line_pointer into a floating point constant
5574 of type TYPE, and store the appropriate bytes in *LITP. The number
5575 of LITTLENUMS emitted is stored in *SIZEP. An error message is
5576 returned, or NULL on OK. */
5579 md_atof (int type
, char *litP
, int *sizeP
)
5581 extern char *vax_md_atof (int, char *, int *);
5587 /* vax_md_atof() doesn't like "G" for some reason. */
5591 return vax_md_atof (type
, litP
, sizeP
);
5594 return ieee_md_atof (type
, litP
, sizeP
, FALSE
);
5598 /* Take care of the target-specific command-line options. */
5601 md_parse_option (int c
, char *arg
)
5606 alpha_nofloats_on
= 1;
5610 alpha_addr32_on
= 1;
5618 g_switch_value
= atoi (arg
);
5623 const struct cpu_type
*p
;
5625 for (p
= cpu_types
; p
->name
; ++p
)
5626 if (strcmp (arg
, p
->name
) == 0)
5628 alpha_target_name
= p
->name
, alpha_target
= p
->flags
;
5631 as_warn (_("Unknown CPU identifier `%s'"), arg
);
5637 case '+': /* For g++. Hash any name > 63 chars long. */
5638 alpha_flag_hash_long_names
= 1;
5641 case 'H': /* Show new symbol after hash truncation. */
5642 alpha_flag_show_after_trunc
= 1;
5645 case 'h': /* For gnu-c/vax compatibility. */
5648 case OPTION_REPLACE
:
5649 alpha_flag_replace
= 1;
5652 case OPTION_NOREPLACE
:
5653 alpha_flag_replace
= 0;
5658 alpha_flag_relax
= 1;
5663 alpha_flag_mdebug
= 1;
5665 case OPTION_NO_MDEBUG
:
5666 alpha_flag_mdebug
= 0;
5677 /* Print a description of the command-line options that we accept. */
5680 md_show_usage (FILE *stream
)
5684 -32addr treat addresses as 32-bit values\n\
5685 -F lack floating point instructions support\n\
5686 -mev4 | -mev45 | -mev5 | -mev56 | -mpca56 | -mev6 | -mev67 | -mev68 | -mall\n\
5687 specify variant of Alpha architecture\n\
5688 -m21064 | -m21066 | -m21164 | -m21164a | -m21164pc | -m21264 | -m21264a | -m21264b\n\
5689 these variants include PALcode opcodes\n"),
5694 -+ encode (don't truncate) names longer than 64 characters\n\
5695 -H show new symbol after hash truncation\n\
5696 -replace/-noreplace enable or disable the optimization of procedure calls\n"),
5701 /* Decide from what point a pc-relative relocation is relative to,
5702 relative to the pc-relative fixup. Er, relatively speaking. */
5705 md_pcrel_from (fixS
*fixP
)
5707 valueT addr
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
5709 switch (fixP
->fx_r_type
)
5711 case BFD_RELOC_23_PCREL_S2
:
5712 case BFD_RELOC_ALPHA_HINT
:
5713 case BFD_RELOC_ALPHA_BRSGP
:
5720 /* Attempt to simplify or even eliminate a fixup. The return value is
5721 ignored; perhaps it was once meaningful, but now it is historical.
5722 To indicate that a fixup has been eliminated, set fixP->fx_done.
5724 For ELF, here it is that we transform the GPDISP_HI16 reloc we used
5725 internally into the GPDISP reloc used externally. We had to do
5726 this so that we'd have the GPDISP_LO16 reloc as a tag to compute
5727 the distance to the "lda" instruction for setting the addend to
5731 md_apply_fix (fixS
*fixP
, valueT
* valP
, segT seg
)
5733 char * const fixpos
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5734 valueT value
= * valP
;
5735 unsigned image
, size
;
5737 switch (fixP
->fx_r_type
)
5739 /* The GPDISP relocations are processed internally with a symbol
5740 referring to the current function's section; we need to drop
5741 in a value which, when added to the address of the start of
5742 the function, gives the desired GP. */
5743 case BFD_RELOC_ALPHA_GPDISP_HI16
:
5745 fixS
*next
= fixP
->fx_next
;
5747 /* With user-specified !gpdisp relocations, we can be missing
5748 the matching LO16 reloc. We will have already issued an
5751 fixP
->fx_offset
= (next
->fx_frag
->fr_address
+ next
->fx_where
5752 - fixP
->fx_frag
->fr_address
- fixP
->fx_where
);
5754 value
= (value
- sign_extend_16 (value
)) >> 16;
5757 fixP
->fx_r_type
= BFD_RELOC_ALPHA_GPDISP
;
5761 case BFD_RELOC_ALPHA_GPDISP_LO16
:
5762 value
= sign_extend_16 (value
);
5763 fixP
->fx_offset
= 0;
5769 fixP
->fx_addsy
= section_symbol (seg
);
5770 md_number_to_chars (fixpos
, value
, 2);
5775 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
5781 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
5787 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
5791 if (fixP
->fx_pcrel
== 0 && fixP
->fx_addsy
== 0)
5793 md_number_to_chars (fixpos
, value
, size
);
5799 case BFD_RELOC_GPREL32
:
5800 gas_assert (fixP
->fx_subsy
== alpha_gp_symbol
);
5802 /* FIXME: inherited this obliviousness of `value' -- why? */
5803 md_number_to_chars (fixpos
, -alpha_gp_value
, 4);
5806 case BFD_RELOC_GPREL32
:
5808 case BFD_RELOC_GPREL16
:
5809 case BFD_RELOC_ALPHA_GPREL_HI16
:
5810 case BFD_RELOC_ALPHA_GPREL_LO16
:
5813 case BFD_RELOC_23_PCREL_S2
:
5814 if (fixP
->fx_pcrel
== 0 && fixP
->fx_addsy
== 0)
5816 image
= bfd_getl32 (fixpos
);
5817 image
= (image
& ~0x1FFFFF) | ((value
>> 2) & 0x1FFFFF);
5822 case BFD_RELOC_ALPHA_HINT
:
5823 if (fixP
->fx_pcrel
== 0 && fixP
->fx_addsy
== 0)
5825 image
= bfd_getl32 (fixpos
);
5826 image
= (image
& ~0x3FFF) | ((value
>> 2) & 0x3FFF);
5832 case BFD_RELOC_ALPHA_BRSGP
:
5835 case BFD_RELOC_ALPHA_TLSGD
:
5836 case BFD_RELOC_ALPHA_TLSLDM
:
5837 case BFD_RELOC_ALPHA_GOTDTPREL16
:
5838 case BFD_RELOC_ALPHA_DTPREL_HI16
:
5839 case BFD_RELOC_ALPHA_DTPREL_LO16
:
5840 case BFD_RELOC_ALPHA_DTPREL16
:
5841 case BFD_RELOC_ALPHA_GOTTPREL16
:
5842 case BFD_RELOC_ALPHA_TPREL_HI16
:
5843 case BFD_RELOC_ALPHA_TPREL_LO16
:
5844 case BFD_RELOC_ALPHA_TPREL16
:
5846 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
5851 case BFD_RELOC_ALPHA_LITERAL
:
5852 md_number_to_chars (fixpos
, value
, 2);
5855 case BFD_RELOC_ALPHA_ELF_LITERAL
:
5856 case BFD_RELOC_ALPHA_LITUSE
:
5857 case BFD_RELOC_ALPHA_LINKAGE
:
5858 case BFD_RELOC_ALPHA_CODEADDR
:
5862 case BFD_RELOC_ALPHA_NOP
:
5863 value
-= (8 + 4); /* PC-relative, base is jsr+4. */
5865 /* From B.4.5.2 of the OpenVMS Linker Utility Manual:
5866 "Finally, the ETIR$C_STC_BSR command passes the same address
5867 as ETIR$C_STC_NOP (so that they will fail or succeed together),
5868 and the same test is done again." */
5869 if (S_GET_SEGMENT (fixP
->fx_addsy
) == undefined_section
)
5871 fixP
->fx_addnumber
= -value
;
5875 if ((abs (value
) >> 2) & ~0xfffff)
5879 /* Change to a nop. */
5884 case BFD_RELOC_ALPHA_LDA
:
5885 /* fixup_segment sets fixP->fx_addsy to NULL when it can pre-compute
5886 the value for an O_subtract. */
5888 && S_GET_SEGMENT (fixP
->fx_addsy
) == undefined_section
)
5890 fixP
->fx_addnumber
= symbol_get_bfdsym (fixP
->fx_subsy
)->value
;
5894 if ((abs (value
)) & ~0x7fff)
5898 /* Change to an lda. */
5899 image
= 0x237B0000 | (value
& 0xFFFF);
5903 case BFD_RELOC_ALPHA_BSR
:
5904 case BFD_RELOC_ALPHA_BOH
:
5905 value
-= 4; /* PC-relative, base is jsr+4. */
5907 /* See comment in the BFD_RELOC_ALPHA_NOP case above. */
5908 if (S_GET_SEGMENT (fixP
->fx_addsy
) == undefined_section
)
5910 fixP
->fx_addnumber
= -value
;
5914 if ((abs (value
) >> 2) & ~0xfffff)
5917 if (fixP
->fx_r_type
== BFD_RELOC_ALPHA_BOH
)
5920 image
= bfd_getl32(fixpos
);
5921 image
= (image
& ~0x3FFF) | ((value
>> 2) & 0x3FFF);
5928 /* Change to a branch. */
5929 image
= 0xD3400000 | ((value
>> 2) & 0x1FFFFF);
5934 case BFD_RELOC_VTABLE_INHERIT
:
5935 case BFD_RELOC_VTABLE_ENTRY
:
5940 const struct alpha_operand
*operand
;
5942 if ((int) fixP
->fx_r_type
>= 0)
5943 as_fatal (_("unhandled relocation type %s"),
5944 bfd_get_reloc_code_name (fixP
->fx_r_type
));
5946 gas_assert (-(int) fixP
->fx_r_type
< (int) alpha_num_operands
);
5947 operand
= &alpha_operands
[-(int) fixP
->fx_r_type
];
5949 /* The rest of these fixups only exist internally during symbol
5950 resolution and have no representation in the object file.
5951 Therefore they must be completely resolved as constants. */
5953 if (fixP
->fx_addsy
!= 0
5954 && S_GET_SEGMENT (fixP
->fx_addsy
) != absolute_section
)
5955 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5956 _("non-absolute expression in constant field"));
5958 image
= bfd_getl32 (fixpos
);
5959 image
= insert_operand (image
, operand
, (offsetT
) value
,
5960 fixP
->fx_file
, fixP
->fx_line
);
5965 if (fixP
->fx_addsy
!= 0 || fixP
->fx_pcrel
!= 0)
5969 as_warn_where (fixP
->fx_file
, fixP
->fx_line
,
5970 _("type %d reloc done?\n"), (int) fixP
->fx_r_type
);
5975 md_number_to_chars (fixpos
, image
, 4);
5981 /* Look for a register name in the given symbol. */
5984 md_undefined_symbol (char *name
)
5988 int is_float
= 0, num
;
5993 if (name
[1] == 'p' && name
[2] == '\0')
5994 return alpha_register_table
[AXP_REG_FP
];
5999 if (!ISDIGIT (*++name
))
6003 case '0': case '1': case '2': case '3': case '4':
6004 case '5': case '6': case '7': case '8': case '9':
6005 if (name
[1] == '\0')
6006 num
= name
[0] - '0';
6007 else if (name
[0] != '0' && ISDIGIT (name
[1]) && name
[2] == '\0')
6009 num
= (name
[0] - '0') * 10 + name
[1] - '0';
6016 if (!alpha_noat_on
&& (num
+ is_float
) == AXP_REG_AT
)
6017 as_warn (_("Used $at without \".set noat\""));
6018 return alpha_register_table
[num
+ is_float
];
6021 if (name
[1] == 't' && name
[2] == '\0')
6024 as_warn (_("Used $at without \".set noat\""));
6025 return alpha_register_table
[AXP_REG_AT
];
6030 if (name
[1] == 'p' && name
[2] == '\0')
6031 return alpha_register_table
[alpha_gp_register
];
6035 if (name
[1] == 'p' && name
[2] == '\0')
6036 return alpha_register_table
[AXP_REG_SP
];
6044 /* @@@ Magic ECOFF bits. */
6047 alpha_frob_ecoff_data (void)
6050 /* $zero and $f31 are read-only. */
6051 alpha_gprmask
&= ~1;
6052 alpha_fprmask
&= ~1;
6056 /* Hook to remember a recently defined label so that the auto-align
6057 code can adjust the symbol after we know what alignment will be
6061 alpha_define_label (symbolS
*sym
)
6063 alpha_insn_label
= sym
;
6065 dwarf2_emit_label (sym
);
6069 /* Return true if we must always emit a reloc for a type and false if
6070 there is some hope of resolving it at assembly time. */
6073 alpha_force_relocation (fixS
*f
)
6075 if (alpha_flag_relax
)
6078 switch (f
->fx_r_type
)
6080 case BFD_RELOC_ALPHA_GPDISP_HI16
:
6081 case BFD_RELOC_ALPHA_GPDISP_LO16
:
6082 case BFD_RELOC_ALPHA_GPDISP
:
6083 case BFD_RELOC_ALPHA_LITERAL
:
6084 case BFD_RELOC_ALPHA_ELF_LITERAL
:
6085 case BFD_RELOC_ALPHA_LITUSE
:
6086 case BFD_RELOC_GPREL16
:
6087 case BFD_RELOC_GPREL32
:
6088 case BFD_RELOC_ALPHA_GPREL_HI16
:
6089 case BFD_RELOC_ALPHA_GPREL_LO16
:
6090 case BFD_RELOC_ALPHA_LINKAGE
:
6091 case BFD_RELOC_ALPHA_CODEADDR
:
6092 case BFD_RELOC_ALPHA_BRSGP
:
6093 case BFD_RELOC_ALPHA_TLSGD
:
6094 case BFD_RELOC_ALPHA_TLSLDM
:
6095 case BFD_RELOC_ALPHA_GOTDTPREL16
:
6096 case BFD_RELOC_ALPHA_DTPREL_HI16
:
6097 case BFD_RELOC_ALPHA_DTPREL_LO16
:
6098 case BFD_RELOC_ALPHA_DTPREL16
:
6099 case BFD_RELOC_ALPHA_GOTTPREL16
:
6100 case BFD_RELOC_ALPHA_TPREL_HI16
:
6101 case BFD_RELOC_ALPHA_TPREL_LO16
:
6102 case BFD_RELOC_ALPHA_TPREL16
:
6104 case BFD_RELOC_ALPHA_NOP
:
6105 case BFD_RELOC_ALPHA_BSR
:
6106 case BFD_RELOC_ALPHA_LDA
:
6107 case BFD_RELOC_ALPHA_BOH
:
6115 return generic_force_reloc (f
);
6118 /* Return true if we can partially resolve a relocation now. */
6121 alpha_fix_adjustable (fixS
*f
)
6123 /* Are there any relocation types for which we must generate a
6124 reloc but we can adjust the values contained within it? */
6125 switch (f
->fx_r_type
)
6127 case BFD_RELOC_ALPHA_GPDISP_HI16
:
6128 case BFD_RELOC_ALPHA_GPDISP_LO16
:
6129 case BFD_RELOC_ALPHA_GPDISP
:
6132 case BFD_RELOC_ALPHA_LITERAL
:
6133 case BFD_RELOC_ALPHA_ELF_LITERAL
:
6134 case BFD_RELOC_ALPHA_LITUSE
:
6135 case BFD_RELOC_ALPHA_LINKAGE
:
6136 case BFD_RELOC_ALPHA_CODEADDR
:
6139 case BFD_RELOC_VTABLE_ENTRY
:
6140 case BFD_RELOC_VTABLE_INHERIT
:
6143 case BFD_RELOC_GPREL16
:
6144 case BFD_RELOC_GPREL32
:
6145 case BFD_RELOC_ALPHA_GPREL_HI16
:
6146 case BFD_RELOC_ALPHA_GPREL_LO16
:
6147 case BFD_RELOC_23_PCREL_S2
:
6151 case BFD_RELOC_ALPHA_HINT
:
6154 case BFD_RELOC_ALPHA_TLSGD
:
6155 case BFD_RELOC_ALPHA_TLSLDM
:
6156 case BFD_RELOC_ALPHA_GOTDTPREL16
:
6157 case BFD_RELOC_ALPHA_DTPREL_HI16
:
6158 case BFD_RELOC_ALPHA_DTPREL_LO16
:
6159 case BFD_RELOC_ALPHA_DTPREL16
:
6160 case BFD_RELOC_ALPHA_GOTTPREL16
:
6161 case BFD_RELOC_ALPHA_TPREL_HI16
:
6162 case BFD_RELOC_ALPHA_TPREL_LO16
:
6163 case BFD_RELOC_ALPHA_TPREL16
:
6164 /* ??? No idea why we can't return a reference to .tbss+10, but
6165 we're preventing this in the other assemblers. Follow for now. */
6169 case BFD_RELOC_ALPHA_BRSGP
:
6170 /* If we have a BRSGP reloc to a local symbol, adjust it to BRADDR and
6171 let it get resolved at assembly time. */
6173 symbolS
*sym
= f
->fx_addsy
;
6177 if (generic_force_reloc (f
))
6180 switch (S_GET_OTHER (sym
) & STO_ALPHA_STD_GPLOAD
)
6182 case STO_ALPHA_NOPV
:
6184 case STO_ALPHA_STD_GPLOAD
:
6188 if (S_IS_LOCAL (sym
))
6191 name
= S_GET_NAME (sym
);
6192 as_bad_where (f
->fx_file
, f
->fx_line
,
6193 _("!samegp reloc against symbol without .prologue: %s"),
6197 f
->fx_r_type
= BFD_RELOC_23_PCREL_S2
;
6198 f
->fx_offset
+= offset
;
6203 case BFD_RELOC_ALPHA_NOP
:
6204 case BFD_RELOC_ALPHA_BSR
:
6205 case BFD_RELOC_ALPHA_LDA
:
6206 case BFD_RELOC_ALPHA_BOH
:
6215 /* Generate the BFD reloc to be stuck in the object file from the
6216 fixup used internally in the assembler. */
6219 tc_gen_reloc (asection
*sec ATTRIBUTE_UNUSED
,
6224 reloc
= (arelent
*) xmalloc (sizeof (* reloc
));
6225 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
6226 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
6227 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6229 /* Make sure none of our internal relocations make it this far.
6230 They'd better have been fully resolved by this point. */
6231 gas_assert ((int) fixp
->fx_r_type
> 0);
6233 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
6234 if (reloc
->howto
== NULL
)
6236 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
6237 _("cannot represent `%s' relocation in object file"),
6238 bfd_get_reloc_code_name (fixp
->fx_r_type
));
6242 if (!fixp
->fx_pcrel
!= !reloc
->howto
->pc_relative
)
6243 as_fatal (_("internal error? cannot generate `%s' relocation"),
6244 bfd_get_reloc_code_name (fixp
->fx_r_type
));
6246 gas_assert (!fixp
->fx_pcrel
== !reloc
->howto
->pc_relative
);
6248 reloc
->addend
= fixp
->fx_offset
;
6251 /* Fake out bfd_perform_relocation. sigh. */
6252 /* ??? Better would be to use the special_function hook. */
6253 if (fixp
->fx_r_type
== BFD_RELOC_ALPHA_LITERAL
)
6254 reloc
->addend
= -alpha_gp_value
;
6258 switch (fixp
->fx_r_type
)
6260 struct evax_private_udata_struct
*udata
;
6264 case BFD_RELOC_ALPHA_LINKAGE
:
6265 /* Copy the linkage index. */
6266 reloc
->addend
= fixp
->fx_addnumber
;
6269 case BFD_RELOC_ALPHA_NOP
:
6270 case BFD_RELOC_ALPHA_BSR
:
6271 case BFD_RELOC_ALPHA_LDA
:
6272 case BFD_RELOC_ALPHA_BOH
:
6273 pname
= symbol_get_bfdsym (fixp
->fx_addsy
)->name
;
6275 /* We need the non-suffixed name of the procedure. Beware that
6276 the main symbol might be equated so look it up and take its name. */
6277 pname_len
= strlen (pname
);
6278 if (pname_len
> 4 && strcmp (pname
+ pname_len
- 4, "..en") == 0)
6281 char *my_pname
= (char *) alloca (pname_len
- 4 + 1);
6283 memcpy (my_pname
, pname
, pname_len
- 4);
6284 my_pname
[pname_len
- 4] = 0;
6285 sym
= symbol_find (my_pname
);
6289 while (symbol_equated_reloc_p (sym
))
6291 symbolS
*n
= symbol_get_value_expression (sym
)->X_add_symbol
;
6293 /* We must avoid looping, as that can occur with a badly
6299 pname
= symbol_get_bfdsym (sym
)->name
;
6302 udata
= (struct evax_private_udata_struct
*)
6303 xmalloc (sizeof (struct evax_private_udata_struct
));
6304 udata
->enbsym
= symbol_get_bfdsym (fixp
->fx_addsy
);
6305 udata
->bsym
= symbol_get_bfdsym (fixp
->tc_fix_data
.info
->psym
);
6306 udata
->origname
= (char *)pname
;
6307 udata
->lkindex
= ((struct evax_private_udata_struct
*)
6308 symbol_get_bfdsym (fixp
->tc_fix_data
.info
->sym
)->udata
.p
)->lkindex
;
6309 reloc
->sym_ptr_ptr
= (void *)udata
;
6310 reloc
->addend
= fixp
->fx_addnumber
;
6320 /* Parse a register name off of the input_line and return a register
6321 number. Gets md_undefined_symbol above to do the register name
6324 Only called as a part of processing the ECOFF .frame directive. */
6327 tc_get_register (int frame ATTRIBUTE_UNUSED
)
6329 int framereg
= AXP_REG_SP
;
6332 if (*input_line_pointer
== '$')
6334 char *s
= input_line_pointer
;
6335 char c
= get_symbol_end ();
6336 symbolS
*sym
= md_undefined_symbol (s
);
6338 *strchr (s
, '\0') = c
;
6339 if (sym
&& (framereg
= S_GET_VALUE (sym
)) <= 31)
6342 as_warn (_("frame reg expected, using $%d."), framereg
);
6345 note_gpreg (framereg
);
6349 /* This is called before the symbol table is processed. In order to
6350 work with gcc when using mips-tfile, we must keep all local labels.
6351 However, in other cases, we want to discard them. If we were
6352 called with -g, but we didn't see any debugging information, it may
6353 mean that gcc is smuggling debugging information through to
6354 mips-tfile, in which case we must generate all local labels. */
6359 alpha_frob_file_before_adjust (void)
6361 if (alpha_debug
!= 0
6362 && ! ecoff_debugging_seen
)
6363 flag_keep_locals
= 1;
6366 #endif /* OBJ_ECOFF */
6368 /* The Alpha has support for some VAX floating point types, as well as for
6369 IEEE floating point. We consider IEEE to be the primary floating point
6370 format, and sneak in the VAX floating point support here. */
6371 #include "config/atof-vax.c"