1 /* tc-alpha.c - Processor-specific code for the DEC Alpha AXP CPU.
2 Copyright (C) 1989-2020 Free Software Foundation, Inc.
3 Contributed by Carnegie Mellon University, 1993.
4 Written by Alessandro Forin, based on earlier gas-1.38 target CPU files.
5 Modified by Ken Raeburn for gas-2.x and ECOFF support.
6 Modified by Richard Henderson for ELF support.
7 Modified by Klaus K"ampf for EVAX (OpenVMS/Alpha) support.
9 This file is part of GAS, the GNU Assembler.
11 GAS is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3, or (at your option)
16 GAS is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with GAS; see the file COPYING. If not, write to the Free
23 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
26 /* Mach Operating System
27 Copyright (c) 1993 Carnegie Mellon University
30 Permission to use, copy, modify and distribute this software and its
31 documentation is hereby granted, provided that both the copyright
32 notice and this permission notice appear in all copies of the
33 software, derivative works or modified versions, and any portions
34 thereof, and that both notices appear in supporting documentation.
36 CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
37 CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
38 ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
40 Carnegie Mellon requests users of this software to return to
42 Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
43 School of Computer Science
44 Carnegie Mellon University
45 Pittsburgh PA 15213-3890
47 any improvements or extensions that they make and grant Carnegie the
48 rights to redistribute these changes. */
54 #include "opcode/alpha.h"
57 #include "elf/alpha.h"
65 #include "dwarf2dbg.h"
66 #include "dw2gencfi.h"
67 #include "safe-ctype.h"
71 #define TOKENIZE_ERROR -1
72 #define TOKENIZE_ERROR_REPORT -2
73 #define MAX_INSN_FIXUPS 2
74 #define MAX_INSN_ARGS 5
76 /* Used since new relocation types are introduced in this
77 file (DUMMY_RELOC_LITUSE_*) */
78 typedef int extended_bfd_reloc_code_real_type
;
83 /* bfd_reloc_code_real_type reloc; */
84 extended_bfd_reloc_code_real_type reloc
;
86 /* The symbol of the item in the linkage section. */
89 /* The symbol of the procedure descriptor. */
98 struct alpha_fixup fixups
[MAX_INSN_FIXUPS
];
116 void (*emit
) (const expressionS
*, int, const void *);
118 enum alpha_macro_arg argsets
[16];
121 /* Extra expression types. */
123 #define O_pregister O_md1 /* O_register, in parentheses. */
124 #define O_cpregister O_md2 /* + a leading comma. */
126 /* The alpha_reloc_op table below depends on the ordering of these. */
127 #define O_literal O_md3 /* !literal relocation. */
128 #define O_lituse_addr O_md4 /* !lituse_addr relocation. */
129 #define O_lituse_base O_md5 /* !lituse_base relocation. */
130 #define O_lituse_bytoff O_md6 /* !lituse_bytoff relocation. */
131 #define O_lituse_jsr O_md7 /* !lituse_jsr relocation. */
132 #define O_lituse_tlsgd O_md8 /* !lituse_tlsgd relocation. */
133 #define O_lituse_tlsldm O_md9 /* !lituse_tlsldm relocation. */
134 #define O_lituse_jsrdirect O_md10 /* !lituse_jsrdirect relocation. */
135 #define O_gpdisp O_md11 /* !gpdisp relocation. */
136 #define O_gprelhigh O_md12 /* !gprelhigh relocation. */
137 #define O_gprellow O_md13 /* !gprellow relocation. */
138 #define O_gprel O_md14 /* !gprel relocation. */
139 #define O_samegp O_md15 /* !samegp relocation. */
140 #define O_tlsgd O_md16 /* !tlsgd relocation. */
141 #define O_tlsldm O_md17 /* !tlsldm relocation. */
142 #define O_gotdtprel O_md18 /* !gotdtprel relocation. */
143 #define O_dtprelhi O_md19 /* !dtprelhi relocation. */
144 #define O_dtprello O_md20 /* !dtprello relocation. */
145 #define O_dtprel O_md21 /* !dtprel relocation. */
146 #define O_gottprel O_md22 /* !gottprel relocation. */
147 #define O_tprelhi O_md23 /* !tprelhi relocation. */
148 #define O_tprello O_md24 /* !tprello relocation. */
149 #define O_tprel O_md25 /* !tprel relocation. */
151 #define DUMMY_RELOC_LITUSE_ADDR (BFD_RELOC_UNUSED + 1)
152 #define DUMMY_RELOC_LITUSE_BASE (BFD_RELOC_UNUSED + 2)
153 #define DUMMY_RELOC_LITUSE_BYTOFF (BFD_RELOC_UNUSED + 3)
154 #define DUMMY_RELOC_LITUSE_JSR (BFD_RELOC_UNUSED + 4)
155 #define DUMMY_RELOC_LITUSE_TLSGD (BFD_RELOC_UNUSED + 5)
156 #define DUMMY_RELOC_LITUSE_TLSLDM (BFD_RELOC_UNUSED + 6)
157 #define DUMMY_RELOC_LITUSE_JSRDIRECT (BFD_RELOC_UNUSED + 7)
159 #define USER_RELOC_P(R) ((R) >= O_literal && (R) <= O_tprel)
161 /* Macros for extracting the type and number of encoded register tokens. */
163 #define is_ir_num(x) (((x) & 32) == 0)
164 #define is_fpr_num(x) (((x) & 32) != 0)
165 #define regno(x) ((x) & 31)
167 /* Something odd inherited from the old assembler. */
169 #define note_gpreg(R) (alpha_gprmask |= (1 << (R)))
170 #define note_fpreg(R) (alpha_fprmask |= (1 << (R)))
172 /* Predicates for 16- and 32-bit ranges */
173 /* XXX: The non-shift version appears to trigger a compiler bug when
174 cross-assembling from x86 w/ gcc 2.7.2. */
177 #define range_signed_16(x) \
178 (((offsetT) (x) >> 15) == 0 || ((offsetT) (x) >> 15) == -1)
179 #define range_signed_32(x) \
180 (((offsetT) (x) >> 31) == 0 || ((offsetT) (x) >> 31) == -1)
182 #define range_signed_16(x) ((offsetT) (x) >= -(offsetT) 0x8000 && \
183 (offsetT) (x) <= (offsetT) 0x7FFF)
184 #define range_signed_32(x) ((offsetT) (x) >= -(offsetT) 0x80000000 && \
185 (offsetT) (x) <= (offsetT) 0x7FFFFFFF)
188 /* Macros for sign extending from 16- and 32-bits. */
189 /* XXX: The cast macros will work on all the systems that I care about,
190 but really a predicate should be found to use the non-cast forms. */
193 #define sign_extend_16(x) ((short) (x))
194 #define sign_extend_32(x) ((int) (x))
196 #define sign_extend_16(x) ((offsetT) (((x) & 0xFFFF) ^ 0x8000) - 0x8000)
197 #define sign_extend_32(x) ((offsetT) (((x) & 0xFFFFFFFF) \
198 ^ 0x80000000) - 0x80000000)
201 /* Macros to build tokens. */
203 #define set_tok_reg(t, r) (memset (&(t), 0, sizeof (t)), \
204 (t).X_op = O_register, \
205 (t).X_add_number = (r))
206 #define set_tok_preg(t, r) (memset (&(t), 0, sizeof (t)), \
207 (t).X_op = O_pregister, \
208 (t).X_add_number = (r))
209 #define set_tok_cpreg(t, r) (memset (&(t), 0, sizeof (t)), \
210 (t).X_op = O_cpregister, \
211 (t).X_add_number = (r))
212 #define set_tok_freg(t, r) (memset (&(t), 0, sizeof (t)), \
213 (t).X_op = O_register, \
214 (t).X_add_number = (r) + 32)
215 #define set_tok_sym(t, s, a) (memset (&(t), 0, sizeof (t)), \
216 (t).X_op = O_symbol, \
217 (t).X_add_symbol = (s), \
218 (t).X_add_number = (a))
219 #define set_tok_const(t, n) (memset (&(t), 0, sizeof (t)), \
220 (t).X_op = O_constant, \
221 (t).X_add_number = (n))
223 /* Generic assembler global variables which must be defined by all
226 /* Characters which always start a comment. */
227 const char comment_chars
[] = "#";
229 /* Characters which start a comment at the beginning of a line. */
230 const char line_comment_chars
[] = "#";
232 /* Characters which may be used to separate multiple commands on a
234 const char line_separator_chars
[] = ";";
236 /* Characters which are used to indicate an exponent in a floating
238 const char EXP_CHARS
[] = "eE";
240 /* Characters which mean that a number is a floating point constant,
242 /* XXX: Do all of these really get used on the alpha?? */
243 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
246 const char *md_shortopts
= "Fm:g+1h:HG:";
248 const char *md_shortopts
= "Fm:gG:";
251 struct option md_longopts
[] =
253 #define OPTION_32ADDR (OPTION_MD_BASE)
254 { "32addr", no_argument
, NULL
, OPTION_32ADDR
},
255 #define OPTION_RELAX (OPTION_32ADDR + 1)
256 { "relax", no_argument
, NULL
, OPTION_RELAX
},
258 #define OPTION_MDEBUG (OPTION_RELAX + 1)
259 #define OPTION_NO_MDEBUG (OPTION_MDEBUG + 1)
260 { "mdebug", no_argument
, NULL
, OPTION_MDEBUG
},
261 { "no-mdebug", no_argument
, NULL
, OPTION_NO_MDEBUG
},
264 #define OPTION_REPLACE (OPTION_RELAX + 1)
265 #define OPTION_NOREPLACE (OPTION_REPLACE+1)
266 { "replace", no_argument
, NULL
, OPTION_REPLACE
},
267 { "noreplace", no_argument
, NULL
, OPTION_NOREPLACE
},
269 { NULL
, no_argument
, NULL
, 0 }
272 size_t md_longopts_size
= sizeof (md_longopts
);
276 #define AXP_REG_R16 16
277 #define AXP_REG_R17 17
279 #define AXP_REG_T9 22
281 #define AXP_REG_T10 23
283 #define AXP_REG_T11 24
285 #define AXP_REG_T12 25
286 #define AXP_REG_AI 25
288 #define AXP_REG_FP 29
291 #define AXP_REG_GP AXP_REG_PV
293 #endif /* OBJ_EVAX */
295 /* The cpu for which we are generating code. */
296 static unsigned alpha_target
= AXP_OPCODE_BASE
;
297 static const char *alpha_target_name
= "<all>";
299 /* The hash table of instruction opcodes. */
300 static htab_t alpha_opcode_hash
;
302 /* The hash table of macro opcodes. */
303 static htab_t alpha_macro_hash
;
306 /* The $gp relocation symbol. */
307 static symbolS
*alpha_gp_symbol
;
309 /* XXX: what is this, and why is it exported? */
310 valueT alpha_gp_value
;
313 /* The current $gp register. */
314 static int alpha_gp_register
= AXP_REG_GP
;
316 /* A table of the register symbols. */
317 static symbolS
*alpha_register_table
[64];
319 /* Constant sections, or sections of constants. */
321 static segT alpha_lita_section
;
324 segT alpha_link_section
;
327 static segT alpha_lit8_section
;
330 /* Symbols referring to said sections. */
332 static symbolS
*alpha_lita_symbol
;
335 static symbolS
*alpha_link_symbol
;
338 static symbolS
*alpha_lit8_symbol
;
341 /* Literal for .litX+0x8000 within .lita. */
343 static offsetT alpha_lit8_literal
;
346 /* Is the assembler not allowed to use $at? */
347 static int alpha_noat_on
= 0;
349 /* Are macros enabled? */
350 static int alpha_macros_on
= 1;
352 /* Are floats disabled? */
353 static int alpha_nofloats_on
= 0;
355 /* Are addresses 32 bit? */
356 static int alpha_addr32_on
= 0;
358 /* Symbol labelling the current insn. When the Alpha gas sees
361 and the section happens to not be on an eight byte boundary, it
362 will align both the symbol and the .quad to an eight byte boundary. */
363 static symbolS
*alpha_insn_label
;
364 #if defined(OBJ_ELF) || defined (OBJ_EVAX)
365 static symbolS
*alpha_prologue_label
;
369 /* Symbol associate with the current jsr instruction. */
370 static symbolS
*alpha_linkage_symbol
;
373 /* Whether we should automatically align data generation pseudo-ops.
374 .align 0 will turn this off. */
375 static int alpha_auto_align_on
= 1;
377 /* The known current alignment of the current section. */
378 static int alpha_current_align
;
380 /* These are exported to ECOFF code. */
381 unsigned long alpha_gprmask
, alpha_fprmask
;
383 /* Whether the debugging option was seen. */
384 static int alpha_debug
;
387 /* Whether we are emitting an mdebug section. */
388 int alpha_flag_mdebug
= -1;
392 /* Whether to perform the VMS procedure call optimization. */
393 int alpha_flag_replace
= 1;
396 /* Don't fully resolve relocations, allowing code movement in the linker. */
397 static int alpha_flag_relax
;
399 /* What value to give to bfd_set_gp_size. */
400 static int g_switch_value
= 8;
403 /* Collect information about current procedure here. */
404 struct alpha_evax_procs
406 symbolS
*symbol
; /* Proc pdesc symbol. */
408 int framereg
; /* Register for frame pointer. */
409 int framesize
; /* Size of frame. */
421 /* Linked list of .linkage fixups. */
422 struct alpha_linkage_fixups
*alpha_linkage_fixup_root
;
423 static struct alpha_linkage_fixups
*alpha_linkage_fixup_tail
;
425 /* Current procedure descriptor. */
426 static struct alpha_evax_procs
*alpha_evax_proc
;
427 static struct alpha_evax_procs alpha_evax_proc_data
;
429 static int alpha_flag_hash_long_names
= 0; /* -+ */
430 static int alpha_flag_show_after_trunc
= 0; /* -H */
432 /* If the -+ switch is given, then a hash is appended to any name that is
433 longer than 64 characters, else longer symbol names are truncated. */
438 /* A table to map the spelling of a relocation operand into an appropriate
439 bfd_reloc_code_real_type type. The table is assumed to be ordered such
440 that op-O_literal indexes into it. */
442 #define ALPHA_RELOC_TABLE(op) \
443 (&alpha_reloc_op[ ((!USER_RELOC_P (op)) \
445 : (int) (op) - (int) O_literal) ])
447 #define DEF(NAME, RELOC, REQ, ALLOW) \
448 { #NAME, sizeof(#NAME)-1, O_##NAME, RELOC, REQ, ALLOW}
450 static const struct alpha_reloc_op_tag
452 const char *name
; /* String to lookup. */
453 size_t length
; /* Size of the string. */
454 operatorT op
; /* Which operator to use. */
455 extended_bfd_reloc_code_real_type reloc
;
456 unsigned int require_seq
: 1; /* Require a sequence number. */
457 unsigned int allow_seq
: 1; /* Allow a sequence number. */
461 DEF (literal
, BFD_RELOC_ALPHA_ELF_LITERAL
, 0, 1),
462 DEF (lituse_addr
, DUMMY_RELOC_LITUSE_ADDR
, 1, 1),
463 DEF (lituse_base
, DUMMY_RELOC_LITUSE_BASE
, 1, 1),
464 DEF (lituse_bytoff
, DUMMY_RELOC_LITUSE_BYTOFF
, 1, 1),
465 DEF (lituse_jsr
, DUMMY_RELOC_LITUSE_JSR
, 1, 1),
466 DEF (lituse_tlsgd
, DUMMY_RELOC_LITUSE_TLSGD
, 1, 1),
467 DEF (lituse_tlsldm
, DUMMY_RELOC_LITUSE_TLSLDM
, 1, 1),
468 DEF (lituse_jsrdirect
, DUMMY_RELOC_LITUSE_JSRDIRECT
, 1, 1),
469 DEF (gpdisp
, BFD_RELOC_ALPHA_GPDISP
, 1, 1),
470 DEF (gprelhigh
, BFD_RELOC_ALPHA_GPREL_HI16
, 0, 0),
471 DEF (gprellow
, BFD_RELOC_ALPHA_GPREL_LO16
, 0, 0),
472 DEF (gprel
, BFD_RELOC_GPREL16
, 0, 0),
473 DEF (samegp
, BFD_RELOC_ALPHA_BRSGP
, 0, 0),
474 DEF (tlsgd
, BFD_RELOC_ALPHA_TLSGD
, 0, 1),
475 DEF (tlsldm
, BFD_RELOC_ALPHA_TLSLDM
, 0, 1),
476 DEF (gotdtprel
, BFD_RELOC_ALPHA_GOTDTPREL16
, 0, 0),
477 DEF (dtprelhi
, BFD_RELOC_ALPHA_DTPREL_HI16
, 0, 0),
478 DEF (dtprello
, BFD_RELOC_ALPHA_DTPREL_LO16
, 0, 0),
479 DEF (dtprel
, BFD_RELOC_ALPHA_DTPREL16
, 0, 0),
480 DEF (gottprel
, BFD_RELOC_ALPHA_GOTTPREL16
, 0, 0),
481 DEF (tprelhi
, BFD_RELOC_ALPHA_TPREL_HI16
, 0, 0),
482 DEF (tprello
, BFD_RELOC_ALPHA_TPREL_LO16
, 0, 0),
483 DEF (tprel
, BFD_RELOC_ALPHA_TPREL16
, 0, 0),
488 static const int alpha_num_reloc_op
489 = sizeof (alpha_reloc_op
) / sizeof (*alpha_reloc_op
);
490 #endif /* RELOC_OP_P */
492 /* Maximum # digits needed to hold the largest sequence #. */
493 #define ALPHA_RELOC_DIGITS 25
495 /* Structure to hold explicit sequence information. */
496 struct alpha_reloc_tag
498 fixS
*master
; /* The literal reloc. */
500 struct symbol
*sym
; /* Linkage section item symbol. */
501 struct symbol
*psym
; /* Pdesc symbol. */
503 fixS
*slaves
; /* Head of linked list of lituses. */
504 segT segment
; /* Segment relocs are in or undefined_section. */
505 long sequence
; /* Sequence #. */
506 unsigned n_master
; /* # of literals. */
507 unsigned n_slaves
; /* # of lituses. */
508 unsigned saw_tlsgd
: 1; /* True if ... */
509 unsigned saw_tlsldm
: 1;
510 unsigned saw_lu_tlsgd
: 1;
511 unsigned saw_lu_tlsldm
: 1;
512 unsigned multi_section_p
: 1; /* True if more than one section was used. */
513 char string
[1]; /* Printable form of sequence to hash with. */
516 /* Hash table to link up literals with the appropriate lituse. */
517 static htab_t alpha_literal_hash
;
519 /* Sequence numbers for internal use by macros. */
520 static long next_sequence_num
= -1;
522 /* A table of CPU names and opcode sets. */
524 static const struct cpu_type
531 /* Ad hoc convention: cpu number gets palcode, process code doesn't.
532 This supports usage under DU 4.0b that does ".arch ev4", and
533 usage in MILO that does -m21064. Probably something more
534 specific like -m21064-pal should be used, but oh well. */
536 { "21064", AXP_OPCODE_BASE
|AXP_OPCODE_EV4
},
537 { "21064a", AXP_OPCODE_BASE
|AXP_OPCODE_EV4
},
538 { "21066", AXP_OPCODE_BASE
|AXP_OPCODE_EV4
},
539 { "21068", AXP_OPCODE_BASE
|AXP_OPCODE_EV4
},
540 { "21164", AXP_OPCODE_BASE
|AXP_OPCODE_EV5
},
541 { "21164a", AXP_OPCODE_BASE
|AXP_OPCODE_EV5
|AXP_OPCODE_BWX
},
542 { "21164pc", (AXP_OPCODE_BASE
|AXP_OPCODE_EV5
|AXP_OPCODE_BWX
544 { "21264", (AXP_OPCODE_BASE
|AXP_OPCODE_EV6
|AXP_OPCODE_BWX
545 |AXP_OPCODE_MAX
|AXP_OPCODE_CIX
) },
546 { "21264a", (AXP_OPCODE_BASE
|AXP_OPCODE_EV6
|AXP_OPCODE_BWX
547 |AXP_OPCODE_MAX
|AXP_OPCODE_CIX
) },
548 { "21264b", (AXP_OPCODE_BASE
|AXP_OPCODE_EV6
|AXP_OPCODE_BWX
549 |AXP_OPCODE_MAX
|AXP_OPCODE_CIX
) },
551 { "ev4", AXP_OPCODE_BASE
},
552 { "ev45", AXP_OPCODE_BASE
},
553 { "lca45", AXP_OPCODE_BASE
},
554 { "ev5", AXP_OPCODE_BASE
},
555 { "ev56", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
},
556 { "pca56", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
|AXP_OPCODE_MAX
},
557 { "ev6", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
|AXP_OPCODE_MAX
|AXP_OPCODE_CIX
},
558 { "ev67", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
|AXP_OPCODE_MAX
|AXP_OPCODE_CIX
},
559 { "ev68", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
|AXP_OPCODE_MAX
|AXP_OPCODE_CIX
},
561 { "all", AXP_OPCODE_BASE
},
565 /* Some instruction sets indexed by lg(size). */
566 static const char * const sextX_op
[] = { "sextb", "sextw", "sextl", NULL
};
567 static const char * const insXl_op
[] = { "insbl", "inswl", "insll", "insql" };
568 static const char * const insXh_op
[] = { NULL
, "inswh", "inslh", "insqh" };
569 static const char * const extXl_op
[] = { "extbl", "extwl", "extll", "extql" };
570 static const char * const extXh_op
[] = { NULL
, "extwh", "extlh", "extqh" };
571 static const char * const mskXl_op
[] = { "mskbl", "mskwl", "mskll", "mskql" };
572 static const char * const mskXh_op
[] = { NULL
, "mskwh", "msklh", "mskqh" };
573 static const char * const stX_op
[] = { "stb", "stw", "stl", "stq" };
574 static const char * const ldXu_op
[] = { "ldbu", "ldwu", NULL
, NULL
};
576 static void assemble_insn (const struct alpha_opcode
*, const expressionS
*, int, struct alpha_insn
*, extended_bfd_reloc_code_real_type
);
577 static void emit_insn (struct alpha_insn
*);
578 static void assemble_tokens (const char *, const expressionS
*, int, int);
580 static const char *s_alpha_section_name (void);
581 static symbolS
*add_to_link_pool (symbolS
*, offsetT
);
584 static struct alpha_reloc_tag
*
585 get_alpha_reloc_tag (long sequence
)
587 char buffer
[ALPHA_RELOC_DIGITS
];
588 struct alpha_reloc_tag
*info
;
590 sprintf (buffer
, "!%ld", sequence
);
592 info
= (struct alpha_reloc_tag
*) str_hash_find (alpha_literal_hash
, buffer
);
595 size_t len
= strlen (buffer
);
597 info
= (struct alpha_reloc_tag
*)
598 xcalloc (sizeof (struct alpha_reloc_tag
) + len
, 1);
600 info
->segment
= now_seg
;
601 info
->sequence
= sequence
;
602 strcpy (info
->string
, buffer
);
603 str_hash_insert (alpha_literal_hash
, info
->string
, (void *) info
);
616 alpha_adjust_relocs (bfd
*abfd ATTRIBUTE_UNUSED
,
618 void * ptr ATTRIBUTE_UNUSED
)
620 segment_info_type
*seginfo
= seg_info (sec
);
626 /* If seginfo is NULL, we did not create this section; don't do
627 anything with it. By using a pointer to a pointer, we can update
628 the links in place. */
632 /* If there are no relocations, skip the section. */
633 if (! seginfo
->fix_root
)
636 /* First rebuild the fixup chain without the explicit lituse and
637 gpdisp_lo16 relocs. */
638 prevP
= &seginfo
->fix_root
;
639 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= next
)
641 next
= fixp
->fx_next
;
642 fixp
->fx_next
= (fixS
*) 0;
644 switch (fixp
->fx_r_type
)
646 case BFD_RELOC_ALPHA_LITUSE
:
647 if (fixp
->tc_fix_data
.info
->n_master
== 0)
648 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
649 _("No !literal!%ld was found"),
650 fixp
->tc_fix_data
.info
->sequence
);
652 if (fixp
->fx_offset
== LITUSE_ALPHA_TLSGD
)
654 if (! fixp
->tc_fix_data
.info
->saw_tlsgd
)
655 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
656 _("No !tlsgd!%ld was found"),
657 fixp
->tc_fix_data
.info
->sequence
);
659 else if (fixp
->fx_offset
== LITUSE_ALPHA_TLSLDM
)
661 if (! fixp
->tc_fix_data
.info
->saw_tlsldm
)
662 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
663 _("No !tlsldm!%ld was found"),
664 fixp
->tc_fix_data
.info
->sequence
);
669 case BFD_RELOC_ALPHA_GPDISP_LO16
:
670 if (fixp
->tc_fix_data
.info
->n_master
== 0)
671 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
672 _("No ldah !gpdisp!%ld was found"),
673 fixp
->tc_fix_data
.info
->sequence
);
676 case BFD_RELOC_ALPHA_ELF_LITERAL
:
677 if (fixp
->tc_fix_data
.info
678 && (fixp
->tc_fix_data
.info
->saw_tlsgd
679 || fixp
->tc_fix_data
.info
->saw_tlsldm
))
685 prevP
= &fixp
->fx_next
;
690 /* Go back and re-chain dependent relocations. They are currently
691 linked through the next_reloc field in reverse order, so as we
692 go through the next_reloc chain, we effectively reverse the chain
695 Except if there is more than one !literal for a given sequence
696 number. In that case, the programmer and/or compiler is not sure
697 how control flows from literal to lituse, and we can't be sure to
698 get the relaxation correct.
700 ??? Well, actually we could, if there are enough lituses such that
701 we can make each literal have at least one of each lituse type
702 present. Not implemented.
704 Also suppress the optimization if the !literals/!lituses are spread
705 in different segments. This can happen with "interesting" uses of
706 inline assembly; examples are present in the Linux kernel semaphores. */
708 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= next
)
710 next
= fixp
->fx_next
;
711 switch (fixp
->fx_r_type
)
713 case BFD_RELOC_ALPHA_TLSGD
:
714 case BFD_RELOC_ALPHA_TLSLDM
:
715 if (!fixp
->tc_fix_data
.info
)
717 if (fixp
->tc_fix_data
.info
->n_master
== 0)
719 else if (fixp
->tc_fix_data
.info
->n_master
> 1)
721 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
722 _("too many !literal!%ld for %s"),
723 fixp
->tc_fix_data
.info
->sequence
,
724 (fixp
->fx_r_type
== BFD_RELOC_ALPHA_TLSGD
725 ? "!tlsgd" : "!tlsldm"));
729 fixp
->tc_fix_data
.info
->master
->fx_next
= fixp
->fx_next
;
730 fixp
->fx_next
= fixp
->tc_fix_data
.info
->master
;
731 fixp
= fixp
->fx_next
;
734 case BFD_RELOC_ALPHA_ELF_LITERAL
:
735 if (fixp
->tc_fix_data
.info
736 && fixp
->tc_fix_data
.info
->n_master
== 1
737 && ! fixp
->tc_fix_data
.info
->multi_section_p
)
739 for (slave
= fixp
->tc_fix_data
.info
->slaves
;
741 slave
= slave
->tc_fix_data
.next_reloc
)
743 slave
->fx_next
= fixp
->fx_next
;
744 fixp
->fx_next
= slave
;
749 case BFD_RELOC_ALPHA_GPDISP_HI16
:
750 if (fixp
->tc_fix_data
.info
->n_slaves
== 0)
751 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
752 _("No lda !gpdisp!%ld was found"),
753 fixp
->tc_fix_data
.info
->sequence
);
756 slave
= fixp
->tc_fix_data
.info
->slaves
;
757 slave
->fx_next
= next
;
758 fixp
->fx_next
= slave
;
768 /* Before the relocations are written, reorder them, so that user
769 supplied !lituse relocations follow the appropriate !literal
770 relocations, and similarly for !gpdisp relocations. */
773 alpha_before_fix (void)
775 if (alpha_literal_hash
)
776 bfd_map_over_sections (stdoutput
, alpha_adjust_relocs
, NULL
);
783 debug_exp (expressionS tok
[], int ntok
)
787 fprintf (stderr
, "debug_exp: %d tokens", ntok
);
788 for (i
= 0; i
< ntok
; i
++)
790 expressionS
*t
= &tok
[i
];
795 default: name
= "unknown"; break;
796 case O_illegal
: name
= "O_illegal"; break;
797 case O_absent
: name
= "O_absent"; break;
798 case O_constant
: name
= "O_constant"; break;
799 case O_symbol
: name
= "O_symbol"; break;
800 case O_symbol_rva
: name
= "O_symbol_rva"; break;
801 case O_register
: name
= "O_register"; break;
802 case O_big
: name
= "O_big"; break;
803 case O_uminus
: name
= "O_uminus"; break;
804 case O_bit_not
: name
= "O_bit_not"; break;
805 case O_logical_not
: name
= "O_logical_not"; break;
806 case O_multiply
: name
= "O_multiply"; break;
807 case O_divide
: name
= "O_divide"; break;
808 case O_modulus
: name
= "O_modulus"; break;
809 case O_left_shift
: name
= "O_left_shift"; break;
810 case O_right_shift
: name
= "O_right_shift"; break;
811 case O_bit_inclusive_or
: name
= "O_bit_inclusive_or"; break;
812 case O_bit_or_not
: name
= "O_bit_or_not"; break;
813 case O_bit_exclusive_or
: name
= "O_bit_exclusive_or"; break;
814 case O_bit_and
: name
= "O_bit_and"; break;
815 case O_add
: name
= "O_add"; break;
816 case O_subtract
: name
= "O_subtract"; break;
817 case O_eq
: name
= "O_eq"; break;
818 case O_ne
: name
= "O_ne"; break;
819 case O_lt
: name
= "O_lt"; break;
820 case O_le
: name
= "O_le"; break;
821 case O_ge
: name
= "O_ge"; break;
822 case O_gt
: name
= "O_gt"; break;
823 case O_logical_and
: name
= "O_logical_and"; break;
824 case O_logical_or
: name
= "O_logical_or"; break;
825 case O_index
: name
= "O_index"; break;
826 case O_pregister
: name
= "O_pregister"; break;
827 case O_cpregister
: name
= "O_cpregister"; break;
828 case O_literal
: name
= "O_literal"; break;
829 case O_lituse_addr
: name
= "O_lituse_addr"; break;
830 case O_lituse_base
: name
= "O_lituse_base"; break;
831 case O_lituse_bytoff
: name
= "O_lituse_bytoff"; break;
832 case O_lituse_jsr
: name
= "O_lituse_jsr"; break;
833 case O_lituse_tlsgd
: name
= "O_lituse_tlsgd"; break;
834 case O_lituse_tlsldm
: name
= "O_lituse_tlsldm"; break;
835 case O_lituse_jsrdirect
: name
= "O_lituse_jsrdirect"; break;
836 case O_gpdisp
: name
= "O_gpdisp"; break;
837 case O_gprelhigh
: name
= "O_gprelhigh"; break;
838 case O_gprellow
: name
= "O_gprellow"; break;
839 case O_gprel
: name
= "O_gprel"; break;
840 case O_samegp
: name
= "O_samegp"; break;
841 case O_tlsgd
: name
= "O_tlsgd"; break;
842 case O_tlsldm
: name
= "O_tlsldm"; break;
843 case O_gotdtprel
: name
= "O_gotdtprel"; break;
844 case O_dtprelhi
: name
= "O_dtprelhi"; break;
845 case O_dtprello
: name
= "O_dtprello"; break;
846 case O_dtprel
: name
= "O_dtprel"; break;
847 case O_gottprel
: name
= "O_gottprel"; break;
848 case O_tprelhi
: name
= "O_tprelhi"; break;
849 case O_tprello
: name
= "O_tprello"; break;
850 case O_tprel
: name
= "O_tprel"; break;
853 fprintf (stderr
, ", %s(%s, %s, %d)", name
,
854 (t
->X_add_symbol
) ? S_GET_NAME (t
->X_add_symbol
) : "--",
855 (t
->X_op_symbol
) ? S_GET_NAME (t
->X_op_symbol
) : "--",
856 (int) t
->X_add_number
);
858 fprintf (stderr
, "\n");
863 /* Parse the arguments to an opcode. */
866 tokenize_arguments (char *str
,
870 expressionS
*end_tok
= tok
+ ntok
;
871 char *old_input_line_pointer
;
872 int saw_comma
= 0, saw_arg
= 0;
874 expressionS
*orig_tok
= tok
;
878 const struct alpha_reloc_op_tag
*r
;
881 int reloc_found_p
= 0;
884 memset (tok
, 0, sizeof (*tok
) * ntok
);
886 /* Save and restore input_line_pointer around this function. */
887 old_input_line_pointer
= input_line_pointer
;
888 input_line_pointer
= str
;
891 /* ??? Wrest control of ! away from the regular expression parser. */
892 is_end_of_line
[(unsigned char) '!'] = 1;
895 while (tok
< end_tok
&& *input_line_pointer
)
898 switch (*input_line_pointer
)
905 /* A relocation operand can be placed after the normal operand on an
906 assembly language statement, and has the following form:
907 !relocation_type!sequence_number. */
910 /* Only support one relocation op per insn. */
911 as_bad (_("More than one relocation op per insn"));
918 ++input_line_pointer
;
920 c
= get_symbol_name (&p
);
922 /* Parse !relocation_type. */
923 len
= input_line_pointer
- p
;
926 as_bad (_("No relocation operand"));
930 r
= &alpha_reloc_op
[0];
931 for (i
= alpha_num_reloc_op
- 1; i
>= 0; i
--, r
++)
932 if (len
== r
->length
&& memcmp (p
, r
->name
, len
) == 0)
936 as_bad (_("Unknown relocation operand: !%s"), p
);
940 *input_line_pointer
= c
;
941 SKIP_WHITESPACE_AFTER_NAME ();
942 if (*input_line_pointer
!= '!')
946 as_bad (_("no sequence number after !%s"), p
);
950 tok
->X_add_number
= 0;
956 as_bad (_("!%s does not use a sequence number"), p
);
960 input_line_pointer
++;
962 /* Parse !sequence_number. */
964 if (tok
->X_op
!= O_constant
|| tok
->X_add_number
<= 0)
966 as_bad (_("Bad sequence number: !%s!%s"),
967 r
->name
, input_line_pointer
);
976 #endif /* RELOC_OP_P */
979 ++input_line_pointer
;
980 if (saw_comma
|| !saw_arg
)
987 char *hold
= input_line_pointer
++;
989 /* First try for parenthesized register ... */
991 if (*input_line_pointer
== ')' && tok
->X_op
== O_register
)
993 tok
->X_op
= (saw_comma
? O_cpregister
: O_pregister
);
996 ++input_line_pointer
;
1001 /* ... then fall through to plain expression. */
1002 input_line_pointer
= hold
;
1007 if (saw_arg
&& !saw_comma
)
1011 if (tok
->X_op
== O_illegal
|| tok
->X_op
== O_absent
)
1024 input_line_pointer
= old_input_line_pointer
;
1027 debug_exp (orig_tok
, ntok
- (end_tok
- tok
));
1030 is_end_of_line
[(unsigned char) '!'] = 0;
1033 return ntok
- (end_tok
- tok
);
1037 is_end_of_line
[(unsigned char) '!'] = 0;
1039 input_line_pointer
= old_input_line_pointer
;
1040 return TOKENIZE_ERROR
;
1044 is_end_of_line
[(unsigned char) '!'] = 0;
1046 input_line_pointer
= old_input_line_pointer
;
1047 return TOKENIZE_ERROR_REPORT
;
1050 /* Search forward through all variants of an opcode looking for a
1053 static const struct alpha_opcode
*
1054 find_opcode_match (const struct alpha_opcode
*first_opcode
,
1055 const expressionS
*tok
,
1059 const struct alpha_opcode
*opcode
= first_opcode
;
1061 int got_cpu_match
= 0;
1065 const unsigned char *opidx
;
1068 /* Don't match opcodes that don't exist on this architecture. */
1069 if (!(opcode
->flags
& alpha_target
))
1074 for (opidx
= opcode
->operands
; *opidx
; ++opidx
)
1076 const struct alpha_operand
*operand
= &alpha_operands
[*opidx
];
1078 /* Only take input from real operands. */
1079 if (operand
->flags
& AXP_OPERAND_FAKE
)
1082 /* When we expect input, make sure we have it. */
1085 if ((operand
->flags
& AXP_OPERAND_OPTIONAL_MASK
) == 0)
1090 /* Match operand type with expression type. */
1091 switch (operand
->flags
& AXP_OPERAND_TYPECHECK_MASK
)
1093 case AXP_OPERAND_IR
:
1094 if (tok
[tokidx
].X_op
!= O_register
1095 || !is_ir_num (tok
[tokidx
].X_add_number
))
1098 case AXP_OPERAND_FPR
:
1099 if (tok
[tokidx
].X_op
!= O_register
1100 || !is_fpr_num (tok
[tokidx
].X_add_number
))
1103 case AXP_OPERAND_IR
| AXP_OPERAND_PARENS
:
1104 if (tok
[tokidx
].X_op
!= O_pregister
1105 || !is_ir_num (tok
[tokidx
].X_add_number
))
1108 case AXP_OPERAND_IR
| AXP_OPERAND_PARENS
| AXP_OPERAND_COMMA
:
1109 if (tok
[tokidx
].X_op
!= O_cpregister
1110 || !is_ir_num (tok
[tokidx
].X_add_number
))
1114 case AXP_OPERAND_RELATIVE
:
1115 case AXP_OPERAND_SIGNED
:
1116 case AXP_OPERAND_UNSIGNED
:
1117 switch (tok
[tokidx
].X_op
)
1132 /* Everything else should have been fake. */
1138 /* Possible match -- did we use all of our input? */
1147 while (++opcode
- alpha_opcodes
< (int) alpha_num_opcodes
1148 && !strcmp (opcode
->name
, first_opcode
->name
));
1151 *pcpumatch
= got_cpu_match
;
1156 /* Given an opcode name and a pre-tokenized set of arguments, assemble
1157 the insn, but do not emit it.
1159 Note that this implies no macros allowed, since we can't store more
1160 than one insn in an insn structure. */
1163 assemble_tokens_to_insn (const char *opname
,
1164 const expressionS
*tok
,
1166 struct alpha_insn
*insn
)
1168 const struct alpha_opcode
*opcode
;
1170 /* Search opcodes. */
1171 opcode
= (const struct alpha_opcode
*) str_hash_find (alpha_opcode_hash
, opname
);
1175 opcode
= find_opcode_match (opcode
, tok
, &ntok
, &cpumatch
);
1178 assemble_insn (opcode
, tok
, ntok
, insn
, BFD_RELOC_UNUSED
);
1182 as_bad (_("inappropriate arguments for opcode `%s'"), opname
);
1184 as_bad (_("opcode `%s' not supported for target %s"), opname
,
1188 as_bad (_("unknown opcode `%s'"), opname
);
1191 /* Build a BFD section with its flags set appropriately for the .lita,
1192 .lit8, or .lit4 sections. */
1195 create_literal_section (const char *name
,
1199 segT current_section
= now_seg
;
1200 int current_subsec
= now_subseg
;
1203 *secp
= new_sec
= subseg_new (name
, 0);
1204 subseg_set (current_section
, current_subsec
);
1205 bfd_set_section_alignment (new_sec
, 4);
1206 bfd_set_section_flags (new_sec
, (SEC_RELOC
| SEC_ALLOC
| SEC_LOAD
1207 | SEC_READONLY
| SEC_DATA
));
1209 S_CLEAR_EXTERNAL (*symp
= section_symbol (new_sec
));
1212 /* Load a (partial) expression into a target register.
1214 If poffset is not null, after the call it will either contain
1215 O_constant 0, or a 16-bit offset appropriate for any MEM format
1216 instruction. In addition, pbasereg will be modified to point to
1217 the base register to use in that MEM format instruction.
1219 In any case, *pbasereg should contain a base register to add to the
1220 expression. This will normally be either AXP_REG_ZERO or
1221 alpha_gp_register. Symbol addresses will always be loaded via $gp,
1222 so "foo($0)" is interpreted as adding the address of foo to $0;
1223 i.e. "ldq $targ, LIT($gp); addq $targ, $0, $targ". Odd, perhaps,
1224 but this is what OSF/1 does.
1226 If explicit relocations of the form !literal!<number> are allowed,
1227 and used, then explicit_reloc with be an expression pointer.
1229 Finally, the return value is nonzero if the calling macro may emit
1230 a LITUSE reloc if otherwise appropriate; the return value is the
1231 sequence number to use. */
1234 load_expression (int targreg
,
1235 const expressionS
*exp
,
1237 expressionS
*poffset
,
1240 long emit_lituse
= 0;
1241 offsetT addend
= exp
->X_add_number
;
1242 int basereg
= *pbasereg
;
1243 struct alpha_insn insn
;
1244 expressionS newtok
[3];
1253 /* Attempt to reduce .lit load by splitting the offset from
1254 its symbol when possible, but don't create a situation in
1256 if (!range_signed_32 (addend
) &&
1257 (alpha_noat_on
|| targreg
== AXP_REG_AT
))
1259 lit
= add_to_literal_pool (exp
->X_add_symbol
, addend
,
1260 alpha_lita_section
, 8);
1264 lit
= add_to_literal_pool (exp
->X_add_symbol
, 0,
1265 alpha_lita_section
, 8);
1268 as_fatal (_("overflow in literal (.lita) table"));
1270 /* Emit "ldq r, lit(gp)". */
1272 if (basereg
!= alpha_gp_register
&& targreg
== basereg
)
1275 as_bad (_("macro requires $at register while noat in effect"));
1276 if (targreg
== AXP_REG_AT
)
1277 as_bad (_("macro requires $at while $at in use"));
1279 set_tok_reg (newtok
[0], AXP_REG_AT
);
1282 set_tok_reg (newtok
[0], targreg
);
1284 set_tok_sym (newtok
[1], alpha_lita_symbol
, lit
);
1285 set_tok_preg (newtok
[2], alpha_gp_register
);
1287 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1289 gas_assert (insn
.nfixups
== 1);
1290 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_LITERAL
;
1291 insn
.sequence
= emit_lituse
= next_sequence_num
--;
1292 #endif /* OBJ_ECOFF */
1294 /* Emit "ldq r, gotoff(gp)". */
1296 if (basereg
!= alpha_gp_register
&& targreg
== basereg
)
1299 as_bad (_("macro requires $at register while noat in effect"));
1300 if (targreg
== AXP_REG_AT
)
1301 as_bad (_("macro requires $at while $at in use"));
1303 set_tok_reg (newtok
[0], AXP_REG_AT
);
1306 set_tok_reg (newtok
[0], targreg
);
1308 /* XXX: Disable this .got minimizing optimization so that we can get
1309 better instruction offset knowledge in the compiler. This happens
1310 very infrequently anyway. */
1312 || (!range_signed_32 (addend
)
1313 && (alpha_noat_on
|| targreg
== AXP_REG_AT
)))
1319 set_tok_sym (newtok
[1], exp
->X_add_symbol
, 0);
1321 set_tok_preg (newtok
[2], alpha_gp_register
);
1323 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1325 gas_assert (insn
.nfixups
== 1);
1326 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_ELF_LITERAL
;
1327 insn
.sequence
= emit_lituse
= next_sequence_num
--;
1328 #endif /* OBJ_ELF */
1330 /* Find symbol or symbol pointer in link section. */
1332 if (exp
->X_add_symbol
== alpha_evax_proc
->symbol
)
1334 /* Linkage-relative expression. */
1335 set_tok_reg (newtok
[0], targreg
);
1337 if (range_signed_16 (addend
))
1339 set_tok_const (newtok
[1], addend
);
1344 set_tok_const (newtok
[1], 0);
1346 set_tok_preg (newtok
[2], basereg
);
1347 assemble_tokens_to_insn ("lda", newtok
, 3, &insn
);
1351 const char *symname
= S_GET_NAME (exp
->X_add_symbol
);
1352 const char *ptr1
, *ptr2
;
1353 int symlen
= strlen (symname
);
1356 strcmp (ptr2
= &symname
[symlen
- 4], "..lk") == 0))
1358 /* Access to an item whose address is stored in the linkage
1359 section. Just read the address. */
1360 set_tok_reg (newtok
[0], targreg
);
1363 newtok
[1].X_op
= O_subtract
;
1364 newtok
[1].X_op_symbol
= alpha_evax_proc
->symbol
;
1366 set_tok_preg (newtok
[2], basereg
);
1367 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1368 alpha_linkage_symbol
= exp
->X_add_symbol
;
1371 set_tok_const (*poffset
, 0);
1373 if (alpha_flag_replace
&& targreg
== 26)
1375 /* Add a NOP fixup for 'ldX $26,YYY..NAME..lk'. */
1379 /* Build the entry name as 'NAME..en'. */
1380 ptr1
= strstr (symname
, "..") + 2;
1383 ensymname
= XNEWVEC (char, ptr2
- ptr1
+ 5);
1384 memcpy (ensymname
, ptr1
, ptr2
- ptr1
);
1385 memcpy (ensymname
+ (ptr2
- ptr1
), "..en", 5);
1387 gas_assert (insn
.nfixups
+ 1 <= MAX_INSN_FIXUPS
);
1388 insn
.fixups
[insn
.nfixups
].reloc
= BFD_RELOC_ALPHA_NOP
;
1389 ensym
= symbol_find_or_make (ensymname
);
1391 symbol_mark_used (ensym
);
1392 /* The fixup must be the same as the BFD_RELOC_ALPHA_BOH
1393 case in emit_jsrjmp. See B.4.5.2 of the OpenVMS Linker
1395 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_symbol
;
1396 insn
.fixups
[insn
.nfixups
].exp
.X_add_symbol
= ensym
;
1397 insn
.fixups
[insn
.nfixups
].exp
.X_add_number
= 0;
1398 insn
.fixups
[insn
.nfixups
].xtrasym
= alpha_linkage_symbol
;
1399 insn
.fixups
[insn
.nfixups
].procsym
= alpha_evax_proc
->symbol
;
1402 /* ??? Force bsym to be instantiated now, as it will be
1403 too late to do so in tc_gen_reloc. */
1404 symbol_get_bfdsym (exp
->X_add_symbol
);
1406 else if (alpha_flag_replace
&& targreg
== 27)
1408 /* Add a lda fixup for 'ldX $27,YYY.NAME..lk+8'. */
1413 ptr1
= strstr (symname
, "..") + 2;
1416 psymname
= xmemdup0 (ptr1
, ptr2
- ptr1
);
1418 gas_assert (insn
.nfixups
+ 1 <= MAX_INSN_FIXUPS
);
1419 insn
.fixups
[insn
.nfixups
].reloc
= BFD_RELOC_ALPHA_LDA
;
1420 psym
= symbol_find_or_make (psymname
);
1422 symbol_mark_used (psym
);
1423 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_subtract
;
1424 insn
.fixups
[insn
.nfixups
].exp
.X_add_symbol
= psym
;
1425 insn
.fixups
[insn
.nfixups
].exp
.X_op_symbol
= alpha_evax_proc
->symbol
;
1426 insn
.fixups
[insn
.nfixups
].exp
.X_add_number
= 0;
1427 insn
.fixups
[insn
.nfixups
].xtrasym
= alpha_linkage_symbol
;
1428 insn
.fixups
[insn
.nfixups
].procsym
= alpha_evax_proc
->symbol
;
1437 /* Not in the linkage section. Put the value into the linkage
1441 if (!range_signed_32 (addend
))
1442 addend
= sign_extend_32 (addend
);
1443 linkexp
= add_to_link_pool (exp
->X_add_symbol
, 0);
1444 set_tok_reg (newtok
[0], targreg
);
1445 set_tok_sym (newtok
[1], linkexp
, 0);
1446 set_tok_preg (newtok
[2], basereg
);
1447 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1450 #endif /* OBJ_EVAX */
1455 if (basereg
!= alpha_gp_register
&& basereg
!= AXP_REG_ZERO
)
1457 /* Emit "addq r, base, r". */
1459 set_tok_reg (newtok
[1], basereg
);
1460 set_tok_reg (newtok
[2], targreg
);
1461 assemble_tokens ("addq", newtok
, 3, 0);
1472 /* Assume that this difference expression will be resolved to an
1473 absolute value and that that value will fit in 16 bits. */
1475 set_tok_reg (newtok
[0], targreg
);
1477 set_tok_preg (newtok
[2], basereg
);
1478 assemble_tokens (opname
, newtok
, 3, 0);
1481 set_tok_const (*poffset
, 0);
1485 if (exp
->X_add_number
> 0)
1486 as_bad (_("bignum invalid; zero assumed"));
1488 as_bad (_("floating point number invalid; zero assumed"));
1493 as_bad (_("can't handle expression"));
1498 if (!range_signed_32 (addend
))
1504 long seq_num
= next_sequence_num
--;
1507 /* For 64-bit addends, just put it in the literal pool. */
1509 /* Emit "ldq targreg, lit(basereg)". */
1510 litexp
= add_to_link_pool (section_symbol (absolute_section
), addend
);
1511 set_tok_reg (newtok
[0], targreg
);
1512 set_tok_sym (newtok
[1], litexp
, 0);
1513 set_tok_preg (newtok
[2], alpha_gp_register
);
1514 assemble_tokens ("ldq", newtok
, 3, 0);
1517 if (alpha_lit8_section
== NULL
)
1519 create_literal_section (".lit8",
1520 &alpha_lit8_section
,
1521 &alpha_lit8_symbol
);
1524 alpha_lit8_literal
= add_to_literal_pool (alpha_lit8_symbol
, 0x8000,
1525 alpha_lita_section
, 8);
1526 if (alpha_lit8_literal
>= 0x8000)
1527 as_fatal (_("overflow in literal (.lita) table"));
1531 lit
= add_to_literal_pool (NULL
, addend
, alpha_lit8_section
, 8) - 0x8000;
1533 as_fatal (_("overflow in literal (.lit8) table"));
1535 /* Emit "lda litreg, .lit8+0x8000". */
1537 if (targreg
== basereg
)
1540 as_bad (_("macro requires $at register while noat in effect"));
1541 if (targreg
== AXP_REG_AT
)
1542 as_bad (_("macro requires $at while $at in use"));
1544 set_tok_reg (newtok
[0], AXP_REG_AT
);
1547 set_tok_reg (newtok
[0], targreg
);
1549 set_tok_sym (newtok
[1], alpha_lita_symbol
, alpha_lit8_literal
);
1552 set_tok_sym (newtok
[1], alpha_lit8_symbol
, 0x8000);
1554 set_tok_preg (newtok
[2], alpha_gp_register
);
1556 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1558 gas_assert (insn
.nfixups
== 1);
1560 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_LITERAL
;
1563 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_ELF_LITERAL
;
1565 insn
.sequence
= seq_num
;
1569 /* Emit "ldq litreg, lit(litreg)". */
1571 set_tok_const (newtok
[1], lit
);
1572 set_tok_preg (newtok
[2], newtok
[0].X_add_number
);
1574 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1576 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
1577 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
1578 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
1580 insn
.sequence
= seq_num
;
1585 /* Emit "addq litreg, base, target". */
1587 if (basereg
!= AXP_REG_ZERO
)
1589 set_tok_reg (newtok
[1], basereg
);
1590 set_tok_reg (newtok
[2], targreg
);
1591 assemble_tokens ("addq", newtok
, 3, 0);
1593 #endif /* !OBJ_EVAX */
1596 set_tok_const (*poffset
, 0);
1597 *pbasereg
= targreg
;
1601 offsetT low
, high
, extra
, tmp
;
1603 /* For 32-bit operands, break up the addend. */
1605 low
= sign_extend_16 (addend
);
1607 high
= sign_extend_16 (tmp
>> 16);
1609 if (tmp
- (high
<< 16))
1613 high
= sign_extend_16 (tmp
>> 16);
1618 set_tok_reg (newtok
[0], targreg
);
1619 set_tok_preg (newtok
[2], basereg
);
1623 /* Emit "ldah r, extra(r). */
1624 set_tok_const (newtok
[1], extra
);
1625 assemble_tokens ("ldah", newtok
, 3, 0);
1626 set_tok_preg (newtok
[2], basereg
= targreg
);
1631 /* Emit "ldah r, high(r). */
1632 set_tok_const (newtok
[1], high
);
1633 assemble_tokens ("ldah", newtok
, 3, 0);
1635 set_tok_preg (newtok
[2], basereg
);
1638 if ((low
&& !poffset
) || (!poffset
&& basereg
!= targreg
))
1640 /* Emit "lda r, low(base)". */
1641 set_tok_const (newtok
[1], low
);
1642 assemble_tokens ("lda", newtok
, 3, 0);
1648 set_tok_const (*poffset
, low
);
1649 *pbasereg
= basereg
;
1655 /* The lda macro differs from the lda instruction in that it handles
1656 most simple expressions, particularly symbol address loads and
1660 emit_lda (const expressionS
*tok
,
1662 const void * unused ATTRIBUTE_UNUSED
)
1667 basereg
= (tok
[1].X_op
== O_constant
? AXP_REG_ZERO
: alpha_gp_register
);
1669 basereg
= tok
[2].X_add_number
;
1671 (void) load_expression (tok
[0].X_add_number
, &tok
[1], &basereg
, NULL
, "lda");
1674 /* The ldah macro differs from the ldah instruction in that it has $31
1675 as an implied base register. */
1678 emit_ldah (const expressionS
*tok
,
1679 int ntok ATTRIBUTE_UNUSED
,
1680 const void * unused ATTRIBUTE_UNUSED
)
1682 expressionS newtok
[3];
1686 set_tok_preg (newtok
[2], AXP_REG_ZERO
);
1688 assemble_tokens ("ldah", newtok
, 3, 0);
1691 /* Called internally to handle all alignment needs. This takes care
1692 of eliding calls to frag_align if'n the cached current alignment
1693 says we've already got it, as well as taking care of the auto-align
1694 feature wrt labels. */
1700 int force ATTRIBUTE_UNUSED
)
1702 if (alpha_current_align
>= n
)
1707 if (subseg_text_p (now_seg
))
1708 frag_align_code (n
, 0);
1710 frag_align (n
, 0, 0);
1713 frag_align (n
, *pfill
, 0);
1715 alpha_current_align
= n
;
1717 if (label
!= NULL
&& S_GET_SEGMENT (label
) == now_seg
)
1719 symbol_set_frag (label
, frag_now
);
1720 S_SET_VALUE (label
, (valueT
) frag_now_fix ());
1723 record_alignment (now_seg
, n
);
1725 /* ??? If alpha_flag_relax && force && elf, record the requested alignment
1726 in a reloc for the linker to see. */
1729 /* Actually output an instruction with its fixup. */
1732 emit_insn (struct alpha_insn
*insn
)
1737 /* Take care of alignment duties. */
1738 if (alpha_auto_align_on
&& alpha_current_align
< 2)
1739 alpha_align (2, (char *) NULL
, alpha_insn_label
, 0);
1740 if (alpha_current_align
> 2)
1741 alpha_current_align
= 2;
1742 alpha_insn_label
= NULL
;
1744 /* Write out the instruction. */
1746 md_number_to_chars (f
, insn
->insn
, 4);
1749 dwarf2_emit_insn (4);
1752 /* Apply the fixups in order. */
1753 for (i
= 0; i
< insn
->nfixups
; ++i
)
1755 const struct alpha_operand
*operand
= (const struct alpha_operand
*) 0;
1756 struct alpha_fixup
*fixup
= &insn
->fixups
[i
];
1757 struct alpha_reloc_tag
*info
= NULL
;
1761 /* Some fixups are only used internally and so have no howto. */
1762 if ((int) fixup
->reloc
< 0)
1764 operand
= &alpha_operands
[-(int) fixup
->reloc
];
1766 pcrel
= ((operand
->flags
& AXP_OPERAND_RELATIVE
) != 0);
1768 else if (fixup
->reloc
> BFD_RELOC_UNUSED
1769 || fixup
->reloc
== BFD_RELOC_ALPHA_GPDISP_HI16
1770 || fixup
->reloc
== BFD_RELOC_ALPHA_GPDISP_LO16
)
1777 reloc_howto_type
*reloc_howto
=
1778 bfd_reloc_type_lookup (stdoutput
,
1779 (bfd_reloc_code_real_type
) fixup
->reloc
);
1780 gas_assert (reloc_howto
);
1782 size
= bfd_get_reloc_size (reloc_howto
);
1784 switch (fixup
->reloc
)
1787 case BFD_RELOC_ALPHA_NOP
:
1788 case BFD_RELOC_ALPHA_BSR
:
1789 case BFD_RELOC_ALPHA_LDA
:
1790 case BFD_RELOC_ALPHA_BOH
:
1794 gas_assert (size
>= 1 && size
<= 4);
1797 pcrel
= reloc_howto
->pc_relative
;
1800 fixP
= fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, size
,
1801 &fixup
->exp
, pcrel
, (bfd_reloc_code_real_type
) fixup
->reloc
);
1803 /* Turn off complaints that the addend is too large for some fixups,
1804 and copy in the sequence number for the explicit relocations. */
1805 switch (fixup
->reloc
)
1807 case BFD_RELOC_ALPHA_HINT
:
1808 case BFD_RELOC_GPREL32
:
1809 case BFD_RELOC_GPREL16
:
1810 case BFD_RELOC_ALPHA_GPREL_HI16
:
1811 case BFD_RELOC_ALPHA_GPREL_LO16
:
1812 case BFD_RELOC_ALPHA_GOTDTPREL16
:
1813 case BFD_RELOC_ALPHA_DTPREL_HI16
:
1814 case BFD_RELOC_ALPHA_DTPREL_LO16
:
1815 case BFD_RELOC_ALPHA_DTPREL16
:
1816 case BFD_RELOC_ALPHA_GOTTPREL16
:
1817 case BFD_RELOC_ALPHA_TPREL_HI16
:
1818 case BFD_RELOC_ALPHA_TPREL_LO16
:
1819 case BFD_RELOC_ALPHA_TPREL16
:
1820 fixP
->fx_no_overflow
= 1;
1823 case BFD_RELOC_ALPHA_GPDISP_HI16
:
1824 fixP
->fx_no_overflow
= 1;
1825 fixP
->fx_addsy
= section_symbol (now_seg
);
1826 fixP
->fx_offset
= 0;
1828 info
= get_alpha_reloc_tag (insn
->sequence
);
1829 if (++info
->n_master
> 1)
1830 as_bad (_("too many ldah insns for !gpdisp!%ld"), insn
->sequence
);
1831 if (info
->segment
!= now_seg
)
1832 as_bad (_("both insns for !gpdisp!%ld must be in the same section"),
1834 fixP
->tc_fix_data
.info
= info
;
1837 case BFD_RELOC_ALPHA_GPDISP_LO16
:
1838 fixP
->fx_no_overflow
= 1;
1840 info
= get_alpha_reloc_tag (insn
->sequence
);
1841 if (++info
->n_slaves
> 1)
1842 as_bad (_("too many lda insns for !gpdisp!%ld"), insn
->sequence
);
1843 if (info
->segment
!= now_seg
)
1844 as_bad (_("both insns for !gpdisp!%ld must be in the same section"),
1846 fixP
->tc_fix_data
.info
= info
;
1847 info
->slaves
= fixP
;
1850 case BFD_RELOC_ALPHA_LITERAL
:
1851 case BFD_RELOC_ALPHA_ELF_LITERAL
:
1852 fixP
->fx_no_overflow
= 1;
1854 if (insn
->sequence
== 0)
1856 info
= get_alpha_reloc_tag (insn
->sequence
);
1857 info
->master
= fixP
;
1859 if (info
->segment
!= now_seg
)
1860 info
->multi_section_p
= 1;
1861 fixP
->tc_fix_data
.info
= info
;
1865 case DUMMY_RELOC_LITUSE_ADDR
:
1866 fixP
->fx_offset
= LITUSE_ALPHA_ADDR
;
1868 case DUMMY_RELOC_LITUSE_BASE
:
1869 fixP
->fx_offset
= LITUSE_ALPHA_BASE
;
1871 case DUMMY_RELOC_LITUSE_BYTOFF
:
1872 fixP
->fx_offset
= LITUSE_ALPHA_BYTOFF
;
1874 case DUMMY_RELOC_LITUSE_JSR
:
1875 fixP
->fx_offset
= LITUSE_ALPHA_JSR
;
1877 case DUMMY_RELOC_LITUSE_TLSGD
:
1878 fixP
->fx_offset
= LITUSE_ALPHA_TLSGD
;
1880 case DUMMY_RELOC_LITUSE_TLSLDM
:
1881 fixP
->fx_offset
= LITUSE_ALPHA_TLSLDM
;
1883 case DUMMY_RELOC_LITUSE_JSRDIRECT
:
1884 fixP
->fx_offset
= LITUSE_ALPHA_JSRDIRECT
;
1887 fixP
->fx_addsy
= section_symbol (now_seg
);
1888 fixP
->fx_r_type
= BFD_RELOC_ALPHA_LITUSE
;
1890 info
= get_alpha_reloc_tag (insn
->sequence
);
1891 if (fixup
->reloc
== DUMMY_RELOC_LITUSE_TLSGD
)
1892 info
->saw_lu_tlsgd
= 1;
1893 else if (fixup
->reloc
== DUMMY_RELOC_LITUSE_TLSLDM
)
1894 info
->saw_lu_tlsldm
= 1;
1895 if (++info
->n_slaves
> 1)
1897 if (info
->saw_lu_tlsgd
)
1898 as_bad (_("too many lituse insns for !lituse_tlsgd!%ld"),
1900 else if (info
->saw_lu_tlsldm
)
1901 as_bad (_("too many lituse insns for !lituse_tlsldm!%ld"),
1904 fixP
->tc_fix_data
.info
= info
;
1905 fixP
->tc_fix_data
.next_reloc
= info
->slaves
;
1906 info
->slaves
= fixP
;
1907 if (info
->segment
!= now_seg
)
1908 info
->multi_section_p
= 1;
1911 case BFD_RELOC_ALPHA_TLSGD
:
1912 fixP
->fx_no_overflow
= 1;
1914 if (insn
->sequence
== 0)
1916 info
= get_alpha_reloc_tag (insn
->sequence
);
1917 if (info
->saw_tlsgd
)
1918 as_bad (_("duplicate !tlsgd!%ld"), insn
->sequence
);
1919 else if (info
->saw_tlsldm
)
1920 as_bad (_("sequence number in use for !tlsldm!%ld"),
1923 info
->saw_tlsgd
= 1;
1924 fixP
->tc_fix_data
.info
= info
;
1927 case BFD_RELOC_ALPHA_TLSLDM
:
1928 fixP
->fx_no_overflow
= 1;
1930 if (insn
->sequence
== 0)
1932 info
= get_alpha_reloc_tag (insn
->sequence
);
1933 if (info
->saw_tlsldm
)
1934 as_bad (_("duplicate !tlsldm!%ld"), insn
->sequence
);
1935 else if (info
->saw_tlsgd
)
1936 as_bad (_("sequence number in use for !tlsgd!%ld"),
1939 info
->saw_tlsldm
= 1;
1940 fixP
->tc_fix_data
.info
= info
;
1944 case BFD_RELOC_ALPHA_NOP
:
1945 case BFD_RELOC_ALPHA_LDA
:
1946 case BFD_RELOC_ALPHA_BSR
:
1947 case BFD_RELOC_ALPHA_BOH
:
1948 info
= get_alpha_reloc_tag (next_sequence_num
--);
1949 fixP
->tc_fix_data
.info
= info
;
1950 fixP
->tc_fix_data
.info
->sym
= fixup
->xtrasym
;
1951 fixP
->tc_fix_data
.info
->psym
= fixup
->procsym
;
1956 if ((int) fixup
->reloc
< 0)
1958 if (operand
->flags
& AXP_OPERAND_NOOVERFLOW
)
1959 fixP
->fx_no_overflow
= 1;
1966 /* Insert an operand value into an instruction. */
1969 insert_operand (unsigned insn
,
1970 const struct alpha_operand
*operand
,
1975 if (operand
->bits
!= 32 && !(operand
->flags
& AXP_OPERAND_NOOVERFLOW
))
1979 if (operand
->flags
& AXP_OPERAND_SIGNED
)
1981 max
= (1 << (operand
->bits
- 1)) - 1;
1982 min
= -(1 << (operand
->bits
- 1));
1986 max
= (1 << operand
->bits
) - 1;
1990 if (val
< min
|| val
> max
)
1991 as_bad_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1994 if (operand
->insert
)
1996 const char *errmsg
= NULL
;
1998 insn
= (*operand
->insert
) (insn
, val
, &errmsg
);
2000 as_warn ("%s", errmsg
);
2003 insn
|= ((val
& ((1 << operand
->bits
) - 1)) << operand
->shift
);
2008 /* Turn an opcode description and a set of arguments into
2009 an instruction and a fixup. */
2012 assemble_insn (const struct alpha_opcode
*opcode
,
2013 const expressionS
*tok
,
2015 struct alpha_insn
*insn
,
2016 extended_bfd_reloc_code_real_type reloc
)
2018 const struct alpha_operand
*reloc_operand
= NULL
;
2019 const expressionS
*reloc_exp
= NULL
;
2020 const unsigned char *argidx
;
2024 memset (insn
, 0, sizeof (*insn
));
2025 image
= opcode
->opcode
;
2027 for (argidx
= opcode
->operands
; *argidx
; ++argidx
)
2029 const struct alpha_operand
*operand
= &alpha_operands
[*argidx
];
2030 const expressionS
*t
= (const expressionS
*) 0;
2032 if (operand
->flags
& AXP_OPERAND_FAKE
)
2034 /* Fake operands take no value and generate no fixup. */
2035 image
= insert_operand (image
, operand
, 0, NULL
, 0);
2041 switch (operand
->flags
& AXP_OPERAND_OPTIONAL_MASK
)
2043 case AXP_OPERAND_DEFAULT_FIRST
:
2046 case AXP_OPERAND_DEFAULT_SECOND
:
2049 case AXP_OPERAND_DEFAULT_ZERO
:
2051 static expressionS zero_exp
;
2053 zero_exp
.X_op
= O_constant
;
2054 zero_exp
.X_unsigned
= 1;
2069 image
= insert_operand (image
, operand
, regno (t
->X_add_number
),
2074 image
= insert_operand (image
, operand
, t
->X_add_number
, NULL
, 0);
2075 gas_assert (reloc_operand
== NULL
);
2076 reloc_operand
= operand
;
2081 /* This is only 0 for fields that should contain registers,
2082 which means this pattern shouldn't have matched. */
2083 if (operand
->default_reloc
== 0)
2086 /* There is one special case for which an insn receives two
2087 relocations, and thus the user-supplied reloc does not
2088 override the operand reloc. */
2089 if (operand
->default_reloc
== BFD_RELOC_ALPHA_HINT
)
2091 struct alpha_fixup
*fixup
;
2093 if (insn
->nfixups
>= MAX_INSN_FIXUPS
)
2094 as_fatal (_("too many fixups"));
2096 fixup
= &insn
->fixups
[insn
->nfixups
++];
2098 fixup
->reloc
= BFD_RELOC_ALPHA_HINT
;
2102 if (reloc
== BFD_RELOC_UNUSED
)
2103 reloc
= operand
->default_reloc
;
2105 gas_assert (reloc_operand
== NULL
);
2106 reloc_operand
= operand
;
2113 if (reloc
!= BFD_RELOC_UNUSED
)
2115 struct alpha_fixup
*fixup
;
2117 if (insn
->nfixups
>= MAX_INSN_FIXUPS
)
2118 as_fatal (_("too many fixups"));
2120 /* ??? My but this is hacky. But the OSF/1 assembler uses the same
2121 relocation tag for both ldah and lda with gpdisp. Choose the
2122 correct internal relocation based on the opcode. */
2123 if (reloc
== BFD_RELOC_ALPHA_GPDISP
)
2125 if (strcmp (opcode
->name
, "ldah") == 0)
2126 reloc
= BFD_RELOC_ALPHA_GPDISP_HI16
;
2127 else if (strcmp (opcode
->name
, "lda") == 0)
2128 reloc
= BFD_RELOC_ALPHA_GPDISP_LO16
;
2130 as_bad (_("invalid relocation for instruction"));
2133 /* If this is a real relocation (as opposed to a lituse hint), then
2134 the relocation width should match the operand width.
2135 Take care of -MDISP in operand table. */
2136 else if (reloc
< BFD_RELOC_UNUSED
&& reloc
> 0)
2138 reloc_howto_type
*reloc_howto
2139 = bfd_reloc_type_lookup (stdoutput
,
2140 (bfd_reloc_code_real_type
) reloc
);
2141 if (reloc_operand
== NULL
2142 || reloc_howto
->bitsize
!= reloc_operand
->bits
)
2144 as_bad (_("invalid relocation for field"));
2149 fixup
= &insn
->fixups
[insn
->nfixups
++];
2151 fixup
->exp
= *reloc_exp
;
2153 fixup
->exp
.X_op
= O_absent
;
2154 fixup
->reloc
= reloc
;
2160 /* Handle all "simple" integer register loads -- ldq, ldq_l, ldq_u,
2161 etc. They differ from the real instructions in that they do simple
2162 expressions like the lda macro. */
2165 emit_ir_load (const expressionS
*tok
,
2167 const void * opname
)
2171 expressionS newtok
[3];
2172 struct alpha_insn insn
;
2174 = tok
[1].X_add_symbol
? S_GET_NAME (tok
[1].X_add_symbol
): "";
2175 int symlen
= strlen (symname
);
2178 basereg
= (tok
[1].X_op
== O_constant
? AXP_REG_ZERO
: alpha_gp_register
);
2180 basereg
= tok
[2].X_add_number
;
2182 lituse
= load_expression (tok
[0].X_add_number
, &tok
[1],
2183 &basereg
, &newtok
[1], (const char *) opname
);
2185 if (basereg
== alpha_gp_register
&&
2186 (symlen
> 4 && strcmp (&symname
[symlen
- 4], "..lk") == 0))
2190 set_tok_preg (newtok
[2], basereg
);
2192 assemble_tokens_to_insn ((const char *) opname
, newtok
, 3, &insn
);
2196 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2197 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2198 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2200 insn
.sequence
= lituse
;
2206 /* Handle fp register loads, and both integer and fp register stores.
2207 Again, we handle simple expressions. */
2210 emit_loadstore (const expressionS
*tok
,
2212 const void * opname
)
2216 expressionS newtok
[3];
2217 struct alpha_insn insn
;
2220 basereg
= (tok
[1].X_op
== O_constant
? AXP_REG_ZERO
: alpha_gp_register
);
2222 basereg
= tok
[2].X_add_number
;
2224 if (tok
[1].X_op
!= O_constant
|| !range_signed_16 (tok
[1].X_add_number
))
2227 as_bad (_("macro requires $at register while noat in effect"));
2229 lituse
= load_expression (AXP_REG_AT
, &tok
[1],
2230 &basereg
, &newtok
[1], (const char *) opname
);
2239 set_tok_preg (newtok
[2], basereg
);
2241 assemble_tokens_to_insn ((const char *) opname
, newtok
, 3, &insn
);
2245 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2246 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2247 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2249 insn
.sequence
= lituse
;
2255 /* Load a half-word or byte as an unsigned value. */
2258 emit_ldXu (const expressionS
*tok
,
2260 const void * vlgsize
)
2262 if (alpha_target
& AXP_OPCODE_BWX
)
2263 emit_ir_load (tok
, ntok
, ldXu_op
[(long) vlgsize
]);
2266 expressionS newtok
[3];
2267 struct alpha_insn insn
;
2272 as_bad (_("macro requires $at register while noat in effect"));
2275 basereg
= (tok
[1].X_op
== O_constant
2276 ? AXP_REG_ZERO
: alpha_gp_register
);
2278 basereg
= tok
[2].X_add_number
;
2280 /* Emit "lda $at, exp". */
2281 lituse
= load_expression (AXP_REG_AT
, &tok
[1], &basereg
, NULL
, "lda");
2283 /* Emit "ldq_u targ, 0($at)". */
2285 set_tok_const (newtok
[1], 0);
2286 set_tok_preg (newtok
[2], basereg
);
2287 assemble_tokens_to_insn ("ldq_u", newtok
, 3, &insn
);
2291 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2292 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2293 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2295 insn
.sequence
= lituse
;
2300 /* Emit "extXl targ, $at, targ". */
2301 set_tok_reg (newtok
[1], basereg
);
2302 newtok
[2] = newtok
[0];
2303 assemble_tokens_to_insn (extXl_op
[(long) vlgsize
], newtok
, 3, &insn
);
2307 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2308 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BYTOFF
;
2309 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2311 insn
.sequence
= lituse
;
2318 /* Load a half-word or byte as a signed value. */
2321 emit_ldX (const expressionS
*tok
,
2323 const void * vlgsize
)
2325 emit_ldXu (tok
, ntok
, vlgsize
);
2326 assemble_tokens (sextX_op
[(long) vlgsize
], tok
, 1, 1);
2329 /* Load an integral value from an unaligned address as an unsigned
2333 emit_uldXu (const expressionS
*tok
,
2335 const void * vlgsize
)
2337 long lgsize
= (long) vlgsize
;
2338 expressionS newtok
[3];
2341 as_bad (_("macro requires $at register while noat in effect"));
2343 /* Emit "lda $at, exp". */
2344 memcpy (newtok
, tok
, sizeof (expressionS
) * ntok
);
2345 newtok
[0].X_add_number
= AXP_REG_AT
;
2346 assemble_tokens ("lda", newtok
, ntok
, 1);
2348 /* Emit "ldq_u $t9, 0($at)". */
2349 set_tok_reg (newtok
[0], AXP_REG_T9
);
2350 set_tok_const (newtok
[1], 0);
2351 set_tok_preg (newtok
[2], AXP_REG_AT
);
2352 assemble_tokens ("ldq_u", newtok
, 3, 1);
2354 /* Emit "ldq_u $t10, size-1($at)". */
2355 set_tok_reg (newtok
[0], AXP_REG_T10
);
2356 set_tok_const (newtok
[1], (1 << lgsize
) - 1);
2357 assemble_tokens ("ldq_u", newtok
, 3, 1);
2359 /* Emit "extXl $t9, $at, $t9". */
2360 set_tok_reg (newtok
[0], AXP_REG_T9
);
2361 set_tok_reg (newtok
[1], AXP_REG_AT
);
2362 set_tok_reg (newtok
[2], AXP_REG_T9
);
2363 assemble_tokens (extXl_op
[lgsize
], newtok
, 3, 1);
2365 /* Emit "extXh $t10, $at, $t10". */
2366 set_tok_reg (newtok
[0], AXP_REG_T10
);
2367 set_tok_reg (newtok
[2], AXP_REG_T10
);
2368 assemble_tokens (extXh_op
[lgsize
], newtok
, 3, 1);
2370 /* Emit "or $t9, $t10, targ". */
2371 set_tok_reg (newtok
[0], AXP_REG_T9
);
2372 set_tok_reg (newtok
[1], AXP_REG_T10
);
2374 assemble_tokens ("or", newtok
, 3, 1);
2377 /* Load an integral value from an unaligned address as a signed value.
2378 Note that quads should get funneled to the unsigned load since we
2379 don't have to do the sign extension. */
2382 emit_uldX (const expressionS
*tok
,
2384 const void * vlgsize
)
2386 emit_uldXu (tok
, ntok
, vlgsize
);
2387 assemble_tokens (sextX_op
[(long) vlgsize
], tok
, 1, 1);
2390 /* Implement the ldil macro. */
2393 emit_ldil (const expressionS
*tok
,
2395 const void * unused ATTRIBUTE_UNUSED
)
2397 expressionS newtok
[2];
2399 memcpy (newtok
, tok
, sizeof (newtok
));
2400 newtok
[1].X_add_number
= sign_extend_32 (tok
[1].X_add_number
);
2402 assemble_tokens ("lda", newtok
, ntok
, 1);
2405 /* Store a half-word or byte. */
2408 emit_stX (const expressionS
*tok
,
2410 const void * vlgsize
)
2412 int lgsize
= (int) (long) vlgsize
;
2414 if (alpha_target
& AXP_OPCODE_BWX
)
2415 emit_loadstore (tok
, ntok
, stX_op
[lgsize
]);
2418 expressionS newtok
[3];
2419 struct alpha_insn insn
;
2424 as_bad (_("macro requires $at register while noat in effect"));
2427 basereg
= (tok
[1].X_op
== O_constant
2428 ? AXP_REG_ZERO
: alpha_gp_register
);
2430 basereg
= tok
[2].X_add_number
;
2432 /* Emit "lda $at, exp". */
2433 lituse
= load_expression (AXP_REG_AT
, &tok
[1], &basereg
, NULL
, "lda");
2435 /* Emit "ldq_u $t9, 0($at)". */
2436 set_tok_reg (newtok
[0], AXP_REG_T9
);
2437 set_tok_const (newtok
[1], 0);
2438 set_tok_preg (newtok
[2], basereg
);
2439 assemble_tokens_to_insn ("ldq_u", newtok
, 3, &insn
);
2443 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2444 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2445 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2447 insn
.sequence
= lituse
;
2452 /* Emit "insXl src, $at, $t10". */
2454 set_tok_reg (newtok
[1], basereg
);
2455 set_tok_reg (newtok
[2], AXP_REG_T10
);
2456 assemble_tokens_to_insn (insXl_op
[lgsize
], newtok
, 3, &insn
);
2460 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2461 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BYTOFF
;
2462 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2464 insn
.sequence
= lituse
;
2469 /* Emit "mskXl $t9, $at, $t9". */
2470 set_tok_reg (newtok
[0], AXP_REG_T9
);
2471 newtok
[2] = newtok
[0];
2472 assemble_tokens_to_insn (mskXl_op
[lgsize
], newtok
, 3, &insn
);
2476 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2477 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BYTOFF
;
2478 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2480 insn
.sequence
= lituse
;
2485 /* Emit "or $t9, $t10, $t9". */
2486 set_tok_reg (newtok
[1], AXP_REG_T10
);
2487 assemble_tokens ("or", newtok
, 3, 1);
2489 /* Emit "stq_u $t9, 0($at). */
2490 set_tok_const(newtok
[1], 0);
2491 set_tok_preg (newtok
[2], AXP_REG_AT
);
2492 assemble_tokens_to_insn ("stq_u", newtok
, 3, &insn
);
2496 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2497 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2498 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2500 insn
.sequence
= lituse
;
2507 /* Store an integer to an unaligned address. */
2510 emit_ustX (const expressionS
*tok
,
2512 const void * vlgsize
)
2514 int lgsize
= (int) (long) vlgsize
;
2515 expressionS newtok
[3];
2517 /* Emit "lda $at, exp". */
2518 memcpy (newtok
, tok
, sizeof (expressionS
) * ntok
);
2519 newtok
[0].X_add_number
= AXP_REG_AT
;
2520 assemble_tokens ("lda", newtok
, ntok
, 1);
2522 /* Emit "ldq_u $9, 0($at)". */
2523 set_tok_reg (newtok
[0], AXP_REG_T9
);
2524 set_tok_const (newtok
[1], 0);
2525 set_tok_preg (newtok
[2], AXP_REG_AT
);
2526 assemble_tokens ("ldq_u", newtok
, 3, 1);
2528 /* Emit "ldq_u $10, size-1($at)". */
2529 set_tok_reg (newtok
[0], AXP_REG_T10
);
2530 set_tok_const (newtok
[1], (1 << lgsize
) - 1);
2531 assemble_tokens ("ldq_u", newtok
, 3, 1);
2533 /* Emit "insXl src, $at, $t11". */
2535 set_tok_reg (newtok
[1], AXP_REG_AT
);
2536 set_tok_reg (newtok
[2], AXP_REG_T11
);
2537 assemble_tokens (insXl_op
[lgsize
], newtok
, 3, 1);
2539 /* Emit "insXh src, $at, $t12". */
2540 set_tok_reg (newtok
[2], AXP_REG_T12
);
2541 assemble_tokens (insXh_op
[lgsize
], newtok
, 3, 1);
2543 /* Emit "mskXl $t9, $at, $t9". */
2544 set_tok_reg (newtok
[0], AXP_REG_T9
);
2545 newtok
[2] = newtok
[0];
2546 assemble_tokens (mskXl_op
[lgsize
], newtok
, 3, 1);
2548 /* Emit "mskXh $t10, $at, $t10". */
2549 set_tok_reg (newtok
[0], AXP_REG_T10
);
2550 newtok
[2] = newtok
[0];
2551 assemble_tokens (mskXh_op
[lgsize
], newtok
, 3, 1);
2553 /* Emit "or $t9, $t11, $t9". */
2554 set_tok_reg (newtok
[0], AXP_REG_T9
);
2555 set_tok_reg (newtok
[1], AXP_REG_T11
);
2556 newtok
[2] = newtok
[0];
2557 assemble_tokens ("or", newtok
, 3, 1);
2559 /* Emit "or $t10, $t12, $t10". */
2560 set_tok_reg (newtok
[0], AXP_REG_T10
);
2561 set_tok_reg (newtok
[1], AXP_REG_T12
);
2562 newtok
[2] = newtok
[0];
2563 assemble_tokens ("or", newtok
, 3, 1);
2565 /* Emit "stq_u $t10, size-1($at)". */
2566 set_tok_reg (newtok
[0], AXP_REG_T10
);
2567 set_tok_const (newtok
[1], (1 << lgsize
) - 1);
2568 set_tok_preg (newtok
[2], AXP_REG_AT
);
2569 assemble_tokens ("stq_u", newtok
, 3, 1);
2571 /* Emit "stq_u $t9, 0($at)". */
2572 set_tok_reg (newtok
[0], AXP_REG_T9
);
2573 set_tok_const (newtok
[1], 0);
2574 assemble_tokens ("stq_u", newtok
, 3, 1);
2577 /* Sign extend a half-word or byte. The 32-bit sign extend is
2578 implemented as "addl $31, $r, $t" in the opcode table. */
2581 emit_sextX (const expressionS
*tok
,
2583 const void * vlgsize
)
2585 long lgsize
= (long) vlgsize
;
2587 if (alpha_target
& AXP_OPCODE_BWX
)
2588 assemble_tokens (sextX_op
[lgsize
], tok
, ntok
, 0);
2591 int bitshift
= 64 - 8 * (1 << lgsize
);
2592 expressionS newtok
[3];
2594 /* Emit "sll src,bits,dst". */
2596 set_tok_const (newtok
[1], bitshift
);
2597 newtok
[2] = tok
[ntok
- 1];
2598 assemble_tokens ("sll", newtok
, 3, 1);
2600 /* Emit "sra dst,bits,dst". */
2601 newtok
[0] = newtok
[2];
2602 assemble_tokens ("sra", newtok
, 3, 1);
2606 /* Implement the division and modulus macros. */
2610 /* Make register usage like in normal procedure call.
2611 Don't clobber PV and RA. */
2614 emit_division (const expressionS
*tok
,
2616 const void * symname
)
2618 /* DIVISION and MODULUS. Yech.
2623 mov x,R16 # if x != R16
2624 mov y,R17 # if y != R17
2629 with appropriate optimizations if R0,R16,R17 are the registers
2630 specified by the compiler. */
2634 expressionS newtok
[3];
2636 xr
= regno (tok
[0].X_add_number
);
2637 yr
= regno (tok
[1].X_add_number
);
2642 rr
= regno (tok
[2].X_add_number
);
2644 /* Move the operands into the right place. */
2645 if (yr
== AXP_REG_R16
&& xr
== AXP_REG_R17
)
2647 /* They are in exactly the wrong order -- swap through AT. */
2649 as_bad (_("macro requires $at register while noat in effect"));
2651 set_tok_reg (newtok
[0], AXP_REG_R16
);
2652 set_tok_reg (newtok
[1], AXP_REG_AT
);
2653 assemble_tokens ("mov", newtok
, 2, 1);
2655 set_tok_reg (newtok
[0], AXP_REG_R17
);
2656 set_tok_reg (newtok
[1], AXP_REG_R16
);
2657 assemble_tokens ("mov", newtok
, 2, 1);
2659 set_tok_reg (newtok
[0], AXP_REG_AT
);
2660 set_tok_reg (newtok
[1], AXP_REG_R17
);
2661 assemble_tokens ("mov", newtok
, 2, 1);
2665 if (yr
== AXP_REG_R16
)
2667 set_tok_reg (newtok
[0], AXP_REG_R16
);
2668 set_tok_reg (newtok
[1], AXP_REG_R17
);
2669 assemble_tokens ("mov", newtok
, 2, 1);
2672 if (xr
!= AXP_REG_R16
)
2674 set_tok_reg (newtok
[0], xr
);
2675 set_tok_reg (newtok
[1], AXP_REG_R16
);
2676 assemble_tokens ("mov", newtok
, 2, 1);
2679 if (yr
!= AXP_REG_R16
&& yr
!= AXP_REG_R17
)
2681 set_tok_reg (newtok
[0], yr
);
2682 set_tok_reg (newtok
[1], AXP_REG_R17
);
2683 assemble_tokens ("mov", newtok
, 2, 1);
2687 sym
= symbol_find_or_make ((const char *) symname
);
2689 set_tok_reg (newtok
[0], AXP_REG_AT
);
2690 set_tok_sym (newtok
[1], sym
, 0);
2691 assemble_tokens ("lda", newtok
, 2, 1);
2693 /* Call the division routine. */
2694 set_tok_reg (newtok
[0], AXP_REG_AT
);
2695 set_tok_cpreg (newtok
[1], AXP_REG_AT
);
2696 set_tok_const (newtok
[2], 0);
2697 assemble_tokens ("jsr", newtok
, 3, 1);
2699 /* Move the result to the right place. */
2700 if (rr
!= AXP_REG_R0
)
2702 set_tok_reg (newtok
[0], AXP_REG_R0
);
2703 set_tok_reg (newtok
[1], rr
);
2704 assemble_tokens ("mov", newtok
, 2, 1);
2708 #else /* !OBJ_EVAX */
2711 emit_division (const expressionS
*tok
,
2713 const void * symname
)
2715 /* DIVISION and MODULUS. Yech.
2725 with appropriate optimizations if t10,t11,t12 are the registers
2726 specified by the compiler. */
2730 expressionS newtok
[3];
2732 xr
= regno (tok
[0].X_add_number
);
2733 yr
= regno (tok
[1].X_add_number
);
2738 rr
= regno (tok
[2].X_add_number
);
2740 sym
= symbol_find_or_make ((const char *) symname
);
2742 /* Move the operands into the right place. */
2743 if (yr
== AXP_REG_T10
&& xr
== AXP_REG_T11
)
2745 /* They are in exactly the wrong order -- swap through AT. */
2747 as_bad (_("macro requires $at register while noat in effect"));
2749 set_tok_reg (newtok
[0], AXP_REG_T10
);
2750 set_tok_reg (newtok
[1], AXP_REG_AT
);
2751 assemble_tokens ("mov", newtok
, 2, 1);
2753 set_tok_reg (newtok
[0], AXP_REG_T11
);
2754 set_tok_reg (newtok
[1], AXP_REG_T10
);
2755 assemble_tokens ("mov", newtok
, 2, 1);
2757 set_tok_reg (newtok
[0], AXP_REG_AT
);
2758 set_tok_reg (newtok
[1], AXP_REG_T11
);
2759 assemble_tokens ("mov", newtok
, 2, 1);
2763 if (yr
== AXP_REG_T10
)
2765 set_tok_reg (newtok
[0], AXP_REG_T10
);
2766 set_tok_reg (newtok
[1], AXP_REG_T11
);
2767 assemble_tokens ("mov", newtok
, 2, 1);
2770 if (xr
!= AXP_REG_T10
)
2772 set_tok_reg (newtok
[0], xr
);
2773 set_tok_reg (newtok
[1], AXP_REG_T10
);
2774 assemble_tokens ("mov", newtok
, 2, 1);
2777 if (yr
!= AXP_REG_T10
&& yr
!= AXP_REG_T11
)
2779 set_tok_reg (newtok
[0], yr
);
2780 set_tok_reg (newtok
[1], AXP_REG_T11
);
2781 assemble_tokens ("mov", newtok
, 2, 1);
2785 /* Call the division routine. */
2786 set_tok_reg (newtok
[0], AXP_REG_T9
);
2787 set_tok_sym (newtok
[1], sym
, 0);
2788 assemble_tokens ("jsr", newtok
, 2, 1);
2790 /* Reload the GP register. */
2794 #if defined(OBJ_ECOFF) || defined(OBJ_ELF)
2795 set_tok_reg (newtok
[0], alpha_gp_register
);
2796 set_tok_const (newtok
[1], 0);
2797 set_tok_preg (newtok
[2], AXP_REG_T9
);
2798 assemble_tokens ("ldgp", newtok
, 3, 1);
2801 /* Move the result to the right place. */
2802 if (rr
!= AXP_REG_T12
)
2804 set_tok_reg (newtok
[0], AXP_REG_T12
);
2805 set_tok_reg (newtok
[1], rr
);
2806 assemble_tokens ("mov", newtok
, 2, 1);
2810 #endif /* !OBJ_EVAX */
2812 /* The jsr and jmp macros differ from their instruction counterparts
2813 in that they can load the target address and default most
2817 emit_jsrjmp (const expressionS
*tok
,
2819 const void * vopname
)
2821 const char *opname
= (const char *) vopname
;
2822 struct alpha_insn insn
;
2823 expressionS newtok
[3];
2827 if (tokidx
< ntok
&& tok
[tokidx
].X_op
== O_register
)
2828 r
= regno (tok
[tokidx
++].X_add_number
);
2830 r
= strcmp (opname
, "jmp") == 0 ? AXP_REG_ZERO
: AXP_REG_RA
;
2832 set_tok_reg (newtok
[0], r
);
2834 if (tokidx
< ntok
&&
2835 (tok
[tokidx
].X_op
== O_pregister
|| tok
[tokidx
].X_op
== O_cpregister
))
2836 r
= regno (tok
[tokidx
++].X_add_number
);
2838 /* Keep register if jsr $n.<sym>. */
2842 int basereg
= alpha_gp_register
;
2843 lituse
= load_expression (r
= AXP_REG_PV
, &tok
[tokidx
],
2844 &basereg
, NULL
, opname
);
2848 set_tok_cpreg (newtok
[1], r
);
2852 newtok
[2] = tok
[tokidx
];
2855 set_tok_const (newtok
[2], 0);
2857 assemble_tokens_to_insn (opname
, newtok
, 3, &insn
);
2861 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2862 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_JSR
;
2863 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2865 insn
.sequence
= lituse
;
2869 if (alpha_flag_replace
2871 && tok
[tokidx
].X_add_symbol
2872 && alpha_linkage_symbol
)
2874 /* Create a BOH reloc for 'jsr $27,NAME'. */
2875 const char *symname
= S_GET_NAME (tok
[tokidx
].X_add_symbol
);
2876 int symlen
= strlen (symname
);
2879 /* Build the entry name as 'NAME..en'. */
2880 ensymname
= XNEWVEC (char, symlen
+ 5);
2881 memcpy (ensymname
, symname
, symlen
);
2882 memcpy (ensymname
+ symlen
, "..en", 5);
2884 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2885 if (insn
.nfixups
> 0)
2887 memmove (&insn
.fixups
[1], &insn
.fixups
[0],
2888 sizeof(struct alpha_fixup
) * insn
.nfixups
);
2891 /* The fixup must be the same as the BFD_RELOC_ALPHA_NOP
2892 case in load_expression. See B.4.5.2 of the OpenVMS
2893 Linker Utility Manual. */
2894 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_BOH
;
2895 insn
.fixups
[0].exp
.X_op
= O_symbol
;
2896 insn
.fixups
[0].exp
.X_add_symbol
= symbol_find_or_make (ensymname
);
2897 insn
.fixups
[0].exp
.X_add_number
= 0;
2898 insn
.fixups
[0].xtrasym
= alpha_linkage_symbol
;
2899 insn
.fixups
[0].procsym
= alpha_evax_proc
->symbol
;
2901 alpha_linkage_symbol
= 0;
2909 /* The ret and jcr instructions differ from their instruction
2910 counterparts in that everything can be defaulted. */
2913 emit_retjcr (const expressionS
*tok
,
2915 const void * vopname
)
2917 const char *opname
= (const char *) vopname
;
2918 expressionS newtok
[3];
2921 if (tokidx
< ntok
&& tok
[tokidx
].X_op
== O_register
)
2922 r
= regno (tok
[tokidx
++].X_add_number
);
2926 set_tok_reg (newtok
[0], r
);
2928 if (tokidx
< ntok
&&
2929 (tok
[tokidx
].X_op
== O_pregister
|| tok
[tokidx
].X_op
== O_cpregister
))
2930 r
= regno (tok
[tokidx
++].X_add_number
);
2934 set_tok_cpreg (newtok
[1], r
);
2937 newtok
[2] = tok
[tokidx
];
2939 set_tok_const (newtok
[2], strcmp (opname
, "ret") == 0);
2941 assemble_tokens (opname
, newtok
, 3, 0);
2944 /* Implement the ldgp macro. */
2947 emit_ldgp (const expressionS
*tok ATTRIBUTE_UNUSED
,
2948 int ntok ATTRIBUTE_UNUSED
,
2949 const void * unused ATTRIBUTE_UNUSED
)
2954 #if defined(OBJ_ECOFF) || defined(OBJ_ELF)
2955 /* from "ldgp r1,n(r2)", generate "ldah r1,X(R2); lda r1,Y(r1)"
2956 with appropriate constants and relocations. */
2957 struct alpha_insn insn
;
2958 expressionS newtok
[3];
2962 if (regno (tok
[2].X_add_number
) == AXP_REG_PV
)
2963 ecoff_set_gp_prolog_size (0);
2967 set_tok_const (newtok
[1], 0);
2970 assemble_tokens_to_insn ("ldah", newtok
, 3, &insn
);
2975 if (addend
.X_op
!= O_constant
)
2976 as_bad (_("can not resolve expression"));
2977 addend
.X_op
= O_symbol
;
2978 addend
.X_add_symbol
= alpha_gp_symbol
;
2982 insn
.fixups
[0].exp
= addend
;
2983 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_GPDISP_HI16
;
2984 insn
.sequence
= next_sequence_num
;
2988 set_tok_preg (newtok
[2], tok
[0].X_add_number
);
2990 assemble_tokens_to_insn ("lda", newtok
, 3, &insn
);
2993 addend
.X_add_number
+= 4;
2997 insn
.fixups
[0].exp
= addend
;
2998 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_GPDISP_LO16
;
2999 insn
.sequence
= next_sequence_num
--;
3002 #endif /* OBJ_ECOFF || OBJ_ELF */
3005 /* The macro table. */
3007 static const struct alpha_macro alpha_macros
[] =
3009 /* Load/Store macros. */
3010 { "lda", emit_lda
, NULL
,
3011 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3012 { "ldah", emit_ldah
, NULL
,
3013 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
} },
3015 { "ldl", emit_ir_load
, "ldl",
3016 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3017 { "ldl_l", emit_ir_load
, "ldl_l",
3018 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3019 { "ldq", emit_ir_load
, "ldq",
3020 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3021 { "ldq_l", emit_ir_load
, "ldq_l",
3022 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3023 { "ldq_u", emit_ir_load
, "ldq_u",
3024 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3025 { "ldf", emit_loadstore
, "ldf",
3026 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3027 { "ldg", emit_loadstore
, "ldg",
3028 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3029 { "lds", emit_loadstore
, "lds",
3030 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3031 { "ldt", emit_loadstore
, "ldt",
3032 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3034 { "ldb", emit_ldX
, (void *) 0,
3035 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3036 { "ldbu", emit_ldXu
, (void *) 0,
3037 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3038 { "ldw", emit_ldX
, (void *) 1,
3039 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3040 { "ldwu", emit_ldXu
, (void *) 1,
3041 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3043 { "uldw", emit_uldX
, (void *) 1,
3044 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3045 { "uldwu", emit_uldXu
, (void *) 1,
3046 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3047 { "uldl", emit_uldX
, (void *) 2,
3048 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3049 { "uldlu", emit_uldXu
, (void *) 2,
3050 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3051 { "uldq", emit_uldXu
, (void *) 3,
3052 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3054 { "ldgp", emit_ldgp
, NULL
,
3055 { MACRO_IR
, MACRO_EXP
, MACRO_PIR
, MACRO_EOA
} },
3057 { "ldi", emit_lda
, NULL
,
3058 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
} },
3059 { "ldil", emit_ldil
, NULL
,
3060 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
} },
3061 { "ldiq", emit_lda
, NULL
,
3062 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
} },
3064 { "stl", emit_loadstore
, "stl",
3065 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3066 { "stl_c", emit_loadstore
, "stl_c",
3067 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3068 { "stq", emit_loadstore
, "stq",
3069 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3070 { "stq_c", emit_loadstore
, "stq_c",
3071 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3072 { "stq_u", emit_loadstore
, "stq_u",
3073 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3074 { "stf", emit_loadstore
, "stf",
3075 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3076 { "stg", emit_loadstore
, "stg",
3077 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3078 { "sts", emit_loadstore
, "sts",
3079 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3080 { "stt", emit_loadstore
, "stt",
3081 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3083 { "stb", emit_stX
, (void *) 0,
3084 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3085 { "stw", emit_stX
, (void *) 1,
3086 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3087 { "ustw", emit_ustX
, (void *) 1,
3088 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3089 { "ustl", emit_ustX
, (void *) 2,
3090 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3091 { "ustq", emit_ustX
, (void *) 3,
3092 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3094 /* Arithmetic macros. */
3096 { "sextb", emit_sextX
, (void *) 0,
3097 { MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3098 MACRO_IR
, MACRO_EOA
,
3099 /* MACRO_EXP, MACRO_IR, MACRO_EOA */ } },
3100 { "sextw", emit_sextX
, (void *) 1,
3101 { MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3102 MACRO_IR
, MACRO_EOA
,
3103 /* MACRO_EXP, MACRO_IR, MACRO_EOA */ } },
3105 { "divl", emit_division
, "__divl",
3106 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3107 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3108 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3109 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3110 { "divlu", emit_division
, "__divlu",
3111 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3112 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3113 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3114 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3115 { "divq", emit_division
, "__divq",
3116 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3117 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3118 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3119 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3120 { "divqu", emit_division
, "__divqu",
3121 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3122 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3123 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3124 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3125 { "reml", emit_division
, "__reml",
3126 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3127 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3128 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3129 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3130 { "remlu", emit_division
, "__remlu",
3131 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3132 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3133 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3134 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3135 { "remq", emit_division
, "__remq",
3136 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3137 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3138 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3139 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3140 { "remqu", emit_division
, "__remqu",
3141 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3142 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3143 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3144 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3146 { "jsr", emit_jsrjmp
, "jsr",
3147 { MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3148 MACRO_PIR
, MACRO_EOA
,
3149 MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3150 MACRO_EXP
, MACRO_EOA
} },
3151 { "jmp", emit_jsrjmp
, "jmp",
3152 { MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3153 MACRO_PIR
, MACRO_EOA
,
3154 MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3155 MACRO_EXP
, MACRO_EOA
} },
3156 { "ret", emit_retjcr
, "ret",
3157 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3158 MACRO_IR
, MACRO_EOA
,
3159 MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3160 MACRO_PIR
, MACRO_EOA
,
3161 MACRO_EXP
, MACRO_EOA
,
3163 { "jcr", emit_retjcr
, "jcr",
3164 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3165 MACRO_IR
, MACRO_EOA
,
3166 MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3167 MACRO_PIR
, MACRO_EOA
,
3168 MACRO_EXP
, MACRO_EOA
,
3170 { "jsr_coroutine", emit_retjcr
, "jcr",
3171 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3172 MACRO_IR
, MACRO_EOA
,
3173 MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3174 MACRO_PIR
, MACRO_EOA
,
3175 MACRO_EXP
, MACRO_EOA
,
3179 static const unsigned int alpha_num_macros
3180 = sizeof (alpha_macros
) / sizeof (*alpha_macros
);
3182 /* Search forward through all variants of a macro looking for a syntax
3185 static const struct alpha_macro
*
3186 find_macro_match (const struct alpha_macro
*first_macro
,
3187 const expressionS
*tok
,
3191 const struct alpha_macro
*macro
= first_macro
;
3196 const enum alpha_macro_arg
*arg
= macro
->argsets
;
3210 /* Index register. */
3212 if (tokidx
>= ntok
|| tok
[tokidx
].X_op
!= O_register
3213 || !is_ir_num (tok
[tokidx
].X_add_number
))
3218 /* Parenthesized index register. */
3220 if (tokidx
>= ntok
|| tok
[tokidx
].X_op
!= O_pregister
3221 || !is_ir_num (tok
[tokidx
].X_add_number
))
3226 /* Optional parenthesized index register. */
3228 if (tokidx
< ntok
&& tok
[tokidx
].X_op
== O_pregister
3229 && is_ir_num (tok
[tokidx
].X_add_number
))
3233 /* Leading comma with a parenthesized index register. */
3235 if (tokidx
>= ntok
|| tok
[tokidx
].X_op
!= O_cpregister
3236 || !is_ir_num (tok
[tokidx
].X_add_number
))
3241 /* Floating point register. */
3243 if (tokidx
>= ntok
|| tok
[tokidx
].X_op
!= O_register
3244 || !is_fpr_num (tok
[tokidx
].X_add_number
))
3249 /* Normal expression. */
3253 switch (tok
[tokidx
].X_op
)
3262 case O_lituse_bytoff
:
3278 while (*arg
!= MACRO_EOA
)
3286 while (++macro
- alpha_macros
< (int) alpha_num_macros
3287 && !strcmp (macro
->name
, first_macro
->name
));
3292 /* Given an opcode name and a pre-tokenized set of arguments, take the
3293 opcode all the way through emission. */
3296 assemble_tokens (const char *opname
,
3297 const expressionS
*tok
,
3299 int local_macros_on
)
3301 int found_something
= 0;
3302 const struct alpha_opcode
*opcode
;
3303 const struct alpha_macro
*macro
;
3305 extended_bfd_reloc_code_real_type reloc
= BFD_RELOC_UNUSED
;
3308 /* If a user-specified relocation is present, this is not a macro. */
3309 if (ntok
&& USER_RELOC_P (tok
[ntok
- 1].X_op
))
3311 reloc
= ALPHA_RELOC_TABLE (tok
[ntok
- 1].X_op
)->reloc
;
3316 if (local_macros_on
)
3318 macro
= ((const struct alpha_macro
*)
3319 str_hash_find (alpha_macro_hash
, opname
));
3322 found_something
= 1;
3323 macro
= find_macro_match (macro
, tok
, &ntok
);
3326 (*macro
->emit
) (tok
, ntok
, macro
->arg
);
3332 /* Search opcodes. */
3333 opcode
= (const struct alpha_opcode
*) str_hash_find (alpha_opcode_hash
, opname
);
3336 found_something
= 1;
3337 opcode
= find_opcode_match (opcode
, tok
, &ntok
, &cpumatch
);
3340 struct alpha_insn insn
;
3341 assemble_insn (opcode
, tok
, ntok
, &insn
, reloc
);
3343 /* Copy the sequence number for the reloc from the reloc token. */
3344 if (reloc
!= BFD_RELOC_UNUSED
)
3345 insn
.sequence
= tok
[ntok
].X_add_number
;
3352 if (found_something
)
3355 as_bad (_("inappropriate arguments for opcode `%s'"), opname
);
3357 as_bad (_("opcode `%s' not supported for target %s"), opname
,
3361 as_bad (_("unknown opcode `%s'"), opname
);
3366 /* Add sym+addend to link pool.
3367 Return offset from current procedure value (pv) to entry in link pool.
3369 Add new fixup only if offset isn't 16bit. */
3372 add_to_link_pool (symbolS
*sym
, offsetT addend
)
3375 segT current_section
= now_seg
;
3376 int current_subsec
= now_subseg
;
3378 segment_info_type
*seginfo
= seg_info (alpha_link_section
);
3380 symbolS
*linksym
, *expsym
;
3383 basesym
= alpha_evax_proc
->symbol
;
3385 /* @@ This assumes all entries in a given section will be of the same
3386 size... Probably correct, but unwise to rely on. */
3387 /* This must always be called with the same subsegment. */
3389 if (seginfo
->frchainP
)
3390 for (fixp
= seginfo
->frchainP
->fix_root
;
3391 fixp
!= (fixS
*) NULL
;
3392 fixp
= fixp
->fx_next
)
3394 if (fixp
->fx_addsy
== sym
3395 && fixp
->fx_offset
== (valueT
)addend
3396 && fixp
->tc_fix_data
.info
3397 && fixp
->tc_fix_data
.info
->sym
3398 && symbol_symbolS (fixp
->tc_fix_data
.info
->sym
)
3399 && (symbol_get_value_expression (fixp
->tc_fix_data
.info
->sym
)
3400 ->X_op_symbol
== basesym
))
3401 return fixp
->tc_fix_data
.info
->sym
;
3404 /* Not found, add a new entry. */
3405 subseg_set (alpha_link_section
, 0);
3406 linksym
= symbol_new
3407 (FAKE_LABEL_NAME
, now_seg
, (valueT
) frag_now_fix (), frag_now
);
3411 /* Create a symbol for 'basesym - linksym' (offset of the added entry). */
3412 e
.X_op
= O_subtract
;
3413 e
.X_add_symbol
= linksym
;
3414 e
.X_op_symbol
= basesym
;
3416 expsym
= make_expr_symbol (&e
);
3418 /* Create a fixup for the entry. */
3420 (frag_now
, p
- frag_now
->fr_literal
, 8, sym
, addend
, 0, BFD_RELOC_64
);
3421 fixp
->tc_fix_data
.info
= get_alpha_reloc_tag (next_sequence_num
--);
3422 fixp
->tc_fix_data
.info
->sym
= expsym
;
3424 subseg_set (current_section
, current_subsec
);
3426 /* Return the symbol. */
3429 #endif /* OBJ_EVAX */
3431 /* Assembler directives. */
3433 /* Handle the .text pseudo-op. This is like the usual one, but it
3434 clears alpha_insn_label and restores auto alignment. */
3437 s_alpha_text (int i
)
3448 symbolP
= symbol_find (".text");
3449 if (symbolP
== NULL
)
3451 symbolP
= symbol_make (".text");
3452 S_SET_SEGMENT (symbolP
, text_section
);
3453 symbol_table_insert (symbolP
);
3457 alpha_insn_label
= NULL
;
3458 alpha_auto_align_on
= 1;
3459 alpha_current_align
= 0;
3462 /* Handle the .data pseudo-op. This is like the usual one, but it
3463 clears alpha_insn_label and restores auto alignment. */
3466 s_alpha_data (int i
)
3473 alpha_insn_label
= NULL
;
3474 alpha_auto_align_on
= 1;
3475 alpha_current_align
= 0;
3478 #if defined (OBJ_ECOFF) || defined (OBJ_EVAX)
3480 /* Handle the OSF/1 and openVMS .comm pseudo quirks. */
3483 s_alpha_comm (int ignore ATTRIBUTE_UNUSED
)
3495 c
= get_symbol_name (&name
);
3497 /* Just after name is now '\0'. */
3498 p
= input_line_pointer
;
3501 SKIP_WHITESPACE_AFTER_NAME ();
3503 /* Alpha OSF/1 compiler doesn't provide the comma, gcc does. */
3504 if (*input_line_pointer
== ',')
3506 input_line_pointer
++;
3509 if ((size
= get_absolute_expression ()) < 0)
3511 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
3512 ignore_rest_of_line ();
3517 symbolP
= symbol_find_or_make (name
);
3520 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
3522 as_bad (_("Ignoring attempt to re-define symbol"));
3523 ignore_rest_of_line ();
3528 if (*input_line_pointer
!= ',')
3529 temp
= 8; /* Default alignment. */
3532 input_line_pointer
++;
3534 temp
= get_absolute_expression ();
3537 /* ??? Unlike on OSF/1, the alignment factor is not in log units. */
3538 while ((temp
>>= 1) != 0)
3541 if (*input_line_pointer
== ',')
3543 /* Extended form of the directive
3545 .comm symbol, size, alignment, section
3547 where the "common" semantics is transferred to the section.
3548 The symbol is effectively an alias for the section name. */
3551 const char *sec_name
;
3552 symbolS
*sec_symbol
;
3553 segT current_seg
= now_seg
;
3554 subsegT current_subseg
= now_subseg
;
3557 input_line_pointer
++;
3559 sec_name
= s_alpha_section_name ();
3560 sec_symbol
= symbol_find_or_make (sec_name
);
3561 sec
= subseg_new (sec_name
, 0);
3562 S_SET_SEGMENT (sec_symbol
, sec
);
3563 symbol_get_bfdsym (sec_symbol
)->flags
|= BSF_SECTION_SYM
;
3564 bfd_vms_set_section_flags (stdoutput
, sec
, 0,
3565 EGPS__V_OVR
| EGPS__V_GBL
| EGPS__V_NOMOD
);
3566 record_alignment (sec
, log_align
);
3568 /* Reuse stab_string_size to store the size of the section. */
3569 cur_size
= seg_info (sec
)->stabu
.stab_string_size
;
3570 if ((int) size
> cur_size
)
3573 = frag_var (rs_fill
, 1, 1, (relax_substateT
)0, NULL
,
3574 (valueT
)size
- (valueT
)cur_size
, NULL
);
3576 seg_info (sec
)->stabu
.stab_string_size
= (int)size
;
3579 S_SET_SEGMENT (symbolP
, sec
);
3581 subseg_set (current_seg
, current_subseg
);
3585 /* Regular form of the directive
3587 .comm symbol, size, alignment
3589 where the "common" semantics in on the symbol.
3590 These symbols are assembled in the .bss section. */
3593 segT current_seg
= now_seg
;
3594 subsegT current_subseg
= now_subseg
;
3596 subseg_set (bss_section
, 1);
3597 frag_align (log_align
, 0, 0);
3598 record_alignment (bss_section
, log_align
);
3600 symbol_set_frag (symbolP
, frag_now
);
3601 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
3605 S_SET_SEGMENT (symbolP
, bss_section
);
3607 subseg_set (current_seg
, current_subseg
);
3611 if (S_GET_VALUE (symbolP
))
3613 if (S_GET_VALUE (symbolP
) != (valueT
) size
)
3614 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
3615 S_GET_NAME (symbolP
),
3616 (long) S_GET_VALUE (symbolP
),
3622 S_SET_VALUE (symbolP
, (valueT
) size
);
3624 S_SET_EXTERNAL (symbolP
);
3628 know (symbol_get_frag (symbolP
) == &zero_address_frag
);
3630 demand_empty_rest_of_line ();
3633 #endif /* ! OBJ_ELF */
3637 /* Handle the .rdata pseudo-op. This is like the usual one, but it
3638 clears alpha_insn_label and restores auto alignment. */
3641 s_alpha_rdata (int ignore ATTRIBUTE_UNUSED
)
3643 get_absolute_expression ();
3644 subseg_new (".rdata", 0);
3645 demand_empty_rest_of_line ();
3646 alpha_insn_label
= NULL
;
3647 alpha_auto_align_on
= 1;
3648 alpha_current_align
= 0;
3655 /* Handle the .sdata pseudo-op. This is like the usual one, but it
3656 clears alpha_insn_label and restores auto alignment. */
3659 s_alpha_sdata (int ignore ATTRIBUTE_UNUSED
)
3661 get_absolute_expression ();
3662 subseg_new (".sdata", 0);
3663 demand_empty_rest_of_line ();
3664 alpha_insn_label
= NULL
;
3665 alpha_auto_align_on
= 1;
3666 alpha_current_align
= 0;
3671 struct alpha_elf_frame_data
3674 symbolS
*func_end_sym
;
3675 symbolS
*prologue_sym
;
3681 offsetT mask_offset
;
3682 offsetT fmask_offset
;
3684 struct alpha_elf_frame_data
*next
;
3687 static struct alpha_elf_frame_data
*all_frame_data
;
3688 static struct alpha_elf_frame_data
**plast_frame_data
= &all_frame_data
;
3689 static struct alpha_elf_frame_data
*cur_frame_data
;
3691 extern int all_cfi_sections
;
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
;
3715 name_end
= get_symbol_name (&name
);
3716 /* CFI_EMIT_eh_frame is the default. */
3717 all_cfi_sections
= CFI_EMIT_eh_frame
;
3719 if (! is_name_beginner (*name
))
3721 as_warn (_(".ent directive has no name"));
3722 (void) restore_line_pointer (name_end
);
3729 as_warn (_("nested .ent directives"));
3731 sym
= symbol_find_or_make (name
);
3732 symbol_get_bfdsym (sym
)->flags
|= BSF_FUNCTION
;
3734 cur_frame_data
= XCNEW (struct alpha_elf_frame_data
);
3735 cur_frame_data
->func_sym
= sym
;
3737 /* Provide sensible defaults. */
3738 cur_frame_data
->fp_regno
= 30; /* sp */
3739 cur_frame_data
->ra_regno
= 26; /* ra */
3741 *plast_frame_data
= cur_frame_data
;
3742 plast_frame_data
= &cur_frame_data
->next
;
3744 /* The .ent directive is sometimes followed by a number. Not sure
3745 what it really means, but ignore it. */
3746 *input_line_pointer
= name_end
;
3747 SKIP_WHITESPACE_AFTER_NAME ();
3748 if (*input_line_pointer
== ',')
3750 input_line_pointer
++;
3753 if (ISDIGIT (*input_line_pointer
) || *input_line_pointer
== '-')
3754 (void) get_absolute_expression ();
3756 demand_empty_rest_of_line ();
3761 s_alpha_end (int dummy ATTRIBUTE_UNUSED
)
3763 if (ECOFF_DEBUGGING
)
3764 ecoff_directive_end (0);
3767 char *name
, name_end
;
3769 name_end
= get_symbol_name (&name
);
3771 if (! is_name_beginner (*name
))
3773 as_warn (_(".end directive has no name"));
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
= XNEW (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
;
3803 (void) restore_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
= xmemdup0 (start
, len
);
3959 input_line_pointer
= start
;
3962 if (ECOFF_DEBUGGING
)
3963 ecoff_directive_file (0);
3965 dwarf2_directive_file (0);
3969 s_alpha_loc (int ignore ATTRIBUTE_UNUSED
)
3971 if (ECOFF_DEBUGGING
)
3972 ecoff_directive_loc (0);
3974 dwarf2_directive_loc (0);
3978 s_alpha_stab (int n
)
3980 /* If we've been undecided about mdebug, make up our minds in favour. */
3981 if (alpha_flag_mdebug
< 0)
3983 segT sec
= subseg_new (".mdebug", 0);
3984 bfd_set_section_flags (sec
, SEC_HAS_CONTENTS
| SEC_READONLY
);
3985 bfd_set_section_alignment (sec
, 3);
3987 ecoff_read_begin_hook ();
3989 if (first_file_directive
)
3991 char *save_ilp
= input_line_pointer
;
3992 input_line_pointer
= first_file_directive
;
3993 ecoff_directive_file (0);
3994 input_line_pointer
= save_ilp
;
3995 free (first_file_directive
);
3998 alpha_flag_mdebug
= 1;
4004 s_alpha_coff_wrapper (int which
)
4006 static void (* const fns
[]) (int) = {
4007 ecoff_directive_begin
,
4008 ecoff_directive_bend
,
4009 ecoff_directive_def
,
4010 ecoff_directive_dim
,
4011 ecoff_directive_endef
,
4012 ecoff_directive_scl
,
4013 ecoff_directive_tag
,
4014 ecoff_directive_val
,
4017 gas_assert (which
>= 0 && which
< (int) (sizeof (fns
)/sizeof (*fns
)));
4019 if (ECOFF_DEBUGGING
)
4023 as_bad (_("ECOFF debugging is disabled."));
4024 ignore_rest_of_line ();
4028 /* Called at the end of assembly. Here we emit unwind info for frames
4029 unless the compiler has done it for us. */
4032 alpha_elf_md_end (void)
4034 struct alpha_elf_frame_data
*p
;
4037 as_warn (_(".ent directive without matching .end"));
4039 /* If someone has generated the unwind info themselves, great. */
4040 if (bfd_get_section_by_name (stdoutput
, ".eh_frame") != NULL
)
4043 /* ??? In theory we could look for functions for which we have
4044 generated unwind info via CFI directives, and those we have not.
4045 Those we have not could still get their unwind info from here.
4046 For now, do nothing if we've seen any CFI directives. Note that
4047 the above test will not trigger, as we've not emitted data yet. */
4048 if (all_fde_data
!= NULL
)
4051 /* Generate .eh_frame data for the unwind directives specified. */
4052 for (p
= all_frame_data
; p
; p
= p
->next
)
4053 if (p
->prologue_sym
)
4055 /* Create a temporary symbol at the same location as our
4056 function symbol. This prevents problems with globals. */
4057 cfi_new_fde (symbol_temp_new (S_GET_SEGMENT (p
->func_sym
),
4058 S_GET_VALUE (p
->func_sym
),
4059 symbol_get_frag (p
->func_sym
)));
4061 cfi_set_sections ();
4062 cfi_set_return_column (p
->ra_regno
);
4063 cfi_add_CFA_def_cfa_register (30);
4064 if (p
->fp_regno
!= 30 || p
->mask
|| p
->fmask
|| p
->frame_size
)
4069 cfi_add_advance_loc (p
->prologue_sym
);
4071 if (p
->fp_regno
!= 30)
4072 if (p
->frame_size
!= 0)
4073 cfi_add_CFA_def_cfa (p
->fp_regno
, p
->frame_size
);
4075 cfi_add_CFA_def_cfa_register (p
->fp_regno
);
4076 else if (p
->frame_size
!= 0)
4077 cfi_add_CFA_def_cfa_offset (p
->frame_size
);
4080 offset
= p
->mask_offset
;
4082 /* Recall that $26 is special-cased and stored first. */
4083 if ((mask
>> 26) & 1)
4085 cfi_add_CFA_offset (26, offset
);
4096 cfi_add_CFA_offset (i
, offset
);
4101 offset
= p
->fmask_offset
;
4109 cfi_add_CFA_offset (i
+ 32, offset
);
4114 cfi_end_fde (p
->func_end_sym
);
4119 s_alpha_usepv (int unused ATTRIBUTE_UNUSED
)
4121 char *name
, name_end
;
4122 char *which
, which_end
;
4126 name_end
= get_symbol_name (&name
);
4128 if (! is_name_beginner (*name
))
4130 as_bad (_(".usepv directive has no name"));
4131 (void) restore_line_pointer (name_end
);
4132 ignore_rest_of_line ();
4136 sym
= symbol_find_or_make (name
);
4137 name_end
= restore_line_pointer (name_end
);
4138 if (! is_end_of_line
[(unsigned char) name_end
])
4139 input_line_pointer
++;
4141 if (name_end
!= ',')
4143 as_bad (_(".usepv directive has no type"));
4144 ignore_rest_of_line ();
4150 which_end
= get_symbol_name (&which
);
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 (void) restore_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
= xmemdup0 (input_line_pointer
, end
- input_line_pointer
);
4211 input_line_pointer
= end
;
4217 /* Put clear/set flags in one flagword. The LSBs are flags to be set,
4218 the MSBs are the flags to be cleared. */
4220 #define EGPS__V_NO_SHIFT 16
4221 #define EGPS__V_MASK 0xffff
4223 /* Parse one VMS section flag. */
4226 s_alpha_section_word (char *str
, size_t len
)
4231 if (len
== 5 && strncmp (str
, "NO", 2) == 0)
4240 if (strncmp (str
, "PIC", 3) == 0)
4242 else if (strncmp (str
, "LIB", 3) == 0)
4244 else if (strncmp (str
, "OVR", 3) == 0)
4246 else if (strncmp (str
, "REL", 3) == 0)
4248 else if (strncmp (str
, "GBL", 3) == 0)
4250 else if (strncmp (str
, "SHR", 3) == 0)
4252 else if (strncmp (str
, "EXE", 3) == 0)
4254 else if (strncmp (str
, "WRT", 3) == 0)
4256 else if (strncmp (str
, "VEC", 3) == 0)
4258 else if (strncmp (str
, "MOD", 3) == 0)
4260 flag
= no
? EGPS__V_NOMOD
: EGPS__V_NOMOD
<< EGPS__V_NO_SHIFT
;
4263 else if (strncmp (str
, "COM", 3) == 0)
4271 as_warn (_("unknown section attribute %s"), str
);
4277 return flag
<< EGPS__V_NO_SHIFT
;
4282 /* Handle the section specific pseudo-op. */
4284 #define EVAX_SECTION_COUNT 5
4286 static const char *section_name
[EVAX_SECTION_COUNT
+ 1] =
4287 { "NULL", ".rdata", ".comm", ".link", ".ctors", ".dtors" };
4290 s_alpha_section (int secid
)
4295 flagword vms_flags
= 0;
4300 name
= s_alpha_section_name ();
4303 sec
= subseg_new (name
, 0);
4304 if (*input_line_pointer
== ',')
4306 /* Skip the comma. */
4307 ++input_line_pointer
;
4315 c
= get_symbol_name (&beg
);
4316 *input_line_pointer
= c
;
4318 vms_flags
|= s_alpha_section_word (beg
, input_line_pointer
- beg
);
4320 SKIP_WHITESPACE_AFTER_NAME ();
4322 while (*input_line_pointer
++ == ',');
4324 --input_line_pointer
;
4327 symbol
= symbol_find_or_make (name
);
4328 S_SET_SEGMENT (symbol
, sec
);
4329 symbol_get_bfdsym (symbol
)->flags
|= BSF_SECTION_SYM
;
4330 bfd_vms_set_section_flags
4332 (vms_flags
>> EGPS__V_NO_SHIFT
) & EGPS__V_MASK
,
4333 vms_flags
& EGPS__V_MASK
);
4337 get_absolute_expression ();
4338 subseg_new (section_name
[secid
], 0);
4341 demand_empty_rest_of_line ();
4342 alpha_insn_label
= NULL
;
4343 alpha_auto_align_on
= 1;
4344 alpha_current_align
= 0;
4348 s_alpha_literals (int ignore ATTRIBUTE_UNUSED
)
4350 subseg_new (".literals", 0);
4351 demand_empty_rest_of_line ();
4352 alpha_insn_label
= NULL
;
4353 alpha_auto_align_on
= 1;
4354 alpha_current_align
= 0;
4357 /* Parse .ent directives. */
4360 s_alpha_ent (int ignore ATTRIBUTE_UNUSED
)
4363 expressionS symexpr
;
4365 if (alpha_evax_proc
!= NULL
)
4366 as_bad (_("previous .ent not closed by a .end"));
4368 alpha_evax_proc
= &alpha_evax_proc_data
;
4370 alpha_evax_proc
->pdsckind
= 0;
4371 alpha_evax_proc
->framereg
= -1;
4372 alpha_evax_proc
->framesize
= 0;
4373 alpha_evax_proc
->rsa_offset
= 0;
4374 alpha_evax_proc
->ra_save
= AXP_REG_RA
;
4375 alpha_evax_proc
->fp_save
= -1;
4376 alpha_evax_proc
->imask
= 0;
4377 alpha_evax_proc
->fmask
= 0;
4378 alpha_evax_proc
->prologue
= 0;
4379 alpha_evax_proc
->type
= 0;
4380 alpha_evax_proc
->handler
= 0;
4381 alpha_evax_proc
->handler_data
= 0;
4383 expression (&symexpr
);
4385 if (symexpr
.X_op
!= O_symbol
)
4387 as_fatal (_(".ent directive has no symbol"));
4388 demand_empty_rest_of_line ();
4392 symbol
= make_expr_symbol (&symexpr
);
4393 symbol_get_bfdsym (symbol
)->flags
|= BSF_FUNCTION
;
4394 alpha_evax_proc
->symbol
= symbol
;
4396 demand_empty_rest_of_line ();
4400 s_alpha_handler (int is_data
)
4403 alpha_evax_proc
->handler_data
= get_absolute_expression ();
4406 char *name
, name_end
;
4408 name_end
= get_symbol_name (&name
);
4410 if (! is_name_beginner (*name
))
4412 as_warn (_(".handler directive has no name"));
4418 sym
= symbol_find_or_make (name
);
4419 symbol_get_bfdsym (sym
)->flags
|= BSF_FUNCTION
;
4420 alpha_evax_proc
->handler
= sym
;
4423 (void) restore_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
)
4437 alpha_evax_proc
->framereg
= tc_get_register (1);
4440 if (*input_line_pointer
++ != ','
4441 || get_absolute_expression_and_terminator (&val
) != ',')
4443 as_warn (_("Bad .frame directive 1./2. param"));
4444 --input_line_pointer
;
4445 demand_empty_rest_of_line ();
4449 alpha_evax_proc
->framesize
= val
;
4451 ra
= tc_get_register (1);
4452 if (ra
!= AXP_REG_RA
)
4453 as_warn (_("Bad RA (%d) register for .frame"), ra
);
4456 if (*input_line_pointer
++ != ',')
4458 as_warn (_("Bad .frame directive 3./4. param"));
4459 --input_line_pointer
;
4460 demand_empty_rest_of_line ();
4463 alpha_evax_proc
->rsa_offset
= get_absolute_expression ();
4466 /* Parse .prologue. */
4469 s_alpha_prologue (int ignore ATTRIBUTE_UNUSED
)
4471 demand_empty_rest_of_line ();
4472 alpha_prologue_label
= symbol_new
4473 (FAKE_LABEL_NAME
, now_seg
, (valueT
) frag_now_fix (), frag_now
);
4476 /* Parse .pdesc <entry_name>,{null|stack|reg}
4477 Insert a procedure descriptor. */
4480 s_alpha_pdesc (int ignore ATTRIBUTE_UNUSED
)
4487 const char *entry_sym_name
;
4488 const char *pdesc_sym_name
;
4492 if (now_seg
!= alpha_link_section
)
4494 as_bad (_(".pdesc directive not in link (.link) section"));
4499 if (exp
.X_op
!= O_symbol
)
4501 as_bad (_(".pdesc directive has no entry symbol"));
4505 entry_sym
= make_expr_symbol (&exp
);
4506 entry_sym_name
= S_GET_NAME (entry_sym
);
4509 len
= strlen (entry_sym_name
);
4510 if (len
< 4 || strcmp (entry_sym_name
+ len
- 4, "..en") != 0)
4512 as_bad (_(".pdesc has a bad entry symbol"));
4516 pdesc_sym_name
= S_GET_NAME (alpha_evax_proc
->symbol
);
4518 if (!alpha_evax_proc
4519 || !S_IS_DEFINED (alpha_evax_proc
->symbol
)
4520 || strlen (pdesc_sym_name
) != len
4521 || memcmp (entry_sym_name
, pdesc_sym_name
, len
) != 0)
4523 as_fatal (_(".pdesc doesn't match with last .ent"));
4527 /* Define pdesc symbol. */
4528 symbol_set_value_now (alpha_evax_proc
->symbol
);
4530 /* Save bfd symbol of proc entry in function symbol. */
4531 ((struct evax_private_udata_struct
*)
4532 symbol_get_bfdsym (alpha_evax_proc
->symbol
)->udata
.p
)->enbsym
4533 = symbol_get_bfdsym (entry_sym
);
4536 if (*input_line_pointer
++ != ',')
4538 as_warn (_("No comma after .pdesc <entryname>"));
4539 demand_empty_rest_of_line ();
4544 name_end
= get_symbol_name (&name
);
4546 if (strncmp (name
, "stack", 5) == 0)
4547 alpha_evax_proc
->pdsckind
= PDSC_S_K_KIND_FP_STACK
;
4549 else if (strncmp (name
, "reg", 3) == 0)
4550 alpha_evax_proc
->pdsckind
= PDSC_S_K_KIND_FP_REGISTER
;
4552 else if (strncmp (name
, "null", 4) == 0)
4553 alpha_evax_proc
->pdsckind
= PDSC_S_K_KIND_NULL
;
4557 (void) restore_line_pointer (name_end
);
4558 as_fatal (_("unknown procedure kind"));
4559 demand_empty_rest_of_line ();
4563 (void) restore_line_pointer (name_end
);
4564 demand_empty_rest_of_line ();
4566 #ifdef md_flush_pending_output
4567 md_flush_pending_output ();
4570 frag_align (3, 0, 0);
4572 fixp
= fix_new (frag_now
, p
- frag_now
->fr_literal
, 8, 0, 0, 0, 0);
4575 *p
= alpha_evax_proc
->pdsckind
4576 | ((alpha_evax_proc
->framereg
== 29) ? PDSC_S_M_BASE_REG_IS_FP
: 0)
4577 | ((alpha_evax_proc
->handler
) ? PDSC_S_M_HANDLER_VALID
: 0)
4578 | ((alpha_evax_proc
->handler_data
) ? PDSC_S_M_HANDLER_DATA_VALID
: 0);
4579 *(p
+ 1) = PDSC_S_M_NATIVE
| PDSC_S_M_NO_JACKET
;
4581 switch (alpha_evax_proc
->pdsckind
)
4583 case PDSC_S_K_KIND_NULL
:
4587 case PDSC_S_K_KIND_FP_REGISTER
:
4588 *(p
+ 2) = alpha_evax_proc
->fp_save
;
4589 *(p
+ 3) = alpha_evax_proc
->ra_save
;
4591 case PDSC_S_K_KIND_FP_STACK
:
4592 md_number_to_chars (p
+ 2, (valueT
) alpha_evax_proc
->rsa_offset
, 2);
4594 default: /* impossible */
4599 *(p
+ 5) = alpha_evax_proc
->type
& 0x0f;
4601 /* Signature offset. */
4602 md_number_to_chars (p
+ 6, (valueT
) 0, 2);
4604 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+ 8,
4605 8, &exp
, 0, BFD_RELOC_64
);
4607 if (alpha_evax_proc
->pdsckind
== PDSC_S_K_KIND_NULL
)
4610 /* pdesc+16: Size. */
4612 md_number_to_chars (p
, (valueT
) alpha_evax_proc
->framesize
, 4);
4613 md_number_to_chars (p
+ 4, (valueT
) 0, 2);
4616 exp
.X_op
= O_subtract
;
4617 exp
.X_add_symbol
= alpha_prologue_label
;
4618 exp
.X_op_symbol
= entry_sym
;
4619 emit_expr (&exp
, 2);
4621 if (alpha_evax_proc
->pdsckind
== PDSC_S_K_KIND_FP_REGISTER
)
4624 /* pdesc+24: register masks. */
4626 md_number_to_chars (p
, alpha_evax_proc
->imask
, 4);
4627 md_number_to_chars (p
+ 4, alpha_evax_proc
->fmask
, 4);
4629 if (alpha_evax_proc
->handler
)
4632 fixp
= fix_new (frag_now
, p
- frag_now
->fr_literal
, 8,
4633 alpha_evax_proc
->handler
, 0, 0, BFD_RELOC_64
);
4636 if (alpha_evax_proc
->handler_data
)
4639 md_number_to_chars (p
, alpha_evax_proc
->handler_data
, 8);
4643 /* Support for crash debug on vms. */
4646 s_alpha_name (int ignore ATTRIBUTE_UNUSED
)
4651 if (now_seg
!= alpha_link_section
)
4653 as_bad (_(".name directive not in link (.link) section"));
4654 demand_empty_rest_of_line ();
4659 if (exp
.X_op
!= O_symbol
)
4661 as_warn (_(".name directive has no symbol"));
4662 demand_empty_rest_of_line ();
4666 demand_empty_rest_of_line ();
4668 #ifdef md_flush_pending_output
4669 md_flush_pending_output ();
4672 frag_align (3, 0, 0);
4675 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 8, &exp
, 0, BFD_RELOC_64
);
4678 /* Parse .linkage <symbol>.
4679 Create a linkage pair relocation. */
4682 s_alpha_linkage (int ignore ATTRIBUTE_UNUSED
)
4688 #ifdef md_flush_pending_output
4689 md_flush_pending_output ();
4693 if (exp
.X_op
!= O_symbol
)
4695 as_fatal (_("No symbol after .linkage"));
4699 struct alpha_linkage_fixups
*linkage_fixup
;
4701 p
= frag_more (LKP_S_K_SIZE
);
4702 memset (p
, 0, LKP_S_K_SIZE
);
4704 (frag_now
, p
- frag_now
->fr_literal
, LKP_S_K_SIZE
, &exp
, 0,
4705 BFD_RELOC_ALPHA_LINKAGE
);
4707 if (alpha_insn_label
== NULL
)
4708 alpha_insn_label
= symbol_new
4709 (FAKE_LABEL_NAME
, now_seg
, (valueT
) frag_now_fix (), frag_now
);
4711 /* Create a linkage element. */
4712 linkage_fixup
= XNEW (struct alpha_linkage_fixups
);
4713 linkage_fixup
->fixp
= fixp
;
4714 linkage_fixup
->next
= NULL
;
4715 linkage_fixup
->label
= alpha_insn_label
;
4717 /* Append it to the list. */
4718 if (alpha_linkage_fixup_root
== NULL
)
4719 alpha_linkage_fixup_root
= linkage_fixup
;
4721 alpha_linkage_fixup_tail
->next
= linkage_fixup
;
4722 alpha_linkage_fixup_tail
= linkage_fixup
;
4724 demand_empty_rest_of_line ();
4727 /* Parse .code_address <symbol>.
4728 Create a code address relocation. */
4731 s_alpha_code_address (int ignore ATTRIBUTE_UNUSED
)
4736 #ifdef md_flush_pending_output
4737 md_flush_pending_output ();
4741 if (exp
.X_op
!= O_symbol
)
4742 as_fatal (_("No symbol after .code_address"));
4747 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 8, &exp
, 0,\
4748 BFD_RELOC_ALPHA_CODEADDR
);
4750 demand_empty_rest_of_line ();
4754 s_alpha_fp_save (int ignore ATTRIBUTE_UNUSED
)
4756 alpha_evax_proc
->fp_save
= tc_get_register (1);
4758 demand_empty_rest_of_line ();
4762 s_alpha_mask (int ignore ATTRIBUTE_UNUSED
)
4766 if (get_absolute_expression_and_terminator (&val
) != ',')
4768 as_warn (_("Bad .mask directive"));
4769 --input_line_pointer
;
4773 alpha_evax_proc
->imask
= val
;
4774 (void) get_absolute_expression ();
4776 demand_empty_rest_of_line ();
4780 s_alpha_fmask (int ignore ATTRIBUTE_UNUSED
)
4784 if (get_absolute_expression_and_terminator (&val
) != ',')
4786 as_warn (_("Bad .fmask directive"));
4787 --input_line_pointer
;
4791 alpha_evax_proc
->fmask
= val
;
4792 (void) get_absolute_expression ();
4794 demand_empty_rest_of_line ();
4798 s_alpha_end (int ignore ATTRIBUTE_UNUSED
)
4803 c
= get_symbol_name (&name
);
4804 (void) restore_line_pointer (c
);
4805 demand_empty_rest_of_line ();
4806 alpha_evax_proc
= NULL
;
4810 s_alpha_file (int ignore ATTRIBUTE_UNUSED
)
4814 static char case_hack
[32];
4816 sprintf (case_hack
, "<CASE:%01d%01d>",
4817 alpha_flag_hash_long_names
, alpha_flag_show_after_trunc
);
4819 s
= symbol_find_or_make (case_hack
);
4820 symbol_get_bfdsym (s
)->flags
|= BSF_FILE
;
4822 get_absolute_expression ();
4823 s
= symbol_find_or_make (demand_copy_string (&length
));
4824 symbol_get_bfdsym (s
)->flags
|= BSF_FILE
;
4825 demand_empty_rest_of_line ();
4827 #endif /* OBJ_EVAX */
4829 /* Handle the .gprel32 pseudo op. */
4832 s_alpha_gprel32 (int ignore ATTRIBUTE_UNUSED
)
4844 e
.X_add_symbol
= section_symbol (absolute_section
);
4857 e
.X_add_symbol
= section_symbol (absolute_section
);
4860 e
.X_op
= O_subtract
;
4861 e
.X_op_symbol
= alpha_gp_symbol
;
4869 if (alpha_auto_align_on
&& alpha_current_align
< 2)
4870 alpha_align (2, (char *) NULL
, alpha_insn_label
, 0);
4871 if (alpha_current_align
> 2)
4872 alpha_current_align
= 2;
4873 alpha_insn_label
= NULL
;
4877 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 4,
4878 &e
, 0, BFD_RELOC_GPREL32
);
4881 /* Handle floating point allocation pseudo-ops. This is like the
4882 generic version, but it makes sure the current label, if any, is
4883 correctly aligned. */
4886 s_alpha_float_cons (int type
)
4912 if (alpha_auto_align_on
&& alpha_current_align
< log_size
)
4913 alpha_align (log_size
, (char *) NULL
, alpha_insn_label
, 0);
4914 if (alpha_current_align
> log_size
)
4915 alpha_current_align
= log_size
;
4916 alpha_insn_label
= NULL
;
4921 /* Handle the .proc pseudo op. We don't really do much with it except
4925 s_alpha_proc (int is_static ATTRIBUTE_UNUSED
)
4933 /* Takes ".proc name,nargs". */
4935 c
= get_symbol_name (&name
);
4936 p
= input_line_pointer
;
4937 symbolP
= symbol_find_or_make (name
);
4939 SKIP_WHITESPACE_AFTER_NAME ();
4940 if (*input_line_pointer
!= ',')
4943 as_warn (_("Expected comma after name \"%s\""), name
);
4946 ignore_rest_of_line ();
4950 input_line_pointer
++;
4951 temp
= get_absolute_expression ();
4953 /* *symbol_get_obj (symbolP) = (signed char) temp; */
4955 as_warn (_("unhandled: .proc %s,%d"), name
, temp
);
4956 demand_empty_rest_of_line ();
4959 /* Handle the .set pseudo op. This is used to turn on and off most of
4960 the assembler features. */
4963 s_alpha_set (int x ATTRIBUTE_UNUSED
)
4970 ch
= get_symbol_name (&name
);
4972 if (s
[0] == 'n' && s
[1] == 'o')
4977 if (!strcmp ("reorder", s
))
4979 else if (!strcmp ("at", s
))
4980 alpha_noat_on
= !yesno
;
4981 else if (!strcmp ("macro", s
))
4982 alpha_macros_on
= yesno
;
4983 else if (!strcmp ("move", s
))
4985 else if (!strcmp ("volatile", s
))
4988 as_warn (_("Tried to .set unrecognized mode `%s'"), name
);
4990 (void) restore_line_pointer (ch
);
4991 demand_empty_rest_of_line ();
4994 /* Handle the .base pseudo op. This changes the assembler's notion of
4995 the $gp register. */
4998 s_alpha_base (int ignore ATTRIBUTE_UNUSED
)
5002 if (*input_line_pointer
== '$')
5005 input_line_pointer
++;
5006 if (*input_line_pointer
== 'r')
5007 input_line_pointer
++;
5010 alpha_gp_register
= get_absolute_expression ();
5011 if (alpha_gp_register
< 0 || alpha_gp_register
> 31)
5013 alpha_gp_register
= AXP_REG_GP
;
5014 as_warn (_("Bad base register, using $%d."), alpha_gp_register
);
5017 demand_empty_rest_of_line ();
5020 /* Handle the .align pseudo-op. This aligns to a power of two. It
5021 also adjusts any current instruction label. We treat this the same
5022 way the MIPS port does: .align 0 turns off auto alignment. */
5025 s_alpha_align (int ignore ATTRIBUTE_UNUSED
)
5029 long max_alignment
= 16;
5031 align
= get_absolute_expression ();
5032 if (align
> max_alignment
)
5034 align
= max_alignment
;
5035 as_bad (_("Alignment too large: %d. assumed"), align
);
5039 as_warn (_("Alignment negative: 0 assumed"));
5043 if (*input_line_pointer
== ',')
5045 input_line_pointer
++;
5046 fill
= get_absolute_expression ();
5054 alpha_auto_align_on
= 1;
5055 alpha_align (align
, pfill
, NULL
, 1);
5059 alpha_auto_align_on
= 0;
5061 alpha_insn_label
= NULL
;
5063 demand_empty_rest_of_line ();
5066 /* Hook the normal string processor to reset known alignment. */
5069 s_alpha_stringer (int terminate
)
5071 alpha_current_align
= 0;
5072 alpha_insn_label
= NULL
;
5073 stringer (8 + terminate
);
5076 /* Hook the normal space processing to reset known alignment. */
5079 s_alpha_space (int ignore
)
5081 alpha_current_align
= 0;
5082 alpha_insn_label
= NULL
;
5086 /* Hook into cons for auto-alignment. */
5089 alpha_cons_align (int size
)
5094 while ((size
>>= 1) != 0)
5097 if (alpha_auto_align_on
&& alpha_current_align
< log_size
)
5098 alpha_align (log_size
, (char *) NULL
, alpha_insn_label
, 0);
5099 if (alpha_current_align
> log_size
)
5100 alpha_current_align
= log_size
;
5101 alpha_insn_label
= NULL
;
5104 /* Here come the .uword, .ulong, and .uquad explicitly unaligned
5105 pseudos. We just turn off auto-alignment and call down to cons. */
5108 s_alpha_ucons (int bytes
)
5110 int hold
= alpha_auto_align_on
;
5111 alpha_auto_align_on
= 0;
5113 alpha_auto_align_on
= hold
;
5116 /* Switch the working cpu type. */
5119 s_alpha_arch (int ignored ATTRIBUTE_UNUSED
)
5122 const struct cpu_type
*p
;
5126 ch
= get_symbol_name (&name
);
5128 for (p
= cpu_types
; p
->name
; ++p
)
5129 if (strcmp (name
, p
->name
) == 0)
5131 alpha_target_name
= p
->name
, alpha_target
= p
->flags
;
5134 as_warn (_("Unknown CPU identifier `%s'"), name
);
5137 (void) restore_line_pointer (ch
);
5138 demand_empty_rest_of_line ();
5142 /* print token expression with alpha specific extension. */
5145 alpha_print_token (FILE *f
, const expressionS
*exp
)
5155 expressionS nexp
= *exp
;
5156 nexp
.X_op
= O_register
;
5157 print_expr_1 (f
, &nexp
);
5162 print_expr_1 (f
, exp
);
5168 /* The target specific pseudo-ops which we support. */
5170 const pseudo_typeS md_pseudo_table
[] =
5173 {"comm", s_alpha_comm
, 0}, /* OSF1 compiler does this. */
5174 {"rdata", s_alpha_rdata
, 0},
5176 {"text", s_alpha_text
, 0},
5177 {"data", s_alpha_data
, 0},
5179 {"sdata", s_alpha_sdata
, 0},
5182 {"section", s_alpha_section
, 0},
5183 {"section.s", s_alpha_section
, 0},
5184 {"sect", s_alpha_section
, 0},
5185 {"sect.s", s_alpha_section
, 0},
5188 {"section", s_alpha_section
, 0},
5189 {"literals", s_alpha_literals
, 0},
5190 {"pdesc", s_alpha_pdesc
, 0},
5191 {"name", s_alpha_name
, 0},
5192 {"linkage", s_alpha_linkage
, 0},
5193 {"code_address", s_alpha_code_address
, 0},
5194 {"ent", s_alpha_ent
, 0},
5195 {"frame", s_alpha_frame
, 0},
5196 {"fp_save", s_alpha_fp_save
, 0},
5197 {"mask", s_alpha_mask
, 0},
5198 {"fmask", s_alpha_fmask
, 0},
5199 {"end", s_alpha_end
, 0},
5200 {"file", s_alpha_file
, 0},
5201 {"rdata", s_alpha_section
, 1},
5202 {"comm", s_alpha_comm
, 0},
5203 {"link", s_alpha_section
, 3},
5204 {"ctors", s_alpha_section
, 4},
5205 {"dtors", s_alpha_section
, 5},
5206 {"handler", s_alpha_handler
, 0},
5207 {"handler_data", s_alpha_handler
, 1},
5210 /* Frame related pseudos. */
5211 {"ent", s_alpha_ent
, 0},
5212 {"end", s_alpha_end
, 0},
5213 {"mask", s_alpha_mask
, 0},
5214 {"fmask", s_alpha_mask
, 1},
5215 {"frame", s_alpha_frame
, 0},
5216 {"prologue", s_alpha_prologue
, 0},
5217 {"file", s_alpha_file
, 5},
5218 {"loc", s_alpha_loc
, 9},
5219 {"stabs", s_alpha_stab
, 's'},
5220 {"stabn", s_alpha_stab
, 'n'},
5221 {"usepv", s_alpha_usepv
, 0},
5222 /* COFF debugging related pseudos. */
5223 {"begin", s_alpha_coff_wrapper
, 0},
5224 {"bend", s_alpha_coff_wrapper
, 1},
5225 {"def", s_alpha_coff_wrapper
, 2},
5226 {"dim", s_alpha_coff_wrapper
, 3},
5227 {"endef", s_alpha_coff_wrapper
, 4},
5228 {"scl", s_alpha_coff_wrapper
, 5},
5229 {"tag", s_alpha_coff_wrapper
, 6},
5230 {"val", s_alpha_coff_wrapper
, 7},
5233 {"prologue", s_alpha_prologue
, 0},
5235 {"prologue", s_ignore
, 0},
5238 {"gprel32", s_alpha_gprel32
, 0},
5239 {"t_floating", s_alpha_float_cons
, 'd'},
5240 {"s_floating", s_alpha_float_cons
, 'f'},
5241 {"f_floating", s_alpha_float_cons
, 'F'},
5242 {"g_floating", s_alpha_float_cons
, 'G'},
5243 {"d_floating", s_alpha_float_cons
, 'D'},
5245 {"proc", s_alpha_proc
, 0},
5246 {"aproc", s_alpha_proc
, 1},
5247 {"set", s_alpha_set
, 0},
5248 {"reguse", s_ignore
, 0},
5249 {"livereg", s_ignore
, 0},
5250 {"base", s_alpha_base
, 0}, /*??*/
5251 {"option", s_ignore
, 0},
5252 {"aent", s_ignore
, 0},
5253 {"ugen", s_ignore
, 0},
5254 {"eflag", s_ignore
, 0},
5256 {"align", s_alpha_align
, 0},
5257 {"double", s_alpha_float_cons
, 'd'},
5258 {"float", s_alpha_float_cons
, 'f'},
5259 {"single", s_alpha_float_cons
, 'f'},
5260 {"ascii", s_alpha_stringer
, 0},
5261 {"asciz", s_alpha_stringer
, 1},
5262 {"string", s_alpha_stringer
, 1},
5263 {"space", s_alpha_space
, 0},
5264 {"skip", s_alpha_space
, 0},
5265 {"zero", s_alpha_space
, 0},
5267 /* Unaligned data pseudos. */
5268 {"uword", s_alpha_ucons
, 2},
5269 {"ulong", s_alpha_ucons
, 4},
5270 {"uquad", s_alpha_ucons
, 8},
5273 /* Dwarf wants these versions of unaligned. */
5274 {"2byte", s_alpha_ucons
, 2},
5275 {"4byte", s_alpha_ucons
, 4},
5276 {"8byte", s_alpha_ucons
, 8},
5279 /* We don't do any optimizing, so we can safely ignore these. */
5280 {"noalias", s_ignore
, 0},
5281 {"alias", s_ignore
, 0},
5283 {"arch", s_alpha_arch
, 0},
5290 /* @@@ GP selection voodoo. All of this seems overly complicated and
5291 unnecessary; which is the primary reason it's for ECOFF only. */
5294 maybe_set_gp (asection
*sec
)
5300 vma
= bfd_section_vma (sec
);
5301 if (vma
&& vma
< alpha_gp_value
)
5302 alpha_gp_value
= vma
;
5306 select_gp_value (void)
5308 gas_assert (alpha_gp_value
== 0);
5310 /* Get minus-one in whatever width... */
5314 /* Select the smallest VMA of these existing sections. */
5315 maybe_set_gp (alpha_lita_section
);
5317 /* @@ Will a simple 0x8000 work here? If not, why not? */
5318 #define GP_ADJUSTMENT (0x8000 - 0x10)
5320 alpha_gp_value
+= GP_ADJUSTMENT
;
5322 S_SET_VALUE (alpha_gp_symbol
, alpha_gp_value
);
5325 printf (_("Chose GP value of %lx\n"), alpha_gp_value
);
5328 #endif /* OBJ_ECOFF */
5331 /* Map 's' to SHF_ALPHA_GPREL. */
5334 alpha_elf_section_letter (int letter
, const char **ptr_msg
)
5337 return SHF_ALPHA_GPREL
;
5339 *ptr_msg
= _("bad .section directive: want a,s,w,x,M,S,G,T in string");
5343 /* Map SHF_ALPHA_GPREL to SEC_SMALL_DATA. */
5346 alpha_elf_section_flags (flagword flags
, bfd_vma attr
, int type ATTRIBUTE_UNUSED
)
5348 if (attr
& SHF_ALPHA_GPREL
)
5349 flags
|= SEC_SMALL_DATA
;
5352 #endif /* OBJ_ELF */
5354 /* This is called from HANDLE_ALIGN in write.c. Fill in the contents
5355 of an rs_align_code fragment. */
5358 alpha_handle_align (fragS
*fragp
)
5360 static unsigned char const unop
[4] = { 0x00, 0x00, 0xfe, 0x2f };
5361 static unsigned char const nopunop
[8] =
5363 0x1f, 0x04, 0xff, 0x47,
5364 0x00, 0x00, 0xfe, 0x2f
5370 if (fragp
->fr_type
!= rs_align_code
)
5373 bytes
= fragp
->fr_next
->fr_address
- fragp
->fr_address
- fragp
->fr_fix
;
5374 p
= fragp
->fr_literal
+ fragp
->fr_fix
;
5387 memcpy (p
, unop
, 4);
5393 memcpy (p
, nopunop
, 8);
5395 fragp
->fr_fix
+= fix
;
5399 /* Public interface functions. */
5401 /* This function is called once, at assembler startup time. It sets
5402 up all the tables, etc. that the MD part of the assembler will
5403 need, that can be determined before arguments are parsed. */
5410 /* Verify that X_op field is wide enough. */
5415 gas_assert (e
.X_op
== O_max
);
5418 /* Create the opcode hash table. */
5419 alpha_opcode_hash
= str_htab_create ();
5421 for (i
= 0; i
< alpha_num_opcodes
;)
5423 const char *name
, *slash
;
5425 name
= alpha_opcodes
[i
].name
;
5426 str_hash_insert (alpha_opcode_hash
, name
, (void *) &alpha_opcodes
[i
]);
5428 /* Some opcodes include modifiers of various sorts with a "/mod"
5429 syntax, like the architecture manual suggests. However, for
5430 use with gcc at least, we also need access to those same opcodes
5433 if ((slash
= strchr (name
, '/')) != NULL
)
5435 char *p
= XNEWVEC (char, strlen (name
));
5437 memcpy (p
, name
, slash
- name
);
5438 strcpy (p
+ (slash
- name
), slash
+ 1);
5440 (void) str_hash_insert (alpha_opcode_hash
, p
, (void *) &alpha_opcodes
[i
]);
5441 /* Ignore failures -- the opcode table does duplicate some
5442 variants in different forms, like "hw_stq" and "hw_st/q". */
5445 while (++i
< alpha_num_opcodes
5446 && (alpha_opcodes
[i
].name
== name
5447 || !strcmp (alpha_opcodes
[i
].name
, name
)))
5451 /* Create the macro hash table. */
5452 alpha_macro_hash
= str_htab_create ();
5454 for (i
= 0; i
< alpha_num_macros
;)
5458 name
= alpha_macros
[i
].name
;
5459 str_hash_insert (alpha_macro_hash
, name
, (void *) &alpha_macros
[i
]);
5461 while (++i
< alpha_num_macros
5462 && (alpha_macros
[i
].name
== name
5463 || !strcmp (alpha_macros
[i
].name
, name
)))
5467 /* Construct symbols for each of the registers. */
5468 for (i
= 0; i
< 32; ++i
)
5472 sprintf (name
, "$%d", i
);
5473 alpha_register_table
[i
] = symbol_create (name
, reg_section
, i
,
5474 &zero_address_frag
);
5481 sprintf (name
, "$f%d", i
- 32);
5482 alpha_register_table
[i
] = symbol_create (name
, reg_section
, i
,
5483 &zero_address_frag
);
5486 /* Create the special symbols and sections we'll be using. */
5488 /* So .sbss will get used for tiny objects. */
5489 bfd_set_gp_size (stdoutput
, g_switch_value
);
5492 create_literal_section (".lita", &alpha_lita_section
, &alpha_lita_symbol
);
5494 /* For handling the GP, create a symbol that won't be output in the
5495 symbol table. We'll edit it out of relocs later. */
5496 alpha_gp_symbol
= symbol_create ("<GP value>", alpha_lita_section
, 0x8000,
5497 &zero_address_frag
);
5501 create_literal_section (".link", &alpha_link_section
, &alpha_link_symbol
);
5505 if (ECOFF_DEBUGGING
)
5507 segT sec
= subseg_new (".mdebug", (subsegT
) 0);
5508 bfd_set_section_flags (sec
, SEC_HAS_CONTENTS
| SEC_READONLY
);
5509 bfd_set_section_alignment (sec
, 3);
5513 /* Create literal lookup hash table. */
5514 alpha_literal_hash
= str_htab_create ();
5516 subseg_set (text_section
, 0);
5519 /* The public interface to the instruction assembler. */
5522 md_assemble (char *str
)
5524 /* Current maximum is 13. */
5526 expressionS tok
[MAX_INSN_ARGS
];
5530 /* Split off the opcode. */
5531 opnamelen
= strspn (str
, "abcdefghijklmnopqrstuvwxyz_/46819");
5532 trunclen
= (opnamelen
< sizeof (opname
) - 1
5534 : sizeof (opname
) - 1);
5535 memcpy (opname
, str
, trunclen
);
5536 opname
[trunclen
] = '\0';
5538 /* Tokenize the rest of the line. */
5539 if ((ntok
= tokenize_arguments (str
+ opnamelen
, tok
, MAX_INSN_ARGS
)) < 0)
5541 if (ntok
!= TOKENIZE_ERROR_REPORT
)
5542 as_bad (_("syntax error"));
5547 /* Finish it off. */
5548 assemble_tokens (opname
, tok
, ntok
, alpha_macros_on
);
5551 /* Round up a section's size to the appropriate boundary. */
5554 md_section_align (segT seg
, valueT size
)
5556 int align
= bfd_section_alignment (seg
);
5557 valueT mask
= ((valueT
) 1 << align
) - 1;
5559 return (size
+ mask
) & ~mask
;
5562 /* Turn a string in input_line_pointer into a floating point constant
5563 of type TYPE, and store the appropriate bytes in *LITP. The number
5564 of LITTLENUMS emitted is stored in *SIZEP. An error message is
5565 returned, or NULL on OK. */
5568 md_atof (int type
, char *litP
, int *sizeP
)
5570 extern const char *vax_md_atof (int, char *, int *);
5576 /* vax_md_atof() doesn't like "G" for some reason. */
5581 return vax_md_atof (type
, litP
, sizeP
);
5584 return ieee_md_atof (type
, litP
, sizeP
, FALSE
);
5588 /* Take care of the target-specific command-line options. */
5591 md_parse_option (int c
, const char *arg
)
5596 alpha_nofloats_on
= 1;
5600 alpha_addr32_on
= 1;
5608 g_switch_value
= atoi (arg
);
5613 const struct cpu_type
*p
;
5615 for (p
= cpu_types
; p
->name
; ++p
)
5616 if (strcmp (arg
, p
->name
) == 0)
5618 alpha_target_name
= p
->name
, alpha_target
= p
->flags
;
5621 as_warn (_("Unknown CPU identifier `%s'"), arg
);
5627 case '+': /* For g++. Hash any name > 63 chars long. */
5628 alpha_flag_hash_long_names
= 1;
5631 case 'H': /* Show new symbol after hash truncation. */
5632 alpha_flag_show_after_trunc
= 1;
5635 case 'h': /* For gnu-c/vax compatibility. */
5638 case OPTION_REPLACE
:
5639 alpha_flag_replace
= 1;
5642 case OPTION_NOREPLACE
:
5643 alpha_flag_replace
= 0;
5648 alpha_flag_relax
= 1;
5653 alpha_flag_mdebug
= 1;
5655 case OPTION_NO_MDEBUG
:
5656 alpha_flag_mdebug
= 0;
5667 /* Print a description of the command-line options that we accept. */
5670 md_show_usage (FILE *stream
)
5674 -32addr treat addresses as 32-bit values\n\
5675 -F lack floating point instructions support\n\
5676 -mev4 | -mev45 | -mev5 | -mev56 | -mpca56 | -mev6 | -mev67 | -mev68 | -mall\n\
5677 specify variant of Alpha architecture\n\
5678 -m21064 | -m21066 | -m21164 | -m21164a | -m21164pc | -m21264 | -m21264a | -m21264b\n\
5679 these variants include PALcode opcodes\n"),
5684 -+ encode (don't truncate) names longer than 64 characters\n\
5685 -H show new symbol after hash truncation\n\
5686 -replace/-noreplace enable or disable the optimization of procedure calls\n"),
5691 /* Decide from what point a pc-relative relocation is relative to,
5692 relative to the pc-relative fixup. Er, relatively speaking. */
5695 md_pcrel_from (fixS
*fixP
)
5697 valueT addr
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
5699 switch (fixP
->fx_r_type
)
5701 case BFD_RELOC_23_PCREL_S2
:
5702 case BFD_RELOC_ALPHA_HINT
:
5703 case BFD_RELOC_ALPHA_BRSGP
:
5710 /* Attempt to simplify or even eliminate a fixup. The return value is
5711 ignored; perhaps it was once meaningful, but now it is historical.
5712 To indicate that a fixup has been eliminated, set fixP->fx_done.
5714 For ELF, here it is that we transform the GPDISP_HI16 reloc we used
5715 internally into the GPDISP reloc used externally. We had to do
5716 this so that we'd have the GPDISP_LO16 reloc as a tag to compute
5717 the distance to the "lda" instruction for setting the addend to
5721 md_apply_fix (fixS
*fixP
, valueT
* valP
, segT seg
)
5723 char * const fixpos
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5724 valueT value
= * valP
;
5725 unsigned image
, size
;
5727 switch (fixP
->fx_r_type
)
5729 /* The GPDISP relocations are processed internally with a symbol
5730 referring to the current function's section; we need to drop
5731 in a value which, when added to the address of the start of
5732 the function, gives the desired GP. */
5733 case BFD_RELOC_ALPHA_GPDISP_HI16
:
5735 fixS
*next
= fixP
->fx_next
;
5737 /* With user-specified !gpdisp relocations, we can be missing
5738 the matching LO16 reloc. We will have already issued an
5741 fixP
->fx_offset
= (next
->fx_frag
->fr_address
+ next
->fx_where
5742 - fixP
->fx_frag
->fr_address
- fixP
->fx_where
);
5744 value
= (value
- sign_extend_16 (value
)) >> 16;
5747 fixP
->fx_r_type
= BFD_RELOC_ALPHA_GPDISP
;
5751 case BFD_RELOC_ALPHA_GPDISP_LO16
:
5752 value
= sign_extend_16 (value
);
5753 fixP
->fx_offset
= 0;
5759 fixP
->fx_addsy
= section_symbol (seg
);
5760 md_number_to_chars (fixpos
, value
, 2);
5765 fixP
->fx_r_type
= BFD_RELOC_8_PCREL
;
5771 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
5777 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
5783 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
5787 if (fixP
->fx_pcrel
== 0 && fixP
->fx_addsy
== 0)
5789 md_number_to_chars (fixpos
, value
, size
);
5795 case BFD_RELOC_GPREL32
:
5796 gas_assert (fixP
->fx_subsy
== alpha_gp_symbol
);
5798 /* FIXME: inherited this obliviousness of `value' -- why? */
5799 md_number_to_chars (fixpos
, -alpha_gp_value
, 4);
5802 case BFD_RELOC_GPREL32
:
5804 case BFD_RELOC_GPREL16
:
5805 case BFD_RELOC_ALPHA_GPREL_HI16
:
5806 case BFD_RELOC_ALPHA_GPREL_LO16
:
5809 case BFD_RELOC_23_PCREL_S2
:
5810 if (fixP
->fx_pcrel
== 0 && fixP
->fx_addsy
== 0)
5812 image
= bfd_getl32 (fixpos
);
5813 image
= (image
& ~0x1FFFFF) | ((value
>> 2) & 0x1FFFFF);
5818 case BFD_RELOC_ALPHA_HINT
:
5819 if (fixP
->fx_pcrel
== 0 && fixP
->fx_addsy
== 0)
5821 image
= bfd_getl32 (fixpos
);
5822 image
= (image
& ~0x3FFF) | ((value
>> 2) & 0x3FFF);
5828 case BFD_RELOC_ALPHA_BRSGP
:
5831 case BFD_RELOC_ALPHA_TLSGD
:
5832 case BFD_RELOC_ALPHA_TLSLDM
:
5833 case BFD_RELOC_ALPHA_GOTDTPREL16
:
5834 case BFD_RELOC_ALPHA_DTPREL_HI16
:
5835 case BFD_RELOC_ALPHA_DTPREL_LO16
:
5836 case BFD_RELOC_ALPHA_DTPREL16
:
5837 case BFD_RELOC_ALPHA_GOTTPREL16
:
5838 case BFD_RELOC_ALPHA_TPREL_HI16
:
5839 case BFD_RELOC_ALPHA_TPREL_LO16
:
5840 case BFD_RELOC_ALPHA_TPREL16
:
5842 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
5847 case BFD_RELOC_ALPHA_LITERAL
:
5848 md_number_to_chars (fixpos
, value
, 2);
5851 case BFD_RELOC_ALPHA_ELF_LITERAL
:
5852 case BFD_RELOC_ALPHA_LITUSE
:
5853 case BFD_RELOC_ALPHA_LINKAGE
:
5854 case BFD_RELOC_ALPHA_CODEADDR
:
5858 case BFD_RELOC_ALPHA_NOP
:
5859 value
-= (8 + 4); /* PC-relative, base is jsr+4. */
5861 /* From B.4.5.2 of the OpenVMS Linker Utility Manual:
5862 "Finally, the ETIR$C_STC_BSR command passes the same address
5863 as ETIR$C_STC_NOP (so that they will fail or succeed together),
5864 and the same test is done again." */
5865 if (S_GET_SEGMENT (fixP
->fx_addsy
) == undefined_section
)
5867 fixP
->fx_addnumber
= -value
;
5871 if (value
+ (1u << 22) >= (1u << 23))
5875 /* Change to a nop. */
5880 case BFD_RELOC_ALPHA_LDA
:
5881 /* fixup_segment sets fixP->fx_addsy to NULL when it can pre-compute
5882 the value for an O_subtract. */
5884 && S_GET_SEGMENT (fixP
->fx_addsy
) == undefined_section
)
5886 fixP
->fx_addnumber
= symbol_get_bfdsym (fixP
->fx_subsy
)->value
;
5890 if (value
+ (1u << 15) >= (1u << 16))
5894 /* Change to an lda. */
5895 image
= 0x237B0000 | (value
& 0xFFFF);
5899 case BFD_RELOC_ALPHA_BSR
:
5900 case BFD_RELOC_ALPHA_BOH
:
5901 value
-= 4; /* PC-relative, base is jsr+4. */
5903 /* See comment in the BFD_RELOC_ALPHA_NOP case above. */
5904 if (S_GET_SEGMENT (fixP
->fx_addsy
) == undefined_section
)
5906 fixP
->fx_addnumber
= -value
;
5910 if (value
+ (1u << 22) >= (1u << 23))
5913 if (fixP
->fx_r_type
== BFD_RELOC_ALPHA_BOH
)
5916 image
= bfd_getl32(fixpos
);
5917 image
= (image
& ~0x3FFF) | ((value
>> 2) & 0x3FFF);
5924 /* Change to a branch. */
5925 image
= 0xD3400000 | ((value
>> 2) & 0x1FFFFF);
5930 case BFD_RELOC_VTABLE_INHERIT
:
5931 case BFD_RELOC_VTABLE_ENTRY
:
5936 const struct alpha_operand
*operand
;
5938 if ((int) fixP
->fx_r_type
>= 0)
5939 as_fatal (_("unhandled relocation type %s"),
5940 bfd_get_reloc_code_name (fixP
->fx_r_type
));
5942 gas_assert (-(int) fixP
->fx_r_type
< (int) alpha_num_operands
);
5943 operand
= &alpha_operands
[-(int) fixP
->fx_r_type
];
5945 /* The rest of these fixups only exist internally during symbol
5946 resolution and have no representation in the object file.
5947 Therefore they must be completely resolved as constants. */
5949 if (fixP
->fx_addsy
!= 0
5950 && S_GET_SEGMENT (fixP
->fx_addsy
) != absolute_section
)
5951 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5952 _("non-absolute expression in constant field"));
5954 image
= bfd_getl32 (fixpos
);
5955 image
= insert_operand (image
, operand
, (offsetT
) value
,
5956 fixP
->fx_file
, fixP
->fx_line
);
5961 if (fixP
->fx_addsy
!= 0 || fixP
->fx_pcrel
!= 0)
5965 as_warn_where (fixP
->fx_file
, fixP
->fx_line
,
5966 _("type %d reloc done?\n"), (int) fixP
->fx_r_type
);
5971 md_number_to_chars (fixpos
, image
, 4);
5977 /* Look for a register name in the given symbol. */
5980 md_undefined_symbol (char *name
)
5984 int is_float
= 0, num
;
5989 if (name
[1] == 'p' && name
[2] == '\0')
5990 return alpha_register_table
[AXP_REG_FP
];
5995 if (!ISDIGIT (*++name
))
5999 case '0': case '1': case '2': case '3': case '4':
6000 case '5': case '6': case '7': case '8': case '9':
6001 if (name
[1] == '\0')
6002 num
= name
[0] - '0';
6003 else if (name
[0] != '0' && ISDIGIT (name
[1]) && name
[2] == '\0')
6005 num
= (name
[0] - '0') * 10 + name
[1] - '0';
6012 if (!alpha_noat_on
&& (num
+ is_float
) == AXP_REG_AT
)
6013 as_warn (_("Used $at without \".set noat\""));
6014 return alpha_register_table
[num
+ is_float
];
6017 if (name
[1] == 't' && name
[2] == '\0')
6020 as_warn (_("Used $at without \".set noat\""));
6021 return alpha_register_table
[AXP_REG_AT
];
6026 if (name
[1] == 'p' && name
[2] == '\0')
6027 return alpha_register_table
[alpha_gp_register
];
6031 if (name
[1] == 'p' && name
[2] == '\0')
6032 return alpha_register_table
[AXP_REG_SP
];
6040 /* @@@ Magic ECOFF bits. */
6043 alpha_frob_ecoff_data (void)
6046 /* $zero and $f31 are read-only. */
6047 alpha_gprmask
&= ~1;
6048 alpha_fprmask
&= ~1;
6052 /* Hook to remember a recently defined label so that the auto-align
6053 code can adjust the symbol after we know what alignment will be
6057 alpha_define_label (symbolS
*sym
)
6059 alpha_insn_label
= sym
;
6061 dwarf2_emit_label (sym
);
6065 /* Return true if we must always emit a reloc for a type and false if
6066 there is some hope of resolving it at assembly time. */
6069 alpha_force_relocation (fixS
*f
)
6071 if (alpha_flag_relax
)
6074 switch (f
->fx_r_type
)
6076 case BFD_RELOC_ALPHA_GPDISP_HI16
:
6077 case BFD_RELOC_ALPHA_GPDISP_LO16
:
6078 case BFD_RELOC_ALPHA_GPDISP
:
6079 case BFD_RELOC_ALPHA_LITERAL
:
6080 case BFD_RELOC_ALPHA_ELF_LITERAL
:
6081 case BFD_RELOC_ALPHA_LITUSE
:
6082 case BFD_RELOC_GPREL16
:
6083 case BFD_RELOC_GPREL32
:
6084 case BFD_RELOC_ALPHA_GPREL_HI16
:
6085 case BFD_RELOC_ALPHA_GPREL_LO16
:
6086 case BFD_RELOC_ALPHA_LINKAGE
:
6087 case BFD_RELOC_ALPHA_CODEADDR
:
6088 case BFD_RELOC_ALPHA_BRSGP
:
6089 case BFD_RELOC_ALPHA_TLSGD
:
6090 case BFD_RELOC_ALPHA_TLSLDM
:
6091 case BFD_RELOC_ALPHA_GOTDTPREL16
:
6092 case BFD_RELOC_ALPHA_DTPREL_HI16
:
6093 case BFD_RELOC_ALPHA_DTPREL_LO16
:
6094 case BFD_RELOC_ALPHA_DTPREL16
:
6095 case BFD_RELOC_ALPHA_GOTTPREL16
:
6096 case BFD_RELOC_ALPHA_TPREL_HI16
:
6097 case BFD_RELOC_ALPHA_TPREL_LO16
:
6098 case BFD_RELOC_ALPHA_TPREL16
:
6100 case BFD_RELOC_ALPHA_NOP
:
6101 case BFD_RELOC_ALPHA_BSR
:
6102 case BFD_RELOC_ALPHA_LDA
:
6103 case BFD_RELOC_ALPHA_BOH
:
6111 return generic_force_reloc (f
);
6114 /* Return true if we can partially resolve a relocation now. */
6117 alpha_fix_adjustable (fixS
*f
)
6119 /* Are there any relocation types for which we must generate a
6120 reloc but we can adjust the values contained within it? */
6121 switch (f
->fx_r_type
)
6123 case BFD_RELOC_ALPHA_GPDISP_HI16
:
6124 case BFD_RELOC_ALPHA_GPDISP_LO16
:
6125 case BFD_RELOC_ALPHA_GPDISP
:
6128 case BFD_RELOC_ALPHA_LITERAL
:
6129 case BFD_RELOC_ALPHA_ELF_LITERAL
:
6130 case BFD_RELOC_ALPHA_LITUSE
:
6131 case BFD_RELOC_ALPHA_LINKAGE
:
6132 case BFD_RELOC_ALPHA_CODEADDR
:
6135 case BFD_RELOC_VTABLE_ENTRY
:
6136 case BFD_RELOC_VTABLE_INHERIT
:
6139 case BFD_RELOC_GPREL16
:
6140 case BFD_RELOC_GPREL32
:
6141 case BFD_RELOC_ALPHA_GPREL_HI16
:
6142 case BFD_RELOC_ALPHA_GPREL_LO16
:
6143 case BFD_RELOC_23_PCREL_S2
:
6147 case BFD_RELOC_ALPHA_HINT
:
6150 case BFD_RELOC_ALPHA_TLSGD
:
6151 case BFD_RELOC_ALPHA_TLSLDM
:
6152 case BFD_RELOC_ALPHA_GOTDTPREL16
:
6153 case BFD_RELOC_ALPHA_DTPREL_HI16
:
6154 case BFD_RELOC_ALPHA_DTPREL_LO16
:
6155 case BFD_RELOC_ALPHA_DTPREL16
:
6156 case BFD_RELOC_ALPHA_GOTTPREL16
:
6157 case BFD_RELOC_ALPHA_TPREL_HI16
:
6158 case BFD_RELOC_ALPHA_TPREL_LO16
:
6159 case BFD_RELOC_ALPHA_TPREL16
:
6160 /* ??? No idea why we can't return a reference to .tbss+10, but
6161 we're preventing this in the other assemblers. Follow for now. */
6165 case BFD_RELOC_ALPHA_BRSGP
:
6166 /* If we have a BRSGP reloc to a local symbol, adjust it to BRADDR and
6167 let it get resolved at assembly time. */
6169 symbolS
*sym
= f
->fx_addsy
;
6173 if (generic_force_reloc (f
))
6176 switch (S_GET_OTHER (sym
) & STO_ALPHA_STD_GPLOAD
)
6178 case STO_ALPHA_NOPV
:
6180 case STO_ALPHA_STD_GPLOAD
:
6184 if (S_IS_LOCAL (sym
))
6187 name
= S_GET_NAME (sym
);
6188 as_bad_where (f
->fx_file
, f
->fx_line
,
6189 _("!samegp reloc against symbol without .prologue: %s"),
6193 f
->fx_r_type
= BFD_RELOC_23_PCREL_S2
;
6194 f
->fx_offset
+= offset
;
6199 case BFD_RELOC_ALPHA_NOP
:
6200 case BFD_RELOC_ALPHA_BSR
:
6201 case BFD_RELOC_ALPHA_LDA
:
6202 case BFD_RELOC_ALPHA_BOH
:
6211 /* Generate the BFD reloc to be stuck in the object file from the
6212 fixup used internally in the assembler. */
6215 tc_gen_reloc (asection
*sec ATTRIBUTE_UNUSED
,
6220 reloc
= XNEW (arelent
);
6221 reloc
->sym_ptr_ptr
= XNEW (asymbol
*);
6222 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
6223 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6225 /* Make sure none of our internal relocations make it this far.
6226 They'd better have been fully resolved by this point. */
6227 gas_assert ((int) fixp
->fx_r_type
> 0);
6229 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
6230 if (reloc
->howto
== NULL
)
6232 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
6233 _("cannot represent `%s' relocation in object file"),
6234 bfd_get_reloc_code_name (fixp
->fx_r_type
));
6238 if (!fixp
->fx_pcrel
!= !reloc
->howto
->pc_relative
)
6239 as_fatal (_("internal error? cannot generate `%s' relocation"),
6240 bfd_get_reloc_code_name (fixp
->fx_r_type
));
6242 gas_assert (!fixp
->fx_pcrel
== !reloc
->howto
->pc_relative
);
6244 reloc
->addend
= fixp
->fx_offset
;
6247 /* Fake out bfd_perform_relocation. sigh. */
6248 /* ??? Better would be to use the special_function hook. */
6249 if (fixp
->fx_r_type
== BFD_RELOC_ALPHA_LITERAL
)
6250 reloc
->addend
= -alpha_gp_value
;
6254 switch (fixp
->fx_r_type
)
6256 struct evax_private_udata_struct
*udata
;
6260 case BFD_RELOC_ALPHA_LINKAGE
:
6261 /* Copy the linkage index. */
6262 reloc
->addend
= fixp
->fx_addnumber
;
6265 case BFD_RELOC_ALPHA_NOP
:
6266 case BFD_RELOC_ALPHA_BSR
:
6267 case BFD_RELOC_ALPHA_LDA
:
6268 case BFD_RELOC_ALPHA_BOH
:
6269 pname
= symbol_get_bfdsym (fixp
->fx_addsy
)->name
;
6271 /* We need the non-suffixed name of the procedure. Beware that
6272 the main symbol might be equated so look it up and take its name. */
6273 pname_len
= strlen (pname
);
6274 if (pname_len
> 4 && strcmp (pname
+ pname_len
- 4, "..en") == 0)
6277 char *my_pname
= xmemdup0 (pname
, pname_len
- 4);
6278 sym
= symbol_find (my_pname
);
6283 while (symbol_equated_reloc_p (sym
))
6285 symbolS
*n
= symbol_get_value_expression (sym
)->X_add_symbol
;
6287 /* We must avoid looping, as that can occur with a badly
6293 pname
= symbol_get_bfdsym (sym
)->name
;
6296 udata
= XNEW (struct evax_private_udata_struct
);
6297 udata
->enbsym
= symbol_get_bfdsym (fixp
->fx_addsy
);
6298 udata
->bsym
= symbol_get_bfdsym (fixp
->tc_fix_data
.info
->psym
);
6299 udata
->origname
= (char *)pname
;
6300 udata
->lkindex
= ((struct evax_private_udata_struct
*)
6301 symbol_get_bfdsym (fixp
->tc_fix_data
.info
->sym
)->udata
.p
)->lkindex
;
6302 reloc
->sym_ptr_ptr
= (void *)udata
;
6303 reloc
->addend
= fixp
->fx_addnumber
;
6313 /* Parse a register name off of the input_line and return a register
6314 number. Gets md_undefined_symbol above to do the register name
6317 Only called as a part of processing the ECOFF .frame directive. */
6320 tc_get_register (int frame ATTRIBUTE_UNUSED
)
6322 int framereg
= AXP_REG_SP
;
6325 if (*input_line_pointer
== '$')
6328 char c
= get_symbol_name (&s
);
6329 symbolS
*sym
= md_undefined_symbol (s
);
6331 *strchr (s
, '\0') = c
;
6332 if (sym
&& (framereg
= S_GET_VALUE (sym
)) <= 31)
6335 as_warn (_("frame reg expected, using $%d."), framereg
);
6338 note_gpreg (framereg
);
6342 /* This is called before the symbol table is processed. In order to
6343 work with gcc when using mips-tfile, we must keep all local labels.
6344 However, in other cases, we want to discard them. If we were
6345 called with -g, but we didn't see any debugging information, it may
6346 mean that gcc is smuggling debugging information through to
6347 mips-tfile, in which case we must generate all local labels. */
6352 alpha_frob_file_before_adjust (void)
6354 if (alpha_debug
!= 0
6355 && ! ecoff_debugging_seen
)
6356 flag_keep_locals
= 1;
6359 #endif /* OBJ_ECOFF */
6361 /* The Alpha has support for some VAX floating point types, as well as for
6362 IEEE floating point. We consider IEEE to be the primary floating point
6363 format, and sneak in the VAX floating point support here. */
6364 #include "config/atof-vax.c"