1 /* tc-alpha.c - Processor-specific code for the DEC Alpha AXP CPU.
2 Copyright 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
5 Contributed by Carnegie Mellon University, 1993.
6 Written by Alessandro Forin, based on earlier gas-1.38 target CPU files.
7 Modified by Ken Raeburn for gas-2.x and ECOFF support.
8 Modified by Richard Henderson for ELF support.
9 Modified by Klaus K"ampf for EVAX (OpenVMS/Alpha) support.
11 This file is part of GAS, the GNU Assembler.
13 GAS is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 3, or (at your option)
18 GAS is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with GAS; see the file COPYING. If not, write to the Free
25 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
28 /* Mach Operating System
29 Copyright (c) 1993 Carnegie Mellon University
32 Permission to use, copy, modify and distribute this software and its
33 documentation is hereby granted, provided that both the copyright
34 notice and this permission notice appear in all copies of the
35 software, derivative works or modified versions, and any portions
36 thereof, and that both notices appear in supporting documentation.
38 CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
39 CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
40 ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
42 Carnegie Mellon requests users of this software to return to
44 Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
45 School of Computer Science
46 Carnegie Mellon University
47 Pittsburgh PA 15213-3890
49 any improvements or extensions that they make and grant Carnegie the
50 rights to redistribute these changes. */
54 #include "struc-symbol.h"
57 #include "opcode/alpha.h"
60 #include "elf/alpha.h"
68 #include "dwarf2dbg.h"
69 #include "dw2gencfi.h"
70 #include "safe-ctype.h"
74 #define TOKENIZE_ERROR -1
75 #define TOKENIZE_ERROR_REPORT -2
76 #define MAX_INSN_FIXUPS 2
77 #define MAX_INSN_ARGS 5
79 /* Used since new relocation types are introduced in this
80 file (DUMMY_RELOC_LITUSE_*) */
81 typedef int extended_bfd_reloc_code_real_type
;
86 /* bfd_reloc_code_real_type reloc; */
87 extended_bfd_reloc_code_real_type reloc
;
89 /* The symbol of the item in the linkage section. */
92 /* The symbol of the procedure descriptor. */
101 struct alpha_fixup fixups
[MAX_INSN_FIXUPS
];
119 void (*emit
) (const expressionS
*, int, const void *);
121 enum alpha_macro_arg argsets
[16];
124 /* Extra expression types. */
126 #define O_pregister O_md1 /* O_register, in parentheses. */
127 #define O_cpregister O_md2 /* + a leading comma. */
129 /* The alpha_reloc_op table below depends on the ordering of these. */
130 #define O_literal O_md3 /* !literal relocation. */
131 #define O_lituse_addr O_md4 /* !lituse_addr relocation. */
132 #define O_lituse_base O_md5 /* !lituse_base relocation. */
133 #define O_lituse_bytoff O_md6 /* !lituse_bytoff relocation. */
134 #define O_lituse_jsr O_md7 /* !lituse_jsr relocation. */
135 #define O_lituse_tlsgd O_md8 /* !lituse_tlsgd relocation. */
136 #define O_lituse_tlsldm O_md9 /* !lituse_tlsldm relocation. */
137 #define O_lituse_jsrdirect O_md10 /* !lituse_jsrdirect relocation. */
138 #define O_gpdisp O_md11 /* !gpdisp relocation. */
139 #define O_gprelhigh O_md12 /* !gprelhigh relocation. */
140 #define O_gprellow O_md13 /* !gprellow relocation. */
141 #define O_gprel O_md14 /* !gprel relocation. */
142 #define O_samegp O_md15 /* !samegp relocation. */
143 #define O_tlsgd O_md16 /* !tlsgd relocation. */
144 #define O_tlsldm O_md17 /* !tlsldm relocation. */
145 #define O_gotdtprel O_md18 /* !gotdtprel relocation. */
146 #define O_dtprelhi O_md19 /* !dtprelhi relocation. */
147 #define O_dtprello O_md20 /* !dtprello relocation. */
148 #define O_dtprel O_md21 /* !dtprel relocation. */
149 #define O_gottprel O_md22 /* !gottprel relocation. */
150 #define O_tprelhi O_md23 /* !tprelhi relocation. */
151 #define O_tprello O_md24 /* !tprello relocation. */
152 #define O_tprel O_md25 /* !tprel relocation. */
154 #define DUMMY_RELOC_LITUSE_ADDR (BFD_RELOC_UNUSED + 1)
155 #define DUMMY_RELOC_LITUSE_BASE (BFD_RELOC_UNUSED + 2)
156 #define DUMMY_RELOC_LITUSE_BYTOFF (BFD_RELOC_UNUSED + 3)
157 #define DUMMY_RELOC_LITUSE_JSR (BFD_RELOC_UNUSED + 4)
158 #define DUMMY_RELOC_LITUSE_TLSGD (BFD_RELOC_UNUSED + 5)
159 #define DUMMY_RELOC_LITUSE_TLSLDM (BFD_RELOC_UNUSED + 6)
160 #define DUMMY_RELOC_LITUSE_JSRDIRECT (BFD_RELOC_UNUSED + 7)
162 #define USER_RELOC_P(R) ((R) >= O_literal && (R) <= O_tprel)
164 /* Macros for extracting the type and number of encoded register tokens. */
166 #define is_ir_num(x) (((x) & 32) == 0)
167 #define is_fpr_num(x) (((x) & 32) != 0)
168 #define regno(x) ((x) & 31)
170 /* Something odd inherited from the old assembler. */
172 #define note_gpreg(R) (alpha_gprmask |= (1 << (R)))
173 #define note_fpreg(R) (alpha_fprmask |= (1 << (R)))
175 /* Predicates for 16- and 32-bit ranges */
176 /* XXX: The non-shift version appears to trigger a compiler bug when
177 cross-assembling from x86 w/ gcc 2.7.2. */
180 #define range_signed_16(x) \
181 (((offsetT) (x) >> 15) == 0 || ((offsetT) (x) >> 15) == -1)
182 #define range_signed_32(x) \
183 (((offsetT) (x) >> 31) == 0 || ((offsetT) (x) >> 31) == -1)
185 #define range_signed_16(x) ((offsetT) (x) >= -(offsetT) 0x8000 && \
186 (offsetT) (x) <= (offsetT) 0x7FFF)
187 #define range_signed_32(x) ((offsetT) (x) >= -(offsetT) 0x80000000 && \
188 (offsetT) (x) <= (offsetT) 0x7FFFFFFF)
191 /* Macros for sign extending from 16- and 32-bits. */
192 /* XXX: The cast macros will work on all the systems that I care about,
193 but really a predicate should be found to use the non-cast forms. */
196 #define sign_extend_16(x) ((short) (x))
197 #define sign_extend_32(x) ((int) (x))
199 #define sign_extend_16(x) ((offsetT) (((x) & 0xFFFF) ^ 0x8000) - 0x8000)
200 #define sign_extend_32(x) ((offsetT) (((x) & 0xFFFFFFFF) \
201 ^ 0x80000000) - 0x80000000)
204 /* Macros to build tokens. */
206 #define set_tok_reg(t, r) (memset (&(t), 0, sizeof (t)), \
207 (t).X_op = O_register, \
208 (t).X_add_number = (r))
209 #define set_tok_preg(t, r) (memset (&(t), 0, sizeof (t)), \
210 (t).X_op = O_pregister, \
211 (t).X_add_number = (r))
212 #define set_tok_cpreg(t, r) (memset (&(t), 0, sizeof (t)), \
213 (t).X_op = O_cpregister, \
214 (t).X_add_number = (r))
215 #define set_tok_freg(t, r) (memset (&(t), 0, sizeof (t)), \
216 (t).X_op = O_register, \
217 (t).X_add_number = (r) + 32)
218 #define set_tok_sym(t, s, a) (memset (&(t), 0, sizeof (t)), \
219 (t).X_op = O_symbol, \
220 (t).X_add_symbol = (s), \
221 (t).X_add_number = (a))
222 #define set_tok_const(t, n) (memset (&(t), 0, sizeof (t)), \
223 (t).X_op = O_constant, \
224 (t).X_add_number = (n))
226 /* Generic assembler global variables which must be defined by all
229 /* Characters which always start a comment. */
230 const char comment_chars
[] = "#";
232 /* Characters which start a comment at the beginning of a line. */
233 const char line_comment_chars
[] = "#";
235 /* Characters which may be used to separate multiple commands on a
237 const char line_separator_chars
[] = ";";
239 /* Characters which are used to indicate an exponent in a floating
241 const char EXP_CHARS
[] = "eE";
243 /* Characters which mean that a number is a floating point constant,
245 /* XXX: Do all of these really get used on the alpha?? */
246 char FLT_CHARS
[] = "rRsSfFdDxXpP";
249 const char *md_shortopts
= "Fm:g+1h:HG:";
251 const char *md_shortopts
= "Fm:gG:";
254 struct option md_longopts
[] =
256 #define OPTION_32ADDR (OPTION_MD_BASE)
257 { "32addr", no_argument
, NULL
, OPTION_32ADDR
},
258 #define OPTION_RELAX (OPTION_32ADDR + 1)
259 { "relax", no_argument
, NULL
, OPTION_RELAX
},
261 #define OPTION_MDEBUG (OPTION_RELAX + 1)
262 #define OPTION_NO_MDEBUG (OPTION_MDEBUG + 1)
263 { "mdebug", no_argument
, NULL
, OPTION_MDEBUG
},
264 { "no-mdebug", no_argument
, NULL
, OPTION_NO_MDEBUG
},
267 #define OPTION_REPLACE (OPTION_RELAX + 1)
268 #define OPTION_NOREPLACE (OPTION_REPLACE+1)
269 { "replace", no_argument
, NULL
, OPTION_REPLACE
},
270 { "noreplace", no_argument
, NULL
, OPTION_NOREPLACE
},
272 { NULL
, no_argument
, NULL
, 0 }
275 size_t md_longopts_size
= sizeof (md_longopts
);
279 #define AXP_REG_R16 16
280 #define AXP_REG_R17 17
282 #define AXP_REG_T9 22
284 #define AXP_REG_T10 23
286 #define AXP_REG_T11 24
288 #define AXP_REG_T12 25
289 #define AXP_REG_AI 25
291 #define AXP_REG_FP 29
294 #define AXP_REG_GP AXP_REG_PV
296 static struct hash_control
*alpha_evax_proc_hash
;
298 #endif /* OBJ_EVAX */
300 /* The cpu for which we are generating code. */
301 static unsigned alpha_target
= AXP_OPCODE_BASE
;
302 static const char *alpha_target_name
= "<all>";
304 /* The hash table of instruction opcodes. */
305 static struct hash_control
*alpha_opcode_hash
;
307 /* The hash table of macro opcodes. */
308 static struct hash_control
*alpha_macro_hash
;
311 /* The $gp relocation symbol. */
312 static symbolS
*alpha_gp_symbol
;
314 /* XXX: what is this, and why is it exported? */
315 valueT alpha_gp_value
;
318 /* The current $gp register. */
319 static int alpha_gp_register
= AXP_REG_GP
;
321 /* A table of the register symbols. */
322 static symbolS
*alpha_register_table
[64];
324 /* Constant sections, or sections of constants. */
326 static segT alpha_lita_section
;
329 segT alpha_link_section
;
332 static segT alpha_lit8_section
;
335 /* Symbols referring to said sections. */
337 static symbolS
*alpha_lita_symbol
;
340 static symbolS
*alpha_link_symbol
;
343 static symbolS
*alpha_lit8_symbol
;
346 /* Literal for .litX+0x8000 within .lita. */
348 static offsetT alpha_lit8_literal
;
351 /* Is the assembler not allowed to use $at? */
352 static int alpha_noat_on
= 0;
354 /* Are macros enabled? */
355 static int alpha_macros_on
= 1;
357 /* Are floats disabled? */
358 static int alpha_nofloats_on
= 0;
360 /* Are addresses 32 bit? */
361 static int alpha_addr32_on
= 0;
363 /* Symbol labelling the current insn. When the Alpha gas sees
366 and the section happens to not be on an eight byte boundary, it
367 will align both the symbol and the .quad to an eight byte boundary. */
368 static symbolS
*alpha_insn_label
;
369 #if defined(OBJ_ELF) || defined (OBJ_EVAX)
370 static symbolS
*alpha_prologue_label
;
374 /* Symbol associate with the current jsr instruction. */
375 static symbolS
*alpha_linkage_symbol
;
378 /* Whether we should automatically align data generation pseudo-ops.
379 .align 0 will turn this off. */
380 static int alpha_auto_align_on
= 1;
382 /* The known current alignment of the current section. */
383 static int alpha_current_align
;
385 /* These are exported to ECOFF code. */
386 unsigned long alpha_gprmask
, alpha_fprmask
;
388 /* Whether the debugging option was seen. */
389 static int alpha_debug
;
392 /* Whether we are emitting an mdebug section. */
393 int alpha_flag_mdebug
= -1;
397 /* Whether to perform the VMS procedure call optimization. */
398 int alpha_flag_replace
= 1;
401 /* Don't fully resolve relocations, allowing code movement in the linker. */
402 static int alpha_flag_relax
;
404 /* What value to give to bfd_set_gp_size. */
405 static int g_switch_value
= 8;
408 /* Collect information about current procedure here. */
409 struct alpha_evax_procs
411 symbolS
*symbol
; /* Proc pdesc symbol. */
413 int framereg
; /* Register for frame pointer. */
414 int framesize
; /* Size of frame. */
426 /* Linked list of .linkage fixups. */
427 struct alpha_linkage_fixups
*alpha_linkage_fixup_root
;
428 static struct alpha_linkage_fixups
*alpha_linkage_fixup_tail
;
430 /* Current procedure descriptor. */
431 static struct alpha_evax_procs
*alpha_evax_proc
;
433 static int alpha_flag_hash_long_names
= 0; /* -+ */
434 static int alpha_flag_show_after_trunc
= 0; /* -H */
436 /* If the -+ switch is given, then a hash is appended to any name that is
437 longer than 64 characters, else longer symbol names are truncated. */
442 /* A table to map the spelling of a relocation operand into an appropriate
443 bfd_reloc_code_real_type type. The table is assumed to be ordered such
444 that op-O_literal indexes into it. */
446 #define ALPHA_RELOC_TABLE(op) \
447 (&alpha_reloc_op[ ((!USER_RELOC_P (op)) \
449 : (int) (op) - (int) O_literal) ])
451 #define DEF(NAME, RELOC, REQ, ALLOW) \
452 { #NAME, sizeof(#NAME)-1, O_##NAME, RELOC, REQ, ALLOW}
454 static const struct alpha_reloc_op_tag
456 const char *name
; /* String to lookup. */
457 size_t length
; /* Size of the string. */
458 operatorT op
; /* Which operator to use. */
459 extended_bfd_reloc_code_real_type reloc
;
460 unsigned int require_seq
: 1; /* Require a sequence number. */
461 unsigned int allow_seq
: 1; /* Allow a sequence number. */
465 DEF (literal
, BFD_RELOC_ALPHA_ELF_LITERAL
, 0, 1),
466 DEF (lituse_addr
, DUMMY_RELOC_LITUSE_ADDR
, 1, 1),
467 DEF (lituse_base
, DUMMY_RELOC_LITUSE_BASE
, 1, 1),
468 DEF (lituse_bytoff
, DUMMY_RELOC_LITUSE_BYTOFF
, 1, 1),
469 DEF (lituse_jsr
, DUMMY_RELOC_LITUSE_JSR
, 1, 1),
470 DEF (lituse_tlsgd
, DUMMY_RELOC_LITUSE_TLSGD
, 1, 1),
471 DEF (lituse_tlsldm
, DUMMY_RELOC_LITUSE_TLSLDM
, 1, 1),
472 DEF (lituse_jsrdirect
, DUMMY_RELOC_LITUSE_JSRDIRECT
, 1, 1),
473 DEF (gpdisp
, BFD_RELOC_ALPHA_GPDISP
, 1, 1),
474 DEF (gprelhigh
, BFD_RELOC_ALPHA_GPREL_HI16
, 0, 0),
475 DEF (gprellow
, BFD_RELOC_ALPHA_GPREL_LO16
, 0, 0),
476 DEF (gprel
, BFD_RELOC_GPREL16
, 0, 0),
477 DEF (samegp
, BFD_RELOC_ALPHA_BRSGP
, 0, 0),
478 DEF (tlsgd
, BFD_RELOC_ALPHA_TLSGD
, 0, 1),
479 DEF (tlsldm
, BFD_RELOC_ALPHA_TLSLDM
, 0, 1),
480 DEF (gotdtprel
, BFD_RELOC_ALPHA_GOTDTPREL16
, 0, 0),
481 DEF (dtprelhi
, BFD_RELOC_ALPHA_DTPREL_HI16
, 0, 0),
482 DEF (dtprello
, BFD_RELOC_ALPHA_DTPREL_LO16
, 0, 0),
483 DEF (dtprel
, BFD_RELOC_ALPHA_DTPREL16
, 0, 0),
484 DEF (gottprel
, BFD_RELOC_ALPHA_GOTTPREL16
, 0, 0),
485 DEF (tprelhi
, BFD_RELOC_ALPHA_TPREL_HI16
, 0, 0),
486 DEF (tprello
, BFD_RELOC_ALPHA_TPREL_LO16
, 0, 0),
487 DEF (tprel
, BFD_RELOC_ALPHA_TPREL16
, 0, 0),
492 static const int alpha_num_reloc_op
493 = sizeof (alpha_reloc_op
) / sizeof (*alpha_reloc_op
);
494 #endif /* RELOC_OP_P */
496 /* Maximum # digits needed to hold the largest sequence #. */
497 #define ALPHA_RELOC_DIGITS 25
499 /* Structure to hold explicit sequence information. */
500 struct alpha_reloc_tag
502 fixS
*master
; /* The literal reloc. */
504 struct symbol
*sym
; /* Linkage section item symbol. */
505 struct symbol
*psym
; /* Pdesc symbol. */
507 fixS
*slaves
; /* Head of linked list of lituses. */
508 segT segment
; /* Segment relocs are in or undefined_section. */
509 long sequence
; /* Sequence #. */
510 unsigned n_master
; /* # of literals. */
511 unsigned n_slaves
; /* # of lituses. */
512 unsigned saw_tlsgd
: 1; /* True if ... */
513 unsigned saw_tlsldm
: 1;
514 unsigned saw_lu_tlsgd
: 1;
515 unsigned saw_lu_tlsldm
: 1;
516 unsigned multi_section_p
: 1; /* True if more than one section was used. */
517 char string
[1]; /* Printable form of sequence to hash with. */
520 /* Hash table to link up literals with the appropriate lituse. */
521 static struct hash_control
*alpha_literal_hash
;
523 /* Sequence numbers for internal use by macros. */
524 static long next_sequence_num
= -1;
526 /* A table of CPU names and opcode sets. */
528 static const struct cpu_type
535 /* Ad hoc convention: cpu number gets palcode, process code doesn't.
536 This supports usage under DU 4.0b that does ".arch ev4", and
537 usage in MILO that does -m21064. Probably something more
538 specific like -m21064-pal should be used, but oh well. */
540 { "21064", AXP_OPCODE_BASE
|AXP_OPCODE_EV4
},
541 { "21064a", AXP_OPCODE_BASE
|AXP_OPCODE_EV4
},
542 { "21066", AXP_OPCODE_BASE
|AXP_OPCODE_EV4
},
543 { "21068", AXP_OPCODE_BASE
|AXP_OPCODE_EV4
},
544 { "21164", AXP_OPCODE_BASE
|AXP_OPCODE_EV5
},
545 { "21164a", AXP_OPCODE_BASE
|AXP_OPCODE_EV5
|AXP_OPCODE_BWX
},
546 { "21164pc", (AXP_OPCODE_BASE
|AXP_OPCODE_EV5
|AXP_OPCODE_BWX
548 { "21264", (AXP_OPCODE_BASE
|AXP_OPCODE_EV6
|AXP_OPCODE_BWX
549 |AXP_OPCODE_MAX
|AXP_OPCODE_CIX
) },
550 { "21264a", (AXP_OPCODE_BASE
|AXP_OPCODE_EV6
|AXP_OPCODE_BWX
551 |AXP_OPCODE_MAX
|AXP_OPCODE_CIX
) },
552 { "21264b", (AXP_OPCODE_BASE
|AXP_OPCODE_EV6
|AXP_OPCODE_BWX
553 |AXP_OPCODE_MAX
|AXP_OPCODE_CIX
) },
555 { "ev4", AXP_OPCODE_BASE
},
556 { "ev45", AXP_OPCODE_BASE
},
557 { "lca45", AXP_OPCODE_BASE
},
558 { "ev5", AXP_OPCODE_BASE
},
559 { "ev56", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
},
560 { "pca56", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
|AXP_OPCODE_MAX
},
561 { "ev6", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
|AXP_OPCODE_MAX
|AXP_OPCODE_CIX
},
562 { "ev67", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
|AXP_OPCODE_MAX
|AXP_OPCODE_CIX
},
563 { "ev68", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
|AXP_OPCODE_MAX
|AXP_OPCODE_CIX
},
565 { "all", AXP_OPCODE_BASE
},
569 /* Some instruction sets indexed by lg(size). */
570 static const char * const sextX_op
[] = { "sextb", "sextw", "sextl", NULL
};
571 static const char * const insXl_op
[] = { "insbl", "inswl", "insll", "insql" };
572 static const char * const insXh_op
[] = { NULL
, "inswh", "inslh", "insqh" };
573 static const char * const extXl_op
[] = { "extbl", "extwl", "extll", "extql" };
574 static const char * const extXh_op
[] = { NULL
, "extwh", "extlh", "extqh" };
575 static const char * const mskXl_op
[] = { "mskbl", "mskwl", "mskll", "mskql" };
576 static const char * const mskXh_op
[] = { NULL
, "mskwh", "msklh", "mskqh" };
577 static const char * const stX_op
[] = { "stb", "stw", "stl", "stq" };
578 static const char * const ldXu_op
[] = { "ldbu", "ldwu", NULL
, NULL
};
580 static void assemble_insn (const struct alpha_opcode
*, const expressionS
*, int, struct alpha_insn
*, extended_bfd_reloc_code_real_type
);
581 static void emit_insn (struct alpha_insn
*);
582 static void assemble_tokens (const char *, const expressionS
*, int, int);
584 static char *s_alpha_section_name (void);
585 static symbolS
*add_to_link_pool (symbolS
*, offsetT
);
588 static struct alpha_reloc_tag
*
589 get_alpha_reloc_tag (long sequence
)
591 char buffer
[ALPHA_RELOC_DIGITS
];
592 struct alpha_reloc_tag
*info
;
594 sprintf (buffer
, "!%ld", sequence
);
596 info
= (struct alpha_reloc_tag
*) hash_find (alpha_literal_hash
, buffer
);
599 size_t len
= strlen (buffer
);
602 info
= (struct alpha_reloc_tag
*)
603 xcalloc (sizeof (struct alpha_reloc_tag
) + len
, 1);
605 info
->segment
= now_seg
;
606 info
->sequence
= sequence
;
607 strcpy (info
->string
, buffer
);
608 errmsg
= hash_insert (alpha_literal_hash
, info
->string
, (void *) info
);
610 as_fatal ("%s", errmsg
);
623 alpha_adjust_relocs (bfd
*abfd ATTRIBUTE_UNUSED
,
625 void * ptr ATTRIBUTE_UNUSED
)
627 segment_info_type
*seginfo
= seg_info (sec
);
633 /* If seginfo is NULL, we did not create this section; don't do
634 anything with it. By using a pointer to a pointer, we can update
635 the links in place. */
639 /* If there are no relocations, skip the section. */
640 if (! seginfo
->fix_root
)
643 /* First rebuild the fixup chain without the explicit lituse and
644 gpdisp_lo16 relocs. */
645 prevP
= &seginfo
->fix_root
;
646 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= next
)
648 next
= fixp
->fx_next
;
649 fixp
->fx_next
= (fixS
*) 0;
651 switch (fixp
->fx_r_type
)
653 case BFD_RELOC_ALPHA_LITUSE
:
654 if (fixp
->tc_fix_data
.info
->n_master
== 0)
655 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
656 _("No !literal!%ld was found"),
657 fixp
->tc_fix_data
.info
->sequence
);
659 if (fixp
->fx_offset
== LITUSE_ALPHA_TLSGD
)
661 if (! fixp
->tc_fix_data
.info
->saw_tlsgd
)
662 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
663 _("No !tlsgd!%ld was found"),
664 fixp
->tc_fix_data
.info
->sequence
);
666 else if (fixp
->fx_offset
== LITUSE_ALPHA_TLSLDM
)
668 if (! fixp
->tc_fix_data
.info
->saw_tlsldm
)
669 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
670 _("No !tlsldm!%ld was found"),
671 fixp
->tc_fix_data
.info
->sequence
);
676 case BFD_RELOC_ALPHA_GPDISP_LO16
:
677 if (fixp
->tc_fix_data
.info
->n_master
== 0)
678 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
679 _("No ldah !gpdisp!%ld was found"),
680 fixp
->tc_fix_data
.info
->sequence
);
683 case BFD_RELOC_ALPHA_ELF_LITERAL
:
684 if (fixp
->tc_fix_data
.info
685 && (fixp
->tc_fix_data
.info
->saw_tlsgd
686 || fixp
->tc_fix_data
.info
->saw_tlsldm
))
692 prevP
= &fixp
->fx_next
;
697 /* Go back and re-chain dependent relocations. They are currently
698 linked through the next_reloc field in reverse order, so as we
699 go through the next_reloc chain, we effectively reverse the chain
702 Except if there is more than one !literal for a given sequence
703 number. In that case, the programmer and/or compiler is not sure
704 how control flows from literal to lituse, and we can't be sure to
705 get the relaxation correct.
707 ??? Well, actually we could, if there are enough lituses such that
708 we can make each literal have at least one of each lituse type
709 present. Not implemented.
711 Also suppress the optimization if the !literals/!lituses are spread
712 in different segments. This can happen with "intersting" uses of
713 inline assembly; examples are present in the Linux kernel semaphores. */
715 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= next
)
717 next
= fixp
->fx_next
;
718 switch (fixp
->fx_r_type
)
720 case BFD_RELOC_ALPHA_TLSGD
:
721 case BFD_RELOC_ALPHA_TLSLDM
:
722 if (!fixp
->tc_fix_data
.info
)
724 if (fixp
->tc_fix_data
.info
->n_master
== 0)
726 else if (fixp
->tc_fix_data
.info
->n_master
> 1)
728 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
729 _("too many !literal!%ld for %s"),
730 fixp
->tc_fix_data
.info
->sequence
,
731 (fixp
->fx_r_type
== BFD_RELOC_ALPHA_TLSGD
732 ? "!tlsgd" : "!tlsldm"));
736 fixp
->tc_fix_data
.info
->master
->fx_next
= fixp
->fx_next
;
737 fixp
->fx_next
= fixp
->tc_fix_data
.info
->master
;
738 fixp
= fixp
->fx_next
;
741 case BFD_RELOC_ALPHA_ELF_LITERAL
:
742 if (fixp
->tc_fix_data
.info
743 && fixp
->tc_fix_data
.info
->n_master
== 1
744 && ! fixp
->tc_fix_data
.info
->multi_section_p
)
746 for (slave
= fixp
->tc_fix_data
.info
->slaves
;
748 slave
= slave
->tc_fix_data
.next_reloc
)
750 slave
->fx_next
= fixp
->fx_next
;
751 fixp
->fx_next
= slave
;
756 case BFD_RELOC_ALPHA_GPDISP_HI16
:
757 if (fixp
->tc_fix_data
.info
->n_slaves
== 0)
758 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
759 _("No lda !gpdisp!%ld was found"),
760 fixp
->tc_fix_data
.info
->sequence
);
763 slave
= fixp
->tc_fix_data
.info
->slaves
;
764 slave
->fx_next
= next
;
765 fixp
->fx_next
= slave
;
775 /* Before the relocations are written, reorder them, so that user
776 supplied !lituse relocations follow the appropriate !literal
777 relocations, and similarly for !gpdisp relocations. */
780 alpha_before_fix (void)
782 if (alpha_literal_hash
)
783 bfd_map_over_sections (stdoutput
, alpha_adjust_relocs
, NULL
);
790 debug_exp (expressionS tok
[], int ntok
)
794 fprintf (stderr
, "debug_exp: %d tokens", ntok
);
795 for (i
= 0; i
< ntok
; i
++)
797 expressionS
*t
= &tok
[i
];
802 default: name
= "unknown"; break;
803 case O_illegal
: name
= "O_illegal"; break;
804 case O_absent
: name
= "O_absent"; break;
805 case O_constant
: name
= "O_constant"; break;
806 case O_symbol
: name
= "O_symbol"; break;
807 case O_symbol_rva
: name
= "O_symbol_rva"; break;
808 case O_register
: name
= "O_register"; break;
809 case O_big
: name
= "O_big"; break;
810 case O_uminus
: name
= "O_uminus"; break;
811 case O_bit_not
: name
= "O_bit_not"; break;
812 case O_logical_not
: name
= "O_logical_not"; break;
813 case O_multiply
: name
= "O_multiply"; break;
814 case O_divide
: name
= "O_divide"; break;
815 case O_modulus
: name
= "O_modulus"; break;
816 case O_left_shift
: name
= "O_left_shift"; break;
817 case O_right_shift
: name
= "O_right_shift"; break;
818 case O_bit_inclusive_or
: name
= "O_bit_inclusive_or"; break;
819 case O_bit_or_not
: name
= "O_bit_or_not"; break;
820 case O_bit_exclusive_or
: name
= "O_bit_exclusive_or"; break;
821 case O_bit_and
: name
= "O_bit_and"; break;
822 case O_add
: name
= "O_add"; break;
823 case O_subtract
: name
= "O_subtract"; break;
824 case O_eq
: name
= "O_eq"; break;
825 case O_ne
: name
= "O_ne"; break;
826 case O_lt
: name
= "O_lt"; break;
827 case O_le
: name
= "O_le"; break;
828 case O_ge
: name
= "O_ge"; break;
829 case O_gt
: name
= "O_gt"; break;
830 case O_logical_and
: name
= "O_logical_and"; break;
831 case O_logical_or
: name
= "O_logical_or"; break;
832 case O_index
: name
= "O_index"; break;
833 case O_pregister
: name
= "O_pregister"; break;
834 case O_cpregister
: name
= "O_cpregister"; break;
835 case O_literal
: name
= "O_literal"; break;
836 case O_lituse_addr
: name
= "O_lituse_addr"; break;
837 case O_lituse_base
: name
= "O_lituse_base"; break;
838 case O_lituse_bytoff
: name
= "O_lituse_bytoff"; break;
839 case O_lituse_jsr
: name
= "O_lituse_jsr"; break;
840 case O_lituse_tlsgd
: name
= "O_lituse_tlsgd"; break;
841 case O_lituse_tlsldm
: name
= "O_lituse_tlsldm"; break;
842 case O_lituse_jsrdirect
: name
= "O_lituse_jsrdirect"; break;
843 case O_gpdisp
: name
= "O_gpdisp"; break;
844 case O_gprelhigh
: name
= "O_gprelhigh"; break;
845 case O_gprellow
: name
= "O_gprellow"; break;
846 case O_gprel
: name
= "O_gprel"; break;
847 case O_samegp
: name
= "O_samegp"; break;
848 case O_tlsgd
: name
= "O_tlsgd"; break;
849 case O_tlsldm
: name
= "O_tlsldm"; break;
850 case O_gotdtprel
: name
= "O_gotdtprel"; break;
851 case O_dtprelhi
: name
= "O_dtprelhi"; break;
852 case O_dtprello
: name
= "O_dtprello"; break;
853 case O_dtprel
: name
= "O_dtprel"; break;
854 case O_gottprel
: name
= "O_gottprel"; break;
855 case O_tprelhi
: name
= "O_tprelhi"; break;
856 case O_tprello
: name
= "O_tprello"; break;
857 case O_tprel
: name
= "O_tprel"; break;
860 fprintf (stderr
, ", %s(%s, %s, %d)", name
,
861 (t
->X_add_symbol
) ? S_GET_NAME (t
->X_add_symbol
) : "--",
862 (t
->X_op_symbol
) ? S_GET_NAME (t
->X_op_symbol
) : "--",
863 (int) t
->X_add_number
);
865 fprintf (stderr
, "\n");
870 /* Parse the arguments to an opcode. */
873 tokenize_arguments (char *str
,
877 expressionS
*end_tok
= tok
+ ntok
;
878 char *old_input_line_pointer
;
879 int saw_comma
= 0, saw_arg
= 0;
881 expressionS
*orig_tok
= tok
;
885 const struct alpha_reloc_op_tag
*r
;
888 int reloc_found_p
= 0;
891 memset (tok
, 0, sizeof (*tok
) * ntok
);
893 /* Save and restore input_line_pointer around this function. */
894 old_input_line_pointer
= input_line_pointer
;
895 input_line_pointer
= str
;
898 /* ??? Wrest control of ! away from the regular expression parser. */
899 is_end_of_line
[(unsigned char) '!'] = 1;
902 while (tok
< end_tok
&& *input_line_pointer
)
905 switch (*input_line_pointer
)
912 /* A relocation operand can be placed after the normal operand on an
913 assembly language statement, and has the following form:
914 !relocation_type!sequence_number. */
917 /* Only support one relocation op per insn. */
918 as_bad (_("More than one relocation op per insn"));
925 ++input_line_pointer
;
927 p
= input_line_pointer
;
928 c
= get_symbol_end ();
930 /* Parse !relocation_type. */
931 len
= input_line_pointer
- p
;
934 as_bad (_("No relocation operand"));
938 r
= &alpha_reloc_op
[0];
939 for (i
= alpha_num_reloc_op
- 1; i
>= 0; i
--, r
++)
940 if (len
== r
->length
&& memcmp (p
, r
->name
, len
) == 0)
944 as_bad (_("Unknown relocation operand: !%s"), p
);
948 *input_line_pointer
= c
;
950 if (*input_line_pointer
!= '!')
954 as_bad (_("no sequence number after !%s"), p
);
958 tok
->X_add_number
= 0;
964 as_bad (_("!%s does not use a sequence number"), p
);
968 input_line_pointer
++;
970 /* Parse !sequence_number. */
972 if (tok
->X_op
!= O_constant
|| tok
->X_add_number
<= 0)
974 as_bad (_("Bad sequence number: !%s!%s"),
975 r
->name
, input_line_pointer
);
984 #endif /* RELOC_OP_P */
987 ++input_line_pointer
;
988 if (saw_comma
|| !saw_arg
)
995 char *hold
= input_line_pointer
++;
997 /* First try for parenthesized register ... */
999 if (*input_line_pointer
== ')' && tok
->X_op
== O_register
)
1001 tok
->X_op
= (saw_comma
? O_cpregister
: O_pregister
);
1004 ++input_line_pointer
;
1009 /* ... then fall through to plain expression. */
1010 input_line_pointer
= hold
;
1014 if (saw_arg
&& !saw_comma
)
1018 if (tok
->X_op
== O_illegal
|| tok
->X_op
== O_absent
)
1031 input_line_pointer
= old_input_line_pointer
;
1034 debug_exp (orig_tok
, ntok
- (end_tok
- tok
));
1037 is_end_of_line
[(unsigned char) '!'] = 0;
1040 return ntok
- (end_tok
- tok
);
1044 is_end_of_line
[(unsigned char) '!'] = 0;
1046 input_line_pointer
= old_input_line_pointer
;
1047 return TOKENIZE_ERROR
;
1051 is_end_of_line
[(unsigned char) '!'] = 0;
1053 input_line_pointer
= old_input_line_pointer
;
1054 return TOKENIZE_ERROR_REPORT
;
1057 /* Search forward through all variants of an opcode looking for a
1060 static const struct alpha_opcode
*
1061 find_opcode_match (const struct alpha_opcode
*first_opcode
,
1062 const expressionS
*tok
,
1066 const struct alpha_opcode
*opcode
= first_opcode
;
1068 int got_cpu_match
= 0;
1072 const unsigned char *opidx
;
1075 /* Don't match opcodes that don't exist on this architecture. */
1076 if (!(opcode
->flags
& alpha_target
))
1081 for (opidx
= opcode
->operands
; *opidx
; ++opidx
)
1083 const struct alpha_operand
*operand
= &alpha_operands
[*opidx
];
1085 /* Only take input from real operands. */
1086 if (operand
->flags
& AXP_OPERAND_FAKE
)
1089 /* When we expect input, make sure we have it. */
1092 if ((operand
->flags
& AXP_OPERAND_OPTIONAL_MASK
) == 0)
1097 /* Match operand type with expression type. */
1098 switch (operand
->flags
& AXP_OPERAND_TYPECHECK_MASK
)
1100 case AXP_OPERAND_IR
:
1101 if (tok
[tokidx
].X_op
!= O_register
1102 || !is_ir_num (tok
[tokidx
].X_add_number
))
1105 case AXP_OPERAND_FPR
:
1106 if (tok
[tokidx
].X_op
!= O_register
1107 || !is_fpr_num (tok
[tokidx
].X_add_number
))
1110 case AXP_OPERAND_IR
| AXP_OPERAND_PARENS
:
1111 if (tok
[tokidx
].X_op
!= O_pregister
1112 || !is_ir_num (tok
[tokidx
].X_add_number
))
1115 case AXP_OPERAND_IR
| AXP_OPERAND_PARENS
| AXP_OPERAND_COMMA
:
1116 if (tok
[tokidx
].X_op
!= O_cpregister
1117 || !is_ir_num (tok
[tokidx
].X_add_number
))
1121 case AXP_OPERAND_RELATIVE
:
1122 case AXP_OPERAND_SIGNED
:
1123 case AXP_OPERAND_UNSIGNED
:
1124 switch (tok
[tokidx
].X_op
)
1139 /* Everything else should have been fake. */
1145 /* Possible match -- did we use all of our input? */
1154 while (++opcode
- alpha_opcodes
< (int) alpha_num_opcodes
1155 && !strcmp (opcode
->name
, first_opcode
->name
));
1158 *pcpumatch
= got_cpu_match
;
1163 /* Given an opcode name and a pre-tokenized set of arguments, assemble
1164 the insn, but do not emit it.
1166 Note that this implies no macros allowed, since we can't store more
1167 than one insn in an insn structure. */
1170 assemble_tokens_to_insn (const char *opname
,
1171 const expressionS
*tok
,
1173 struct alpha_insn
*insn
)
1175 const struct alpha_opcode
*opcode
;
1177 /* Search opcodes. */
1178 opcode
= (const struct alpha_opcode
*) hash_find (alpha_opcode_hash
, opname
);
1182 opcode
= find_opcode_match (opcode
, tok
, &ntok
, &cpumatch
);
1185 assemble_insn (opcode
, tok
, ntok
, insn
, BFD_RELOC_UNUSED
);
1189 as_bad (_("inappropriate arguments for opcode `%s'"), opname
);
1191 as_bad (_("opcode `%s' not supported for target %s"), opname
,
1195 as_bad (_("unknown opcode `%s'"), opname
);
1198 /* Build a BFD section with its flags set appropriately for the .lita,
1199 .lit8, or .lit4 sections. */
1202 create_literal_section (const char *name
,
1206 segT current_section
= now_seg
;
1207 int current_subsec
= now_subseg
;
1210 *secp
= new_sec
= subseg_new (name
, 0);
1211 subseg_set (current_section
, current_subsec
);
1212 bfd_set_section_alignment (stdoutput
, new_sec
, 4);
1213 bfd_set_section_flags (stdoutput
, new_sec
,
1214 SEC_RELOC
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1217 S_CLEAR_EXTERNAL (*symp
= section_symbol (new_sec
));
1220 /* Load a (partial) expression into a target register.
1222 If poffset is not null, after the call it will either contain
1223 O_constant 0, or a 16-bit offset appropriate for any MEM format
1224 instruction. In addition, pbasereg will be modified to point to
1225 the base register to use in that MEM format instruction.
1227 In any case, *pbasereg should contain a base register to add to the
1228 expression. This will normally be either AXP_REG_ZERO or
1229 alpha_gp_register. Symbol addresses will always be loaded via $gp,
1230 so "foo($0)" is interpreted as adding the address of foo to $0;
1231 i.e. "ldq $targ, LIT($gp); addq $targ, $0, $targ". Odd, perhaps,
1232 but this is what OSF/1 does.
1234 If explicit relocations of the form !literal!<number> are allowed,
1235 and used, then explicit_reloc with be an expression pointer.
1237 Finally, the return value is nonzero if the calling macro may emit
1238 a LITUSE reloc if otherwise appropriate; the return value is the
1239 sequence number to use. */
1242 load_expression (int targreg
,
1243 const expressionS
*exp
,
1245 expressionS
*poffset
,
1248 long emit_lituse
= 0;
1249 offsetT addend
= exp
->X_add_number
;
1250 int basereg
= *pbasereg
;
1251 struct alpha_insn insn
;
1252 expressionS newtok
[3];
1261 /* Attempt to reduce .lit load by splitting the offset from
1262 its symbol when possible, but don't create a situation in
1264 if (!range_signed_32 (addend
) &&
1265 (alpha_noat_on
|| targreg
== AXP_REG_AT
))
1267 lit
= add_to_literal_pool (exp
->X_add_symbol
, addend
,
1268 alpha_lita_section
, 8);
1272 lit
= add_to_literal_pool (exp
->X_add_symbol
, 0,
1273 alpha_lita_section
, 8);
1276 as_fatal (_("overflow in literal (.lita) table"));
1278 /* Emit "ldq r, lit(gp)". */
1280 if (basereg
!= alpha_gp_register
&& targreg
== basereg
)
1283 as_bad (_("macro requires $at register while noat in effect"));
1284 if (targreg
== AXP_REG_AT
)
1285 as_bad (_("macro requires $at while $at in use"));
1287 set_tok_reg (newtok
[0], AXP_REG_AT
);
1290 set_tok_reg (newtok
[0], targreg
);
1292 set_tok_sym (newtok
[1], alpha_lita_symbol
, lit
);
1293 set_tok_preg (newtok
[2], alpha_gp_register
);
1295 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1297 gas_assert (insn
.nfixups
== 1);
1298 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_LITERAL
;
1299 insn
.sequence
= emit_lituse
= next_sequence_num
--;
1300 #endif /* OBJ_ECOFF */
1302 /* Emit "ldq r, gotoff(gp)". */
1304 if (basereg
!= alpha_gp_register
&& targreg
== basereg
)
1307 as_bad (_("macro requires $at register while noat in effect"));
1308 if (targreg
== AXP_REG_AT
)
1309 as_bad (_("macro requires $at while $at in use"));
1311 set_tok_reg (newtok
[0], AXP_REG_AT
);
1314 set_tok_reg (newtok
[0], targreg
);
1316 /* XXX: Disable this .got minimizing optimization so that we can get
1317 better instruction offset knowledge in the compiler. This happens
1318 very infrequently anyway. */
1320 || (!range_signed_32 (addend
)
1321 && (alpha_noat_on
|| targreg
== AXP_REG_AT
)))
1327 set_tok_sym (newtok
[1], exp
->X_add_symbol
, 0);
1329 set_tok_preg (newtok
[2], alpha_gp_register
);
1331 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1333 gas_assert (insn
.nfixups
== 1);
1334 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_ELF_LITERAL
;
1335 insn
.sequence
= emit_lituse
= next_sequence_num
--;
1336 #endif /* OBJ_ELF */
1338 /* Find symbol or symbol pointer in link section. */
1340 if (exp
->X_add_symbol
== alpha_evax_proc
->symbol
)
1342 /* Linkage-relative expression. */
1343 set_tok_reg (newtok
[0], targreg
);
1345 if (range_signed_16 (addend
))
1347 set_tok_const (newtok
[1], addend
);
1352 set_tok_const (newtok
[1], 0);
1354 set_tok_preg (newtok
[2], basereg
);
1355 assemble_tokens_to_insn ("lda", newtok
, 3, &insn
);
1359 const char *symname
= S_GET_NAME (exp
->X_add_symbol
);
1360 const char *ptr1
, *ptr2
;
1361 int symlen
= strlen (symname
);
1364 strcmp (ptr2
= &symname
[symlen
- 4], "..lk") == 0))
1366 /* Access to an item whose address is stored in the linkage
1367 section. Just read the address. */
1368 set_tok_reg (newtok
[0], targreg
);
1371 newtok
[1].X_op
= O_subtract
;
1372 newtok
[1].X_op_symbol
= alpha_evax_proc
->symbol
;
1374 set_tok_preg (newtok
[2], basereg
);
1375 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1376 alpha_linkage_symbol
= exp
->X_add_symbol
;
1379 set_tok_const (*poffset
, 0);
1381 if (alpha_flag_replace
&& targreg
== 26)
1383 /* Add a NOP fixup for 'ldX $26,YYY..NAME..lk'. */
1387 /* Build the entry name as 'NAME..en'. */
1388 ptr1
= strstr (symname
, "..") + 2;
1391 ensymname
= (char *) xmalloc (ptr2
- ptr1
+ 5);
1392 memcpy (ensymname
, ptr1
, ptr2
- ptr1
);
1393 memcpy (ensymname
+ (ptr2
- ptr1
), "..en", 5);
1395 gas_assert (insn
.nfixups
+ 1 <= MAX_INSN_FIXUPS
);
1396 insn
.fixups
[insn
.nfixups
].reloc
= BFD_RELOC_ALPHA_NOP
;
1397 ensym
= symbol_find_or_make (ensymname
);
1399 /* The fixup must be the same as the BFD_RELOC_ALPHA_BOH
1400 case in emit_jsrjmp. See B.4.5.2 of the OpenVMS Linker
1402 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_symbol
;
1403 insn
.fixups
[insn
.nfixups
].exp
.X_add_symbol
= ensym
;
1404 insn
.fixups
[insn
.nfixups
].exp
.X_add_number
= 0;
1405 insn
.fixups
[insn
.nfixups
].xtrasym
= alpha_linkage_symbol
;
1406 insn
.fixups
[insn
.nfixups
].procsym
= alpha_evax_proc
->symbol
;
1409 /* ??? Force bsym to be instantiated now, as it will be
1410 too late to do so in tc_gen_reloc. */
1411 symbol_get_bfdsym (exp
->X_add_symbol
);
1413 else if (alpha_flag_replace
&& targreg
== 27)
1415 /* Add a lda fixup for 'ldX $27,YYY.NAME..lk+8'. */
1420 ptr1
= strstr (symname
, "..") + 2;
1423 psymname
= (char *) xmalloc (ptr2
- ptr1
+ 1);
1424 memcpy (psymname
, ptr1
, ptr2
- ptr1
);
1425 psymname
[ptr2
- ptr1
] = 0;
1427 gas_assert (insn
.nfixups
+ 1 <= MAX_INSN_FIXUPS
);
1428 insn
.fixups
[insn
.nfixups
].reloc
= BFD_RELOC_ALPHA_LDA
;
1429 psym
= symbol_find_or_make (psymname
);
1431 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_subtract
;
1432 insn
.fixups
[insn
.nfixups
].exp
.X_add_symbol
= psym
;
1433 insn
.fixups
[insn
.nfixups
].exp
.X_op_symbol
= alpha_evax_proc
->symbol
;
1434 insn
.fixups
[insn
.nfixups
].exp
.X_add_number
= 0;
1435 insn
.fixups
[insn
.nfixups
].xtrasym
= alpha_linkage_symbol
;
1436 insn
.fixups
[insn
.nfixups
].procsym
= alpha_evax_proc
->symbol
;
1445 /* Not in the linkage section. Put the value into the linkage
1449 if (!range_signed_32 (addend
))
1450 addend
= sign_extend_32 (addend
);
1451 linkexp
= add_to_link_pool (exp
->X_add_symbol
, 0);
1452 set_tok_reg (newtok
[0], targreg
);
1453 set_tok_sym (newtok
[1], linkexp
, 0);
1454 set_tok_preg (newtok
[2], basereg
);
1455 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1458 #endif /* OBJ_EVAX */
1463 if (basereg
!= alpha_gp_register
&& basereg
!= AXP_REG_ZERO
)
1465 /* Emit "addq r, base, r". */
1467 set_tok_reg (newtok
[1], basereg
);
1468 set_tok_reg (newtok
[2], targreg
);
1469 assemble_tokens ("addq", newtok
, 3, 0);
1480 /* Assume that this difference expression will be resolved to an
1481 absolute value and that that value will fit in 16 bits. */
1483 set_tok_reg (newtok
[0], targreg
);
1485 set_tok_preg (newtok
[2], basereg
);
1486 assemble_tokens (opname
, newtok
, 3, 0);
1489 set_tok_const (*poffset
, 0);
1493 if (exp
->X_add_number
> 0)
1494 as_bad (_("bignum invalid; zero assumed"));
1496 as_bad (_("floating point number invalid; zero assumed"));
1501 as_bad (_("can't handle expression"));
1506 if (!range_signed_32 (addend
))
1512 long seq_num
= next_sequence_num
--;
1515 /* For 64-bit addends, just put it in the literal pool. */
1517 /* Emit "ldq targreg, lit(basereg)". */
1518 litexp
= add_to_link_pool (section_symbol (absolute_section
), addend
);
1519 set_tok_reg (newtok
[0], targreg
);
1520 set_tok_sym (newtok
[1], litexp
, 0);
1521 set_tok_preg (newtok
[2], alpha_gp_register
);
1522 assemble_tokens ("ldq", newtok
, 3, 0);
1525 if (alpha_lit8_section
== NULL
)
1527 create_literal_section (".lit8",
1528 &alpha_lit8_section
,
1529 &alpha_lit8_symbol
);
1532 alpha_lit8_literal
= add_to_literal_pool (alpha_lit8_symbol
, 0x8000,
1533 alpha_lita_section
, 8);
1534 if (alpha_lit8_literal
>= 0x8000)
1535 as_fatal (_("overflow in literal (.lita) table"));
1539 lit
= add_to_literal_pool (NULL
, addend
, alpha_lit8_section
, 8) - 0x8000;
1541 as_fatal (_("overflow in literal (.lit8) table"));
1543 /* Emit "lda litreg, .lit8+0x8000". */
1545 if (targreg
== basereg
)
1548 as_bad (_("macro requires $at register while noat in effect"));
1549 if (targreg
== AXP_REG_AT
)
1550 as_bad (_("macro requires $at while $at in use"));
1552 set_tok_reg (newtok
[0], AXP_REG_AT
);
1555 set_tok_reg (newtok
[0], targreg
);
1557 set_tok_sym (newtok
[1], alpha_lita_symbol
, alpha_lit8_literal
);
1560 set_tok_sym (newtok
[1], alpha_lit8_symbol
, 0x8000);
1562 set_tok_preg (newtok
[2], alpha_gp_register
);
1564 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1566 gas_assert (insn
.nfixups
== 1);
1568 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_LITERAL
;
1571 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_ELF_LITERAL
;
1573 insn
.sequence
= seq_num
;
1577 /* Emit "ldq litreg, lit(litreg)". */
1579 set_tok_const (newtok
[1], lit
);
1580 set_tok_preg (newtok
[2], newtok
[0].X_add_number
);
1582 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1584 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
1585 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
1586 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
1588 insn
.sequence
= seq_num
;
1593 /* Emit "addq litreg, base, target". */
1595 if (basereg
!= AXP_REG_ZERO
)
1597 set_tok_reg (newtok
[1], basereg
);
1598 set_tok_reg (newtok
[2], targreg
);
1599 assemble_tokens ("addq", newtok
, 3, 0);
1601 #endif /* !OBJ_EVAX */
1604 set_tok_const (*poffset
, 0);
1605 *pbasereg
= targreg
;
1609 offsetT low
, high
, extra
, tmp
;
1611 /* For 32-bit operands, break up the addend. */
1613 low
= sign_extend_16 (addend
);
1615 high
= sign_extend_16 (tmp
>> 16);
1617 if (tmp
- (high
<< 16))
1621 high
= sign_extend_16 (tmp
>> 16);
1626 set_tok_reg (newtok
[0], targreg
);
1627 set_tok_preg (newtok
[2], basereg
);
1631 /* Emit "ldah r, extra(r). */
1632 set_tok_const (newtok
[1], extra
);
1633 assemble_tokens ("ldah", newtok
, 3, 0);
1634 set_tok_preg (newtok
[2], basereg
= targreg
);
1639 /* Emit "ldah r, high(r). */
1640 set_tok_const (newtok
[1], high
);
1641 assemble_tokens ("ldah", newtok
, 3, 0);
1643 set_tok_preg (newtok
[2], basereg
);
1646 if ((low
&& !poffset
) || (!poffset
&& basereg
!= targreg
))
1648 /* Emit "lda r, low(base)". */
1649 set_tok_const (newtok
[1], low
);
1650 assemble_tokens ("lda", newtok
, 3, 0);
1656 set_tok_const (*poffset
, low
);
1657 *pbasereg
= basereg
;
1663 /* The lda macro differs from the lda instruction in that it handles
1664 most simple expressions, particularly symbol address loads and
1668 emit_lda (const expressionS
*tok
,
1670 const void * unused ATTRIBUTE_UNUSED
)
1675 basereg
= (tok
[1].X_op
== O_constant
? AXP_REG_ZERO
: alpha_gp_register
);
1677 basereg
= tok
[2].X_add_number
;
1679 (void) load_expression (tok
[0].X_add_number
, &tok
[1], &basereg
, NULL
, "lda");
1682 /* The ldah macro differs from the ldah instruction in that it has $31
1683 as an implied base register. */
1686 emit_ldah (const expressionS
*tok
,
1687 int ntok ATTRIBUTE_UNUSED
,
1688 const void * unused ATTRIBUTE_UNUSED
)
1690 expressionS newtok
[3];
1694 set_tok_preg (newtok
[2], AXP_REG_ZERO
);
1696 assemble_tokens ("ldah", newtok
, 3, 0);
1699 /* Called internally to handle all alignment needs. This takes care
1700 of eliding calls to frag_align if'n the cached current alignment
1701 says we've already got it, as well as taking care of the auto-align
1702 feature wrt labels. */
1708 int force ATTRIBUTE_UNUSED
)
1710 if (alpha_current_align
>= n
)
1715 if (subseg_text_p (now_seg
))
1716 frag_align_code (n
, 0);
1718 frag_align (n
, 0, 0);
1721 frag_align (n
, *pfill
, 0);
1723 alpha_current_align
= n
;
1725 if (label
!= NULL
&& S_GET_SEGMENT (label
) == now_seg
)
1727 symbol_set_frag (label
, frag_now
);
1728 S_SET_VALUE (label
, (valueT
) frag_now_fix ());
1731 record_alignment (now_seg
, n
);
1733 /* ??? If alpha_flag_relax && force && elf, record the requested alignment
1734 in a reloc for the linker to see. */
1737 /* Actually output an instruction with its fixup. */
1740 emit_insn (struct alpha_insn
*insn
)
1745 /* Take care of alignment duties. */
1746 if (alpha_auto_align_on
&& alpha_current_align
< 2)
1747 alpha_align (2, (char *) NULL
, alpha_insn_label
, 0);
1748 if (alpha_current_align
> 2)
1749 alpha_current_align
= 2;
1750 alpha_insn_label
= NULL
;
1752 /* Write out the instruction. */
1754 md_number_to_chars (f
, insn
->insn
, 4);
1757 dwarf2_emit_insn (4);
1760 /* Apply the fixups in order. */
1761 for (i
= 0; i
< insn
->nfixups
; ++i
)
1763 const struct alpha_operand
*operand
= (const struct alpha_operand
*) 0;
1764 struct alpha_fixup
*fixup
= &insn
->fixups
[i
];
1765 struct alpha_reloc_tag
*info
= NULL
;
1769 /* Some fixups are only used internally and so have no howto. */
1770 if ((int) fixup
->reloc
< 0)
1772 operand
= &alpha_operands
[-(int) fixup
->reloc
];
1774 pcrel
= ((operand
->flags
& AXP_OPERAND_RELATIVE
) != 0);
1776 else if (fixup
->reloc
> BFD_RELOC_UNUSED
1777 || fixup
->reloc
== BFD_RELOC_ALPHA_GPDISP_HI16
1778 || fixup
->reloc
== BFD_RELOC_ALPHA_GPDISP_LO16
)
1785 reloc_howto_type
*reloc_howto
=
1786 bfd_reloc_type_lookup (stdoutput
,
1787 (bfd_reloc_code_real_type
) fixup
->reloc
);
1788 gas_assert (reloc_howto
);
1790 size
= bfd_get_reloc_size (reloc_howto
);
1792 switch (fixup
->reloc
)
1795 case BFD_RELOC_ALPHA_NOP
:
1796 case BFD_RELOC_ALPHA_BSR
:
1797 case BFD_RELOC_ALPHA_LDA
:
1798 case BFD_RELOC_ALPHA_BOH
:
1802 gas_assert (size
>= 1 && size
<= 4);
1805 pcrel
= reloc_howto
->pc_relative
;
1808 fixP
= fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, size
,
1809 &fixup
->exp
, pcrel
, (bfd_reloc_code_real_type
) fixup
->reloc
);
1811 /* Turn off complaints that the addend is too large for some fixups,
1812 and copy in the sequence number for the explicit relocations. */
1813 switch (fixup
->reloc
)
1815 case BFD_RELOC_ALPHA_HINT
:
1816 case BFD_RELOC_GPREL32
:
1817 case BFD_RELOC_GPREL16
:
1818 case BFD_RELOC_ALPHA_GPREL_HI16
:
1819 case BFD_RELOC_ALPHA_GPREL_LO16
:
1820 case BFD_RELOC_ALPHA_GOTDTPREL16
:
1821 case BFD_RELOC_ALPHA_DTPREL_HI16
:
1822 case BFD_RELOC_ALPHA_DTPREL_LO16
:
1823 case BFD_RELOC_ALPHA_DTPREL16
:
1824 case BFD_RELOC_ALPHA_GOTTPREL16
:
1825 case BFD_RELOC_ALPHA_TPREL_HI16
:
1826 case BFD_RELOC_ALPHA_TPREL_LO16
:
1827 case BFD_RELOC_ALPHA_TPREL16
:
1828 fixP
->fx_no_overflow
= 1;
1831 case BFD_RELOC_ALPHA_GPDISP_HI16
:
1832 fixP
->fx_no_overflow
= 1;
1833 fixP
->fx_addsy
= section_symbol (now_seg
);
1834 fixP
->fx_offset
= 0;
1836 info
= get_alpha_reloc_tag (insn
->sequence
);
1837 if (++info
->n_master
> 1)
1838 as_bad (_("too many ldah insns for !gpdisp!%ld"), insn
->sequence
);
1839 if (info
->segment
!= now_seg
)
1840 as_bad (_("both insns for !gpdisp!%ld must be in the same section"),
1842 fixP
->tc_fix_data
.info
= info
;
1845 case BFD_RELOC_ALPHA_GPDISP_LO16
:
1846 fixP
->fx_no_overflow
= 1;
1848 info
= get_alpha_reloc_tag (insn
->sequence
);
1849 if (++info
->n_slaves
> 1)
1850 as_bad (_("too many lda insns for !gpdisp!%ld"), insn
->sequence
);
1851 if (info
->segment
!= now_seg
)
1852 as_bad (_("both insns for !gpdisp!%ld must be in the same section"),
1854 fixP
->tc_fix_data
.info
= info
;
1855 info
->slaves
= fixP
;
1858 case BFD_RELOC_ALPHA_LITERAL
:
1859 case BFD_RELOC_ALPHA_ELF_LITERAL
:
1860 fixP
->fx_no_overflow
= 1;
1862 if (insn
->sequence
== 0)
1864 info
= get_alpha_reloc_tag (insn
->sequence
);
1865 info
->master
= fixP
;
1867 if (info
->segment
!= now_seg
)
1868 info
->multi_section_p
= 1;
1869 fixP
->tc_fix_data
.info
= info
;
1873 case DUMMY_RELOC_LITUSE_ADDR
:
1874 fixP
->fx_offset
= LITUSE_ALPHA_ADDR
;
1876 case DUMMY_RELOC_LITUSE_BASE
:
1877 fixP
->fx_offset
= LITUSE_ALPHA_BASE
;
1879 case DUMMY_RELOC_LITUSE_BYTOFF
:
1880 fixP
->fx_offset
= LITUSE_ALPHA_BYTOFF
;
1882 case DUMMY_RELOC_LITUSE_JSR
:
1883 fixP
->fx_offset
= LITUSE_ALPHA_JSR
;
1885 case DUMMY_RELOC_LITUSE_TLSGD
:
1886 fixP
->fx_offset
= LITUSE_ALPHA_TLSGD
;
1888 case DUMMY_RELOC_LITUSE_TLSLDM
:
1889 fixP
->fx_offset
= LITUSE_ALPHA_TLSLDM
;
1891 case DUMMY_RELOC_LITUSE_JSRDIRECT
:
1892 fixP
->fx_offset
= LITUSE_ALPHA_JSRDIRECT
;
1895 fixP
->fx_addsy
= section_symbol (now_seg
);
1896 fixP
->fx_r_type
= BFD_RELOC_ALPHA_LITUSE
;
1898 info
= get_alpha_reloc_tag (insn
->sequence
);
1899 if (fixup
->reloc
== DUMMY_RELOC_LITUSE_TLSGD
)
1900 info
->saw_lu_tlsgd
= 1;
1901 else if (fixup
->reloc
== DUMMY_RELOC_LITUSE_TLSLDM
)
1902 info
->saw_lu_tlsldm
= 1;
1903 if (++info
->n_slaves
> 1)
1905 if (info
->saw_lu_tlsgd
)
1906 as_bad (_("too many lituse insns for !lituse_tlsgd!%ld"),
1908 else if (info
->saw_lu_tlsldm
)
1909 as_bad (_("too many lituse insns for !lituse_tlsldm!%ld"),
1912 fixP
->tc_fix_data
.info
= info
;
1913 fixP
->tc_fix_data
.next_reloc
= info
->slaves
;
1914 info
->slaves
= fixP
;
1915 if (info
->segment
!= now_seg
)
1916 info
->multi_section_p
= 1;
1919 case BFD_RELOC_ALPHA_TLSGD
:
1920 fixP
->fx_no_overflow
= 1;
1922 if (insn
->sequence
== 0)
1924 info
= get_alpha_reloc_tag (insn
->sequence
);
1925 if (info
->saw_tlsgd
)
1926 as_bad (_("duplicate !tlsgd!%ld"), insn
->sequence
);
1927 else if (info
->saw_tlsldm
)
1928 as_bad (_("sequence number in use for !tlsldm!%ld"),
1931 info
->saw_tlsgd
= 1;
1932 fixP
->tc_fix_data
.info
= info
;
1935 case BFD_RELOC_ALPHA_TLSLDM
:
1936 fixP
->fx_no_overflow
= 1;
1938 if (insn
->sequence
== 0)
1940 info
= get_alpha_reloc_tag (insn
->sequence
);
1941 if (info
->saw_tlsldm
)
1942 as_bad (_("duplicate !tlsldm!%ld"), insn
->sequence
);
1943 else if (info
->saw_tlsgd
)
1944 as_bad (_("sequence number in use for !tlsgd!%ld"),
1947 info
->saw_tlsldm
= 1;
1948 fixP
->tc_fix_data
.info
= info
;
1952 case BFD_RELOC_ALPHA_NOP
:
1953 case BFD_RELOC_ALPHA_LDA
:
1954 case BFD_RELOC_ALPHA_BSR
:
1955 case BFD_RELOC_ALPHA_BOH
:
1956 info
= get_alpha_reloc_tag (next_sequence_num
--);
1957 fixP
->tc_fix_data
.info
= info
;
1958 fixP
->tc_fix_data
.info
->sym
= fixup
->xtrasym
;
1959 fixP
->tc_fix_data
.info
->psym
= fixup
->procsym
;
1964 if ((int) fixup
->reloc
< 0)
1966 if (operand
->flags
& AXP_OPERAND_NOOVERFLOW
)
1967 fixP
->fx_no_overflow
= 1;
1974 /* Insert an operand value into an instruction. */
1977 insert_operand (unsigned insn
,
1978 const struct alpha_operand
*operand
,
1983 if (operand
->bits
!= 32 && !(operand
->flags
& AXP_OPERAND_NOOVERFLOW
))
1987 if (operand
->flags
& AXP_OPERAND_SIGNED
)
1989 max
= (1 << (operand
->bits
- 1)) - 1;
1990 min
= -(1 << (operand
->bits
- 1));
1994 max
= (1 << operand
->bits
) - 1;
1998 if (val
< min
|| val
> max
)
1999 as_warn_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
2002 if (operand
->insert
)
2004 const char *errmsg
= NULL
;
2006 insn
= (*operand
->insert
) (insn
, val
, &errmsg
);
2008 as_warn ("%s", errmsg
);
2011 insn
|= ((val
& ((1 << operand
->bits
) - 1)) << operand
->shift
);
2016 /* Turn an opcode description and a set of arguments into
2017 an instruction and a fixup. */
2020 assemble_insn (const struct alpha_opcode
*opcode
,
2021 const expressionS
*tok
,
2023 struct alpha_insn
*insn
,
2024 extended_bfd_reloc_code_real_type reloc
)
2026 const struct alpha_operand
*reloc_operand
= NULL
;
2027 const expressionS
*reloc_exp
= NULL
;
2028 const unsigned char *argidx
;
2032 memset (insn
, 0, sizeof (*insn
));
2033 image
= opcode
->opcode
;
2035 for (argidx
= opcode
->operands
; *argidx
; ++argidx
)
2037 const struct alpha_operand
*operand
= &alpha_operands
[*argidx
];
2038 const expressionS
*t
= (const expressionS
*) 0;
2040 if (operand
->flags
& AXP_OPERAND_FAKE
)
2042 /* Fake operands take no value and generate no fixup. */
2043 image
= insert_operand (image
, operand
, 0, NULL
, 0);
2049 switch (operand
->flags
& AXP_OPERAND_OPTIONAL_MASK
)
2051 case AXP_OPERAND_DEFAULT_FIRST
:
2054 case AXP_OPERAND_DEFAULT_SECOND
:
2057 case AXP_OPERAND_DEFAULT_ZERO
:
2059 static expressionS zero_exp
;
2061 zero_exp
.X_op
= O_constant
;
2062 zero_exp
.X_unsigned
= 1;
2077 image
= insert_operand (image
, operand
, regno (t
->X_add_number
),
2082 image
= insert_operand (image
, operand
, t
->X_add_number
, NULL
, 0);
2083 gas_assert (reloc_operand
== NULL
);
2084 reloc_operand
= operand
;
2089 /* This is only 0 for fields that should contain registers,
2090 which means this pattern shouldn't have matched. */
2091 if (operand
->default_reloc
== 0)
2094 /* There is one special case for which an insn receives two
2095 relocations, and thus the user-supplied reloc does not
2096 override the operand reloc. */
2097 if (operand
->default_reloc
== BFD_RELOC_ALPHA_HINT
)
2099 struct alpha_fixup
*fixup
;
2101 if (insn
->nfixups
>= MAX_INSN_FIXUPS
)
2102 as_fatal (_("too many fixups"));
2104 fixup
= &insn
->fixups
[insn
->nfixups
++];
2106 fixup
->reloc
= BFD_RELOC_ALPHA_HINT
;
2110 if (reloc
== BFD_RELOC_UNUSED
)
2111 reloc
= operand
->default_reloc
;
2113 gas_assert (reloc_operand
== NULL
);
2114 reloc_operand
= operand
;
2121 if (reloc
!= BFD_RELOC_UNUSED
)
2123 struct alpha_fixup
*fixup
;
2125 if (insn
->nfixups
>= MAX_INSN_FIXUPS
)
2126 as_fatal (_("too many fixups"));
2128 /* ??? My but this is hacky. But the OSF/1 assembler uses the same
2129 relocation tag for both ldah and lda with gpdisp. Choose the
2130 correct internal relocation based on the opcode. */
2131 if (reloc
== BFD_RELOC_ALPHA_GPDISP
)
2133 if (strcmp (opcode
->name
, "ldah") == 0)
2134 reloc
= BFD_RELOC_ALPHA_GPDISP_HI16
;
2135 else if (strcmp (opcode
->name
, "lda") == 0)
2136 reloc
= BFD_RELOC_ALPHA_GPDISP_LO16
;
2138 as_bad (_("invalid relocation for instruction"));
2141 /* If this is a real relocation (as opposed to a lituse hint), then
2142 the relocation width should match the operand width.
2143 Take care of -MDISP in operand table. */
2144 else if (reloc
< BFD_RELOC_UNUSED
&& reloc
> 0)
2146 reloc_howto_type
*reloc_howto
2147 = bfd_reloc_type_lookup (stdoutput
,
2148 (bfd_reloc_code_real_type
) reloc
);
2149 if (reloc_operand
== NULL
2150 || reloc_howto
->bitsize
!= reloc_operand
->bits
)
2152 as_bad (_("invalid relocation for field"));
2157 fixup
= &insn
->fixups
[insn
->nfixups
++];
2159 fixup
->exp
= *reloc_exp
;
2161 fixup
->exp
.X_op
= O_absent
;
2162 fixup
->reloc
= reloc
;
2168 /* Handle all "simple" integer register loads -- ldq, ldq_l, ldq_u,
2169 etc. They differ from the real instructions in that they do simple
2170 expressions like the lda macro. */
2173 emit_ir_load (const expressionS
*tok
,
2175 const void * opname
)
2179 expressionS newtok
[3];
2180 struct alpha_insn insn
;
2182 = tok
[1].X_add_symbol
? S_GET_NAME (tok
[1].X_add_symbol
): "";
2183 int symlen
= strlen (symname
);
2186 basereg
= (tok
[1].X_op
== O_constant
? AXP_REG_ZERO
: alpha_gp_register
);
2188 basereg
= tok
[2].X_add_number
;
2190 lituse
= load_expression (tok
[0].X_add_number
, &tok
[1],
2191 &basereg
, &newtok
[1], (const char *) opname
);
2193 if (basereg
== alpha_gp_register
&&
2194 (symlen
> 4 && strcmp (&symname
[symlen
- 4], "..lk") == 0))
2198 set_tok_preg (newtok
[2], basereg
);
2200 assemble_tokens_to_insn ((const char *) opname
, newtok
, 3, &insn
);
2204 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2205 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2206 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2208 insn
.sequence
= lituse
;
2214 /* Handle fp register loads, and both integer and fp register stores.
2215 Again, we handle simple expressions. */
2218 emit_loadstore (const expressionS
*tok
,
2220 const void * opname
)
2224 expressionS newtok
[3];
2225 struct alpha_insn insn
;
2228 basereg
= (tok
[1].X_op
== O_constant
? AXP_REG_ZERO
: alpha_gp_register
);
2230 basereg
= tok
[2].X_add_number
;
2232 if (tok
[1].X_op
!= O_constant
|| !range_signed_16 (tok
[1].X_add_number
))
2235 as_bad (_("macro requires $at register while noat in effect"));
2237 lituse
= load_expression (AXP_REG_AT
, &tok
[1],
2238 &basereg
, &newtok
[1], (const char *) opname
);
2247 set_tok_preg (newtok
[2], basereg
);
2249 assemble_tokens_to_insn ((const char *) opname
, newtok
, 3, &insn
);
2253 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2254 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2255 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2257 insn
.sequence
= lituse
;
2263 /* Load a half-word or byte as an unsigned value. */
2266 emit_ldXu (const expressionS
*tok
,
2268 const void * vlgsize
)
2270 if (alpha_target
& AXP_OPCODE_BWX
)
2271 emit_ir_load (tok
, ntok
, ldXu_op
[(long) vlgsize
]);
2274 expressionS newtok
[3];
2275 struct alpha_insn insn
;
2280 as_bad (_("macro requires $at register while noat in effect"));
2283 basereg
= (tok
[1].X_op
== O_constant
2284 ? AXP_REG_ZERO
: alpha_gp_register
);
2286 basereg
= tok
[2].X_add_number
;
2288 /* Emit "lda $at, exp". */
2289 lituse
= load_expression (AXP_REG_AT
, &tok
[1], &basereg
, NULL
, "lda");
2291 /* Emit "ldq_u targ, 0($at)". */
2293 set_tok_const (newtok
[1], 0);
2294 set_tok_preg (newtok
[2], basereg
);
2295 assemble_tokens_to_insn ("ldq_u", newtok
, 3, &insn
);
2299 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2300 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2301 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2303 insn
.sequence
= lituse
;
2308 /* Emit "extXl targ, $at, targ". */
2309 set_tok_reg (newtok
[1], basereg
);
2310 newtok
[2] = newtok
[0];
2311 assemble_tokens_to_insn (extXl_op
[(long) vlgsize
], newtok
, 3, &insn
);
2315 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2316 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BYTOFF
;
2317 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2319 insn
.sequence
= lituse
;
2326 /* Load a half-word or byte as a signed value. */
2329 emit_ldX (const expressionS
*tok
,
2331 const void * vlgsize
)
2333 emit_ldXu (tok
, ntok
, vlgsize
);
2334 assemble_tokens (sextX_op
[(long) vlgsize
], tok
, 1, 1);
2337 /* Load an integral value from an unaligned address as an unsigned
2341 emit_uldXu (const expressionS
*tok
,
2343 const void * vlgsize
)
2345 long lgsize
= (long) vlgsize
;
2346 expressionS newtok
[3];
2349 as_bad (_("macro requires $at register while noat in effect"));
2351 /* Emit "lda $at, exp". */
2352 memcpy (newtok
, tok
, sizeof (expressionS
) * ntok
);
2353 newtok
[0].X_add_number
= AXP_REG_AT
;
2354 assemble_tokens ("lda", newtok
, ntok
, 1);
2356 /* Emit "ldq_u $t9, 0($at)". */
2357 set_tok_reg (newtok
[0], AXP_REG_T9
);
2358 set_tok_const (newtok
[1], 0);
2359 set_tok_preg (newtok
[2], AXP_REG_AT
);
2360 assemble_tokens ("ldq_u", newtok
, 3, 1);
2362 /* Emit "ldq_u $t10, size-1($at)". */
2363 set_tok_reg (newtok
[0], AXP_REG_T10
);
2364 set_tok_const (newtok
[1], (1 << lgsize
) - 1);
2365 assemble_tokens ("ldq_u", newtok
, 3, 1);
2367 /* Emit "extXl $t9, $at, $t9". */
2368 set_tok_reg (newtok
[0], AXP_REG_T9
);
2369 set_tok_reg (newtok
[1], AXP_REG_AT
);
2370 set_tok_reg (newtok
[2], AXP_REG_T9
);
2371 assemble_tokens (extXl_op
[lgsize
], newtok
, 3, 1);
2373 /* Emit "extXh $t10, $at, $t10". */
2374 set_tok_reg (newtok
[0], AXP_REG_T10
);
2375 set_tok_reg (newtok
[2], AXP_REG_T10
);
2376 assemble_tokens (extXh_op
[lgsize
], newtok
, 3, 1);
2378 /* Emit "or $t9, $t10, targ". */
2379 set_tok_reg (newtok
[0], AXP_REG_T9
);
2380 set_tok_reg (newtok
[1], AXP_REG_T10
);
2382 assemble_tokens ("or", newtok
, 3, 1);
2385 /* Load an integral value from an unaligned address as a signed value.
2386 Note that quads should get funneled to the unsigned load since we
2387 don't have to do the sign extension. */
2390 emit_uldX (const expressionS
*tok
,
2392 const void * vlgsize
)
2394 emit_uldXu (tok
, ntok
, vlgsize
);
2395 assemble_tokens (sextX_op
[(long) vlgsize
], tok
, 1, 1);
2398 /* Implement the ldil macro. */
2401 emit_ldil (const expressionS
*tok
,
2403 const void * unused ATTRIBUTE_UNUSED
)
2405 expressionS newtok
[2];
2407 memcpy (newtok
, tok
, sizeof (newtok
));
2408 newtok
[1].X_add_number
= sign_extend_32 (tok
[1].X_add_number
);
2410 assemble_tokens ("lda", newtok
, ntok
, 1);
2413 /* Store a half-word or byte. */
2416 emit_stX (const expressionS
*tok
,
2418 const void * vlgsize
)
2420 int lgsize
= (int) (long) vlgsize
;
2422 if (alpha_target
& AXP_OPCODE_BWX
)
2423 emit_loadstore (tok
, ntok
, stX_op
[lgsize
]);
2426 expressionS newtok
[3];
2427 struct alpha_insn insn
;
2432 as_bad (_("macro requires $at register while noat in effect"));
2435 basereg
= (tok
[1].X_op
== O_constant
2436 ? AXP_REG_ZERO
: alpha_gp_register
);
2438 basereg
= tok
[2].X_add_number
;
2440 /* Emit "lda $at, exp". */
2441 lituse
= load_expression (AXP_REG_AT
, &tok
[1], &basereg
, NULL
, "lda");
2443 /* Emit "ldq_u $t9, 0($at)". */
2444 set_tok_reg (newtok
[0], AXP_REG_T9
);
2445 set_tok_const (newtok
[1], 0);
2446 set_tok_preg (newtok
[2], basereg
);
2447 assemble_tokens_to_insn ("ldq_u", newtok
, 3, &insn
);
2451 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2452 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2453 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2455 insn
.sequence
= lituse
;
2460 /* Emit "insXl src, $at, $t10". */
2462 set_tok_reg (newtok
[1], basereg
);
2463 set_tok_reg (newtok
[2], AXP_REG_T10
);
2464 assemble_tokens_to_insn (insXl_op
[lgsize
], newtok
, 3, &insn
);
2468 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2469 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BYTOFF
;
2470 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2472 insn
.sequence
= lituse
;
2477 /* Emit "mskXl $t9, $at, $t9". */
2478 set_tok_reg (newtok
[0], AXP_REG_T9
);
2479 newtok
[2] = newtok
[0];
2480 assemble_tokens_to_insn (mskXl_op
[lgsize
], newtok
, 3, &insn
);
2484 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2485 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BYTOFF
;
2486 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2488 insn
.sequence
= lituse
;
2493 /* Emit "or $t9, $t10, $t9". */
2494 set_tok_reg (newtok
[1], AXP_REG_T10
);
2495 assemble_tokens ("or", newtok
, 3, 1);
2497 /* Emit "stq_u $t9, 0($at). */
2498 set_tok_const(newtok
[1], 0);
2499 set_tok_preg (newtok
[2], AXP_REG_AT
);
2500 assemble_tokens_to_insn ("stq_u", newtok
, 3, &insn
);
2504 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2505 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2506 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2508 insn
.sequence
= lituse
;
2515 /* Store an integer to an unaligned address. */
2518 emit_ustX (const expressionS
*tok
,
2520 const void * vlgsize
)
2522 int lgsize
= (int) (long) vlgsize
;
2523 expressionS newtok
[3];
2525 /* Emit "lda $at, exp". */
2526 memcpy (newtok
, tok
, sizeof (expressionS
) * ntok
);
2527 newtok
[0].X_add_number
= AXP_REG_AT
;
2528 assemble_tokens ("lda", newtok
, ntok
, 1);
2530 /* Emit "ldq_u $9, 0($at)". */
2531 set_tok_reg (newtok
[0], AXP_REG_T9
);
2532 set_tok_const (newtok
[1], 0);
2533 set_tok_preg (newtok
[2], AXP_REG_AT
);
2534 assemble_tokens ("ldq_u", newtok
, 3, 1);
2536 /* Emit "ldq_u $10, size-1($at)". */
2537 set_tok_reg (newtok
[0], AXP_REG_T10
);
2538 set_tok_const (newtok
[1], (1 << lgsize
) - 1);
2539 assemble_tokens ("ldq_u", newtok
, 3, 1);
2541 /* Emit "insXl src, $at, $t11". */
2543 set_tok_reg (newtok
[1], AXP_REG_AT
);
2544 set_tok_reg (newtok
[2], AXP_REG_T11
);
2545 assemble_tokens (insXl_op
[lgsize
], newtok
, 3, 1);
2547 /* Emit "insXh src, $at, $t12". */
2548 set_tok_reg (newtok
[2], AXP_REG_T12
);
2549 assemble_tokens (insXh_op
[lgsize
], newtok
, 3, 1);
2551 /* Emit "mskXl $t9, $at, $t9". */
2552 set_tok_reg (newtok
[0], AXP_REG_T9
);
2553 newtok
[2] = newtok
[0];
2554 assemble_tokens (mskXl_op
[lgsize
], newtok
, 3, 1);
2556 /* Emit "mskXh $t10, $at, $t10". */
2557 set_tok_reg (newtok
[0], AXP_REG_T10
);
2558 newtok
[2] = newtok
[0];
2559 assemble_tokens (mskXh_op
[lgsize
], newtok
, 3, 1);
2561 /* Emit "or $t9, $t11, $t9". */
2562 set_tok_reg (newtok
[0], AXP_REG_T9
);
2563 set_tok_reg (newtok
[1], AXP_REG_T11
);
2564 newtok
[2] = newtok
[0];
2565 assemble_tokens ("or", newtok
, 3, 1);
2567 /* Emit "or $t10, $t12, $t10". */
2568 set_tok_reg (newtok
[0], AXP_REG_T10
);
2569 set_tok_reg (newtok
[1], AXP_REG_T12
);
2570 newtok
[2] = newtok
[0];
2571 assemble_tokens ("or", newtok
, 3, 1);
2573 /* Emit "stq_u $t10, size-1($at)". */
2574 set_tok_reg (newtok
[0], AXP_REG_T10
);
2575 set_tok_const (newtok
[1], (1 << lgsize
) - 1);
2576 set_tok_preg (newtok
[2], AXP_REG_AT
);
2577 assemble_tokens ("stq_u", newtok
, 3, 1);
2579 /* Emit "stq_u $t9, 0($at)". */
2580 set_tok_reg (newtok
[0], AXP_REG_T9
);
2581 set_tok_const (newtok
[1], 0);
2582 assemble_tokens ("stq_u", newtok
, 3, 1);
2585 /* Sign extend a half-word or byte. The 32-bit sign extend is
2586 implemented as "addl $31, $r, $t" in the opcode table. */
2589 emit_sextX (const expressionS
*tok
,
2591 const void * vlgsize
)
2593 long lgsize
= (long) vlgsize
;
2595 if (alpha_target
& AXP_OPCODE_BWX
)
2596 assemble_tokens (sextX_op
[lgsize
], tok
, ntok
, 0);
2599 int bitshift
= 64 - 8 * (1 << lgsize
);
2600 expressionS newtok
[3];
2602 /* Emit "sll src,bits,dst". */
2604 set_tok_const (newtok
[1], bitshift
);
2605 newtok
[2] = tok
[ntok
- 1];
2606 assemble_tokens ("sll", newtok
, 3, 1);
2608 /* Emit "sra dst,bits,dst". */
2609 newtok
[0] = newtok
[2];
2610 assemble_tokens ("sra", newtok
, 3, 1);
2614 /* Implement the division and modulus macros. */
2618 /* Make register usage like in normal procedure call.
2619 Don't clobber PV and RA. */
2622 emit_division (const expressionS
*tok
,
2624 const void * symname
)
2626 /* DIVISION and MODULUS. Yech.
2631 mov x,R16 # if x != R16
2632 mov y,R17 # if y != R17
2637 with appropriate optimizations if R0,R16,R17 are the registers
2638 specified by the compiler. */
2642 expressionS newtok
[3];
2644 xr
= regno (tok
[0].X_add_number
);
2645 yr
= regno (tok
[1].X_add_number
);
2650 rr
= regno (tok
[2].X_add_number
);
2652 /* Move the operands into the right place. */
2653 if (yr
== AXP_REG_R16
&& xr
== AXP_REG_R17
)
2655 /* They are in exactly the wrong order -- swap through AT. */
2657 as_bad (_("macro requires $at register while noat in effect"));
2659 set_tok_reg (newtok
[0], AXP_REG_R16
);
2660 set_tok_reg (newtok
[1], AXP_REG_AT
);
2661 assemble_tokens ("mov", newtok
, 2, 1);
2663 set_tok_reg (newtok
[0], AXP_REG_R17
);
2664 set_tok_reg (newtok
[1], AXP_REG_R16
);
2665 assemble_tokens ("mov", newtok
, 2, 1);
2667 set_tok_reg (newtok
[0], AXP_REG_AT
);
2668 set_tok_reg (newtok
[1], AXP_REG_R17
);
2669 assemble_tokens ("mov", newtok
, 2, 1);
2673 if (yr
== AXP_REG_R16
)
2675 set_tok_reg (newtok
[0], AXP_REG_R16
);
2676 set_tok_reg (newtok
[1], AXP_REG_R17
);
2677 assemble_tokens ("mov", newtok
, 2, 1);
2680 if (xr
!= AXP_REG_R16
)
2682 set_tok_reg (newtok
[0], xr
);
2683 set_tok_reg (newtok
[1], AXP_REG_R16
);
2684 assemble_tokens ("mov", newtok
, 2, 1);
2687 if (yr
!= AXP_REG_R16
&& yr
!= AXP_REG_R17
)
2689 set_tok_reg (newtok
[0], yr
);
2690 set_tok_reg (newtok
[1], AXP_REG_R17
);
2691 assemble_tokens ("mov", newtok
, 2, 1);
2695 sym
= symbol_find_or_make ((const char *) symname
);
2697 set_tok_reg (newtok
[0], AXP_REG_AT
);
2698 set_tok_sym (newtok
[1], sym
, 0);
2699 assemble_tokens ("lda", newtok
, 2, 1);
2701 /* Call the division routine. */
2702 set_tok_reg (newtok
[0], AXP_REG_AT
);
2703 set_tok_cpreg (newtok
[1], AXP_REG_AT
);
2704 set_tok_const (newtok
[2], 0);
2705 assemble_tokens ("jsr", newtok
, 3, 1);
2707 /* Move the result to the right place. */
2708 if (rr
!= AXP_REG_R0
)
2710 set_tok_reg (newtok
[0], AXP_REG_R0
);
2711 set_tok_reg (newtok
[1], rr
);
2712 assemble_tokens ("mov", newtok
, 2, 1);
2716 #else /* !OBJ_EVAX */
2719 emit_division (const expressionS
*tok
,
2721 const void * symname
)
2723 /* DIVISION and MODULUS. Yech.
2733 with appropriate optimizations if t10,t11,t12 are the registers
2734 specified by the compiler. */
2738 expressionS newtok
[3];
2740 xr
= regno (tok
[0].X_add_number
);
2741 yr
= regno (tok
[1].X_add_number
);
2746 rr
= regno (tok
[2].X_add_number
);
2748 sym
= symbol_find_or_make ((const char *) symname
);
2750 /* Move the operands into the right place. */
2751 if (yr
== AXP_REG_T10
&& xr
== AXP_REG_T11
)
2753 /* They are in exactly the wrong order -- swap through AT. */
2755 as_bad (_("macro requires $at register while noat in effect"));
2757 set_tok_reg (newtok
[0], AXP_REG_T10
);
2758 set_tok_reg (newtok
[1], AXP_REG_AT
);
2759 assemble_tokens ("mov", newtok
, 2, 1);
2761 set_tok_reg (newtok
[0], AXP_REG_T11
);
2762 set_tok_reg (newtok
[1], AXP_REG_T10
);
2763 assemble_tokens ("mov", newtok
, 2, 1);
2765 set_tok_reg (newtok
[0], AXP_REG_AT
);
2766 set_tok_reg (newtok
[1], AXP_REG_T11
);
2767 assemble_tokens ("mov", newtok
, 2, 1);
2771 if (yr
== AXP_REG_T10
)
2773 set_tok_reg (newtok
[0], AXP_REG_T10
);
2774 set_tok_reg (newtok
[1], AXP_REG_T11
);
2775 assemble_tokens ("mov", newtok
, 2, 1);
2778 if (xr
!= AXP_REG_T10
)
2780 set_tok_reg (newtok
[0], xr
);
2781 set_tok_reg (newtok
[1], AXP_REG_T10
);
2782 assemble_tokens ("mov", newtok
, 2, 1);
2785 if (yr
!= AXP_REG_T10
&& yr
!= AXP_REG_T11
)
2787 set_tok_reg (newtok
[0], yr
);
2788 set_tok_reg (newtok
[1], AXP_REG_T11
);
2789 assemble_tokens ("mov", newtok
, 2, 1);
2793 /* Call the division routine. */
2794 set_tok_reg (newtok
[0], AXP_REG_T9
);
2795 set_tok_sym (newtok
[1], sym
, 0);
2796 assemble_tokens ("jsr", newtok
, 2, 1);
2798 /* Reload the GP register. */
2802 #if defined(OBJ_ECOFF) || defined(OBJ_ELF)
2803 set_tok_reg (newtok
[0], alpha_gp_register
);
2804 set_tok_const (newtok
[1], 0);
2805 set_tok_preg (newtok
[2], AXP_REG_T9
);
2806 assemble_tokens ("ldgp", newtok
, 3, 1);
2809 /* Move the result to the right place. */
2810 if (rr
!= AXP_REG_T12
)
2812 set_tok_reg (newtok
[0], AXP_REG_T12
);
2813 set_tok_reg (newtok
[1], rr
);
2814 assemble_tokens ("mov", newtok
, 2, 1);
2818 #endif /* !OBJ_EVAX */
2820 /* The jsr and jmp macros differ from their instruction counterparts
2821 in that they can load the target address and default most
2825 emit_jsrjmp (const expressionS
*tok
,
2827 const void * vopname
)
2829 const char *opname
= (const char *) vopname
;
2830 struct alpha_insn insn
;
2831 expressionS newtok
[3];
2835 if (tokidx
< ntok
&& tok
[tokidx
].X_op
== O_register
)
2836 r
= regno (tok
[tokidx
++].X_add_number
);
2838 r
= strcmp (opname
, "jmp") == 0 ? AXP_REG_ZERO
: AXP_REG_RA
;
2840 set_tok_reg (newtok
[0], r
);
2842 if (tokidx
< ntok
&&
2843 (tok
[tokidx
].X_op
== O_pregister
|| tok
[tokidx
].X_op
== O_cpregister
))
2844 r
= regno (tok
[tokidx
++].X_add_number
);
2846 /* Keep register if jsr $n.<sym>. */
2850 int basereg
= alpha_gp_register
;
2851 lituse
= load_expression (r
= AXP_REG_PV
, &tok
[tokidx
],
2852 &basereg
, NULL
, opname
);
2856 set_tok_cpreg (newtok
[1], r
);
2860 newtok
[2] = tok
[tokidx
];
2863 set_tok_const (newtok
[2], 0);
2865 assemble_tokens_to_insn (opname
, newtok
, 3, &insn
);
2869 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2870 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_JSR
;
2871 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2873 insn
.sequence
= lituse
;
2877 if (alpha_flag_replace
2879 && tok
[tokidx
].X_add_symbol
2880 && alpha_linkage_symbol
)
2882 /* Create a BOH reloc for 'jsr $27,NAME'. */
2883 const char *symname
= S_GET_NAME (tok
[tokidx
].X_add_symbol
);
2884 int symlen
= strlen (symname
);
2887 /* Build the entry name as 'NAME..en'. */
2888 ensymname
= (char *) xmalloc (symlen
+ 5);
2889 memcpy (ensymname
, symname
, symlen
);
2890 memcpy (ensymname
+ symlen
, "..en", 5);
2892 gas_assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2893 if (insn
.nfixups
> 0)
2895 memmove (&insn
.fixups
[1], &insn
.fixups
[0],
2896 sizeof(struct alpha_fixup
) * insn
.nfixups
);
2899 /* The fixup must be the same as the BFD_RELOC_ALPHA_NOP
2900 case in load_expression. See B.4.5.2 of the OpenVMS
2901 Linker Utility Manual. */
2902 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_BOH
;
2903 insn
.fixups
[0].exp
.X_op
= O_symbol
;
2904 insn
.fixups
[0].exp
.X_add_symbol
= symbol_find_or_make (ensymname
);
2905 insn
.fixups
[0].exp
.X_add_number
= 0;
2906 insn
.fixups
[0].xtrasym
= alpha_linkage_symbol
;
2907 insn
.fixups
[0].procsym
= alpha_evax_proc
->symbol
;
2909 alpha_linkage_symbol
= 0;
2916 /* The ret and jcr instructions differ from their instruction
2917 counterparts in that everything can be defaulted. */
2920 emit_retjcr (const expressionS
*tok
,
2922 const void * vopname
)
2924 const char *opname
= (const char *) vopname
;
2925 expressionS newtok
[3];
2928 if (tokidx
< ntok
&& tok
[tokidx
].X_op
== O_register
)
2929 r
= regno (tok
[tokidx
++].X_add_number
);
2933 set_tok_reg (newtok
[0], r
);
2935 if (tokidx
< ntok
&&
2936 (tok
[tokidx
].X_op
== O_pregister
|| tok
[tokidx
].X_op
== O_cpregister
))
2937 r
= regno (tok
[tokidx
++].X_add_number
);
2941 set_tok_cpreg (newtok
[1], r
);
2944 newtok
[2] = tok
[tokidx
];
2946 set_tok_const (newtok
[2], strcmp (opname
, "ret") == 0);
2948 assemble_tokens (opname
, newtok
, 3, 0);
2951 /* Implement the ldgp macro. */
2954 emit_ldgp (const expressionS
*tok ATTRIBUTE_UNUSED
,
2955 int ntok ATTRIBUTE_UNUSED
,
2956 const void * unused ATTRIBUTE_UNUSED
)
2961 #if defined(OBJ_ECOFF) || defined(OBJ_ELF)
2962 /* from "ldgp r1,n(r2)", generate "ldah r1,X(R2); lda r1,Y(r1)"
2963 with appropriate constants and relocations. */
2964 struct alpha_insn insn
;
2965 expressionS newtok
[3];
2969 if (regno (tok
[2].X_add_number
) == AXP_REG_PV
)
2970 ecoff_set_gp_prolog_size (0);
2974 set_tok_const (newtok
[1], 0);
2977 assemble_tokens_to_insn ("ldah", newtok
, 3, &insn
);
2982 if (addend
.X_op
!= O_constant
)
2983 as_bad (_("can not resolve expression"));
2984 addend
.X_op
= O_symbol
;
2985 addend
.X_add_symbol
= alpha_gp_symbol
;
2989 insn
.fixups
[0].exp
= addend
;
2990 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_GPDISP_HI16
;
2991 insn
.sequence
= next_sequence_num
;
2995 set_tok_preg (newtok
[2], tok
[0].X_add_number
);
2997 assemble_tokens_to_insn ("lda", newtok
, 3, &insn
);
3000 addend
.X_add_number
+= 4;
3004 insn
.fixups
[0].exp
= addend
;
3005 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_GPDISP_LO16
;
3006 insn
.sequence
= next_sequence_num
--;
3009 #endif /* OBJ_ECOFF || OBJ_ELF */
3012 /* The macro table. */
3014 static const struct alpha_macro alpha_macros
[] =
3016 /* Load/Store macros. */
3017 { "lda", emit_lda
, NULL
,
3018 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3019 { "ldah", emit_ldah
, NULL
,
3020 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
} },
3022 { "ldl", emit_ir_load
, "ldl",
3023 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3024 { "ldl_l", emit_ir_load
, "ldl_l",
3025 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3026 { "ldq", emit_ir_load
, "ldq",
3027 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3028 { "ldq_l", emit_ir_load
, "ldq_l",
3029 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3030 { "ldq_u", emit_ir_load
, "ldq_u",
3031 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3032 { "ldf", emit_loadstore
, "ldf",
3033 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3034 { "ldg", emit_loadstore
, "ldg",
3035 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3036 { "lds", emit_loadstore
, "lds",
3037 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3038 { "ldt", emit_loadstore
, "ldt",
3039 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3041 { "ldb", emit_ldX
, (void *) 0,
3042 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3043 { "ldbu", emit_ldXu
, (void *) 0,
3044 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3045 { "ldw", emit_ldX
, (void *) 1,
3046 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3047 { "ldwu", emit_ldXu
, (void *) 1,
3048 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3050 { "uldw", emit_uldX
, (void *) 1,
3051 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3052 { "uldwu", emit_uldXu
, (void *) 1,
3053 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3054 { "uldl", emit_uldX
, (void *) 2,
3055 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3056 { "uldlu", emit_uldXu
, (void *) 2,
3057 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3058 { "uldq", emit_uldXu
, (void *) 3,
3059 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3061 { "ldgp", emit_ldgp
, NULL
,
3062 { MACRO_IR
, MACRO_EXP
, MACRO_PIR
, MACRO_EOA
} },
3064 { "ldi", emit_lda
, NULL
,
3065 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
} },
3066 { "ldil", emit_ldil
, NULL
,
3067 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
} },
3068 { "ldiq", emit_lda
, NULL
,
3069 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
} },
3071 { "stl", emit_loadstore
, "stl",
3072 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3073 { "stl_c", emit_loadstore
, "stl_c",
3074 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3075 { "stq", emit_loadstore
, "stq",
3076 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3077 { "stq_c", emit_loadstore
, "stq_c",
3078 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3079 { "stq_u", emit_loadstore
, "stq_u",
3080 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3081 { "stf", emit_loadstore
, "stf",
3082 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3083 { "stg", emit_loadstore
, "stg",
3084 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3085 { "sts", emit_loadstore
, "sts",
3086 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3087 { "stt", emit_loadstore
, "stt",
3088 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3090 { "stb", emit_stX
, (void *) 0,
3091 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3092 { "stw", emit_stX
, (void *) 1,
3093 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3094 { "ustw", emit_ustX
, (void *) 1,
3095 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3096 { "ustl", emit_ustX
, (void *) 2,
3097 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3098 { "ustq", emit_ustX
, (void *) 3,
3099 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3101 /* Arithmetic macros. */
3103 { "sextb", emit_sextX
, (void *) 0,
3104 { MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3105 MACRO_IR
, MACRO_EOA
,
3106 /* MACRO_EXP, MACRO_IR, MACRO_EOA */ } },
3107 { "sextw", emit_sextX
, (void *) 1,
3108 { MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3109 MACRO_IR
, MACRO_EOA
,
3110 /* MACRO_EXP, MACRO_IR, MACRO_EOA */ } },
3112 { "divl", emit_division
, "__divl",
3113 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3114 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3115 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3116 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3117 { "divlu", emit_division
, "__divlu",
3118 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3119 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3120 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3121 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3122 { "divq", emit_division
, "__divq",
3123 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3124 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3125 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3126 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3127 { "divqu", emit_division
, "__divqu",
3128 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3129 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3130 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3131 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3132 { "reml", emit_division
, "__reml",
3133 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3134 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3135 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3136 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3137 { "remlu", emit_division
, "__remlu",
3138 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3139 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3140 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3141 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3142 { "remq", emit_division
, "__remq",
3143 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3144 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3145 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3146 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3147 { "remqu", emit_division
, "__remqu",
3148 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3149 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3150 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3151 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3153 { "jsr", emit_jsrjmp
, "jsr",
3154 { MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3155 MACRO_PIR
, MACRO_EOA
,
3156 MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3157 MACRO_EXP
, MACRO_EOA
} },
3158 { "jmp", emit_jsrjmp
, "jmp",
3159 { MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3160 MACRO_PIR
, MACRO_EOA
,
3161 MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3162 MACRO_EXP
, MACRO_EOA
} },
3163 { "ret", emit_retjcr
, "ret",
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 { "jcr", 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
,
3177 { "jsr_coroutine", emit_retjcr
, "jcr",
3178 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3179 MACRO_IR
, MACRO_EOA
,
3180 MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3181 MACRO_PIR
, MACRO_EOA
,
3182 MACRO_EXP
, MACRO_EOA
,
3186 static const unsigned int alpha_num_macros
3187 = sizeof (alpha_macros
) / sizeof (*alpha_macros
);
3189 /* Search forward through all variants of a macro looking for a syntax
3192 static const struct alpha_macro
*
3193 find_macro_match (const struct alpha_macro
*first_macro
,
3194 const expressionS
*tok
,
3198 const struct alpha_macro
*macro
= first_macro
;
3203 const enum alpha_macro_arg
*arg
= macro
->argsets
;
3217 /* Index register. */
3219 if (tokidx
>= ntok
|| tok
[tokidx
].X_op
!= O_register
3220 || !is_ir_num (tok
[tokidx
].X_add_number
))
3225 /* Parenthesized index register. */
3227 if (tokidx
>= ntok
|| tok
[tokidx
].X_op
!= O_pregister
3228 || !is_ir_num (tok
[tokidx
].X_add_number
))
3233 /* Optional parenthesized index register. */
3235 if (tokidx
< ntok
&& tok
[tokidx
].X_op
== O_pregister
3236 && is_ir_num (tok
[tokidx
].X_add_number
))
3240 /* Leading comma with a parenthesized index register. */
3242 if (tokidx
>= ntok
|| tok
[tokidx
].X_op
!= O_cpregister
3243 || !is_ir_num (tok
[tokidx
].X_add_number
))
3248 /* Floating point register. */
3250 if (tokidx
>= ntok
|| tok
[tokidx
].X_op
!= O_register
3251 || !is_fpr_num (tok
[tokidx
].X_add_number
))
3256 /* Normal expression. */
3260 switch (tok
[tokidx
].X_op
)
3269 case O_lituse_bytoff
:
3285 while (*arg
!= MACRO_EOA
)
3293 while (++macro
- alpha_macros
< (int) alpha_num_macros
3294 && !strcmp (macro
->name
, first_macro
->name
));
3299 /* Given an opcode name and a pre-tokenized set of arguments, take the
3300 opcode all the way through emission. */
3303 assemble_tokens (const char *opname
,
3304 const expressionS
*tok
,
3306 int local_macros_on
)
3308 int found_something
= 0;
3309 const struct alpha_opcode
*opcode
;
3310 const struct alpha_macro
*macro
;
3312 extended_bfd_reloc_code_real_type reloc
= BFD_RELOC_UNUSED
;
3315 /* If a user-specified relocation is present, this is not a macro. */
3316 if (ntok
&& USER_RELOC_P (tok
[ntok
- 1].X_op
))
3318 reloc
= ALPHA_RELOC_TABLE (tok
[ntok
- 1].X_op
)->reloc
;
3323 if (local_macros_on
)
3325 macro
= ((const struct alpha_macro
*)
3326 hash_find (alpha_macro_hash
, opname
));
3329 found_something
= 1;
3330 macro
= find_macro_match (macro
, tok
, &ntok
);
3333 (*macro
->emit
) (tok
, ntok
, macro
->arg
);
3339 /* Search opcodes. */
3340 opcode
= (const struct alpha_opcode
*) hash_find (alpha_opcode_hash
, opname
);
3343 found_something
= 1;
3344 opcode
= find_opcode_match (opcode
, tok
, &ntok
, &cpumatch
);
3347 struct alpha_insn insn
;
3348 assemble_insn (opcode
, tok
, ntok
, &insn
, reloc
);
3350 /* Copy the sequence number for the reloc from the reloc token. */
3351 if (reloc
!= BFD_RELOC_UNUSED
)
3352 insn
.sequence
= tok
[ntok
].X_add_number
;
3359 if (found_something
)
3362 as_bad (_("inappropriate arguments for opcode `%s'"), opname
);
3364 as_bad (_("opcode `%s' not supported for target %s"), opname
,
3368 as_bad (_("unknown opcode `%s'"), opname
);
3373 /* Add sym+addend to link pool.
3374 Return offset from curent procedure value (pv) to entry in link pool.
3376 Add new fixup only if offset isn't 16bit. */
3379 add_to_link_pool (symbolS
*sym
, offsetT addend
)
3382 segT current_section
= now_seg
;
3383 int current_subsec
= now_subseg
;
3385 segment_info_type
*seginfo
= seg_info (alpha_link_section
);
3387 symbolS
*linksym
, *expsym
;
3390 basesym
= alpha_evax_proc
->symbol
;
3392 /* @@ This assumes all entries in a given section will be of the same
3393 size... Probably correct, but unwise to rely on. */
3394 /* This must always be called with the same subsegment. */
3396 if (seginfo
->frchainP
)
3397 for (fixp
= seginfo
->frchainP
->fix_root
;
3398 fixp
!= (fixS
*) NULL
;
3399 fixp
= fixp
->fx_next
)
3401 if (fixp
->fx_addsy
== sym
3402 && fixp
->fx_offset
== (valueT
)addend
3403 && fixp
->tc_fix_data
.info
3404 && fixp
->tc_fix_data
.info
->sym
3405 && fixp
->tc_fix_data
.info
->sym
->sy_value
.X_op_symbol
== basesym
)
3406 return fixp
->tc_fix_data
.info
->sym
;
3409 /* Not found, add a new entry. */
3410 subseg_set (alpha_link_section
, 0);
3411 linksym
= symbol_new
3412 (FAKE_LABEL_NAME
, now_seg
, (valueT
) frag_now_fix (), frag_now
);
3416 /* Create the basesym - linksym expression (offset of the added entry). */
3417 e
.X_op
= O_subtract
;
3418 e
.X_add_symbol
= linksym
;
3419 e
.X_op_symbol
= basesym
;
3421 expsym
= make_expr_symbol (&e
);
3424 (frag_now
, p
- frag_now
->fr_literal
, 8, sym
, addend
, 0, BFD_RELOC_64
);
3425 fixp
->tc_fix_data
.info
= get_alpha_reloc_tag (next_sequence_num
--);
3426 fixp
->tc_fix_data
.info
->sym
= expsym
;
3428 subseg_set (current_section
, current_subsec
);
3431 #endif /* OBJ_EVAX */
3433 /* Assembler directives. */
3435 /* Handle the .text pseudo-op. This is like the usual one, but it
3436 clears alpha_insn_label and restores auto alignment. */
3439 s_alpha_text (int i
)
3450 symbolP
= symbol_find (".text");
3451 if (symbolP
== NULL
)
3453 symbolP
= symbol_make (".text");
3454 S_SET_SEGMENT (symbolP
, text_section
);
3455 symbol_table_insert (symbolP
);
3459 alpha_insn_label
= NULL
;
3460 alpha_auto_align_on
= 1;
3461 alpha_current_align
= 0;
3464 /* Handle the .data pseudo-op. This is like the usual one, but it
3465 clears alpha_insn_label and restores auto alignment. */
3468 s_alpha_data (int i
)
3475 alpha_insn_label
= NULL
;
3476 alpha_auto_align_on
= 1;
3477 alpha_current_align
= 0;
3480 #if defined (OBJ_ECOFF) || defined (OBJ_EVAX)
3482 /* Handle the OSF/1 and openVMS .comm pseudo quirks. */
3485 s_alpha_comm (int ignore ATTRIBUTE_UNUSED
)
3497 name
= input_line_pointer
;
3498 c
= get_symbol_end ();
3500 /* Just after name is now '\0'. */
3501 p
= input_line_pointer
;
3506 /* Alpha OSF/1 compiler doesn't provide the comma, gcc does. */
3507 if (*input_line_pointer
== ',')
3509 input_line_pointer
++;
3512 if ((size
= get_absolute_expression ()) < 0)
3514 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
3515 ignore_rest_of_line ();
3520 symbolP
= symbol_find_or_make (name
);
3523 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
3525 as_bad (_("Ignoring attempt to re-define symbol"));
3526 ignore_rest_of_line ();
3531 if (*input_line_pointer
!= ',')
3532 temp
= 8; /* Default alignment. */
3535 input_line_pointer
++;
3537 temp
= get_absolute_expression ();
3540 /* ??? Unlike on OSF/1, the alignment factor is not in log units. */
3541 while ((temp
>>= 1) != 0)
3544 if (*input_line_pointer
== ',')
3546 /* Extended form of the directive
3548 .comm symbol, size, alignment, section
3550 where the "common" semantics is transferred to the section.
3551 The symbol is effectively an alias for the section name. */
3555 symbolS
*sec_symbol
;
3556 segT current_seg
= now_seg
;
3557 subsegT current_subseg
= now_subseg
;
3560 input_line_pointer
++;
3562 sec_name
= s_alpha_section_name ();
3563 sec_symbol
= symbol_find_or_make (sec_name
);
3564 sec
= subseg_new (sec_name
, 0);
3565 S_SET_SEGMENT (sec_symbol
, sec
);
3566 symbol_get_bfdsym (sec_symbol
)->flags
|= BSF_SECTION_SYM
;
3567 bfd_vms_set_section_flags (stdoutput
, sec
, 0,
3568 EGPS__V_OVR
| EGPS__V_GBL
| EGPS__V_NOMOD
);
3569 record_alignment (sec
, log_align
);
3571 /* Reuse stab_string_size to store the size of the section. */
3572 cur_size
= seg_info (sec
)->stabu
.stab_string_size
;
3573 if ((int) size
> cur_size
)
3576 = frag_var (rs_fill
, 1, 1, (relax_substateT
)0, NULL
,
3577 (valueT
)size
- (valueT
)cur_size
, NULL
);
3579 seg_info (sec
)->stabu
.stab_string_size
= (int)size
;
3582 S_SET_SEGMENT (symbolP
, sec
);
3584 subseg_set (current_seg
, current_subseg
);
3588 /* Regular form of the directive
3590 .comm symbol, size, alignment
3592 where the "common" semantics in on the symbol.
3593 These symbols are assembled in the .bss section. */
3596 segT current_seg
= now_seg
;
3597 subsegT current_subseg
= now_subseg
;
3599 subseg_set (bss_section
, 1);
3600 frag_align (log_align
, 0, 0);
3601 record_alignment (bss_section
, log_align
);
3603 symbolP
->sy_frag
= frag_now
;
3604 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
3608 S_SET_SEGMENT (symbolP
, bss_section
);
3610 subseg_set (current_seg
, current_subseg
);
3614 if (S_GET_VALUE (symbolP
))
3616 if (S_GET_VALUE (symbolP
) != (valueT
) size
)
3617 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
3618 S_GET_NAME (symbolP
),
3619 (long) S_GET_VALUE (symbolP
),
3625 S_SET_VALUE (symbolP
, (valueT
) size
);
3627 S_SET_EXTERNAL (symbolP
);
3631 know (symbolP
->sy_frag
== &zero_address_frag
);
3633 demand_empty_rest_of_line ();
3636 #endif /* ! OBJ_ELF */
3640 /* Handle the .rdata pseudo-op. This is like the usual one, but it
3641 clears alpha_insn_label and restores auto alignment. */
3644 s_alpha_rdata (int ignore ATTRIBUTE_UNUSED
)
3646 get_absolute_expression ();
3647 subseg_new (".rdata", 0);
3648 demand_empty_rest_of_line ();
3649 alpha_insn_label
= NULL
;
3650 alpha_auto_align_on
= 1;
3651 alpha_current_align
= 0;
3658 /* Handle the .sdata pseudo-op. This is like the usual one, but it
3659 clears alpha_insn_label and restores auto alignment. */
3662 s_alpha_sdata (int ignore ATTRIBUTE_UNUSED
)
3664 get_absolute_expression ();
3665 subseg_new (".sdata", 0);
3666 demand_empty_rest_of_line ();
3667 alpha_insn_label
= NULL
;
3668 alpha_auto_align_on
= 1;
3669 alpha_current_align
= 0;
3674 struct alpha_elf_frame_data
3677 symbolS
*func_end_sym
;
3678 symbolS
*prologue_sym
;
3684 offsetT mask_offset
;
3685 offsetT fmask_offset
;
3687 struct alpha_elf_frame_data
*next
;
3690 static struct alpha_elf_frame_data
*all_frame_data
;
3691 static struct alpha_elf_frame_data
**plast_frame_data
= &all_frame_data
;
3692 static struct alpha_elf_frame_data
*cur_frame_data
;
3694 /* Handle the .section pseudo-op. This is like the usual one, but it
3695 clears alpha_insn_label and restores auto alignment. */
3698 s_alpha_section (int ignore ATTRIBUTE_UNUSED
)
3700 obj_elf_section (ignore
);
3702 alpha_insn_label
= NULL
;
3703 alpha_auto_align_on
= 1;
3704 alpha_current_align
= 0;
3708 s_alpha_ent (int dummy ATTRIBUTE_UNUSED
)
3710 if (ECOFF_DEBUGGING
)
3711 ecoff_directive_ent (0);
3714 char *name
, name_end
;
3715 name
= input_line_pointer
;
3716 name_end
= get_symbol_end ();
3718 if (! is_name_beginner (*name
))
3720 as_warn (_(".ent directive has no name"));
3721 *input_line_pointer
= name_end
;
3728 as_warn (_("nested .ent directives"));
3730 sym
= symbol_find_or_make (name
);
3731 symbol_get_bfdsym (sym
)->flags
|= BSF_FUNCTION
;
3733 cur_frame_data
= (struct alpha_elf_frame_data
*)
3734 calloc (1, sizeof (*cur_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
;
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
;
3768 name
= input_line_pointer
;
3769 name_end
= get_symbol_end ();
3771 if (! is_name_beginner (*name
))
3773 as_warn (_(".end directive has no name"));
3774 *input_line_pointer
= name_end
;
3780 sym
= symbol_find (name
);
3781 if (!cur_frame_data
)
3782 as_warn (_(".end directive without matching .ent"));
3783 else if (sym
!= cur_frame_data
->func_sym
)
3784 as_warn (_(".end directive names different symbol than .ent"));
3786 /* Create an expression to calculate the size of the function. */
3787 if (sym
&& cur_frame_data
)
3789 OBJ_SYMFIELD_TYPE
*obj
= symbol_get_obj (sym
);
3790 expressionS
*exp
= (expressionS
*) xmalloc (sizeof (expressionS
));
3793 exp
->X_op
= O_subtract
;
3794 exp
->X_add_symbol
= symbol_temp_new_now ();
3795 exp
->X_op_symbol
= sym
;
3796 exp
->X_add_number
= 0;
3798 cur_frame_data
->func_end_sym
= exp
->X_add_symbol
;
3801 cur_frame_data
= NULL
;
3803 *input_line_pointer
= name_end
;
3805 demand_empty_rest_of_line ();
3810 s_alpha_mask (int fp
)
3812 if (ECOFF_DEBUGGING
)
3815 ecoff_directive_fmask (0);
3817 ecoff_directive_mask (0);
3824 if (!cur_frame_data
)
3827 as_warn (_(".fmask outside of .ent"));
3829 as_warn (_(".mask outside of .ent"));
3830 discard_rest_of_line ();
3834 if (get_absolute_expression_and_terminator (&val
) != ',')
3837 as_warn (_("bad .fmask directive"));
3839 as_warn (_("bad .mask directive"));
3840 --input_line_pointer
;
3841 discard_rest_of_line ();
3845 offset
= get_absolute_expression ();
3846 demand_empty_rest_of_line ();
3850 cur_frame_data
->fmask
= val
;
3851 cur_frame_data
->fmask_offset
= offset
;
3855 cur_frame_data
->mask
= val
;
3856 cur_frame_data
->mask_offset
= offset
;
3862 s_alpha_frame (int dummy ATTRIBUTE_UNUSED
)
3864 if (ECOFF_DEBUGGING
)
3865 ecoff_directive_frame (0);
3870 if (!cur_frame_data
)
3872 as_warn (_(".frame outside of .ent"));
3873 discard_rest_of_line ();
3877 cur_frame_data
->fp_regno
= tc_get_register (1);
3880 if (*input_line_pointer
++ != ','
3881 || get_absolute_expression_and_terminator (&val
) != ',')
3883 as_warn (_("bad .frame directive"));
3884 --input_line_pointer
;
3885 discard_rest_of_line ();
3888 cur_frame_data
->frame_size
= val
;
3890 cur_frame_data
->ra_regno
= tc_get_register (0);
3892 /* Next comes the "offset of saved $a0 from $sp". In gcc terms
3893 this is current_function_pretend_args_size. There's no place
3894 to put this value, so ignore it. */
3900 s_alpha_prologue (int ignore ATTRIBUTE_UNUSED
)
3905 arg
= get_absolute_expression ();
3906 demand_empty_rest_of_line ();
3907 alpha_prologue_label
= symbol_new
3908 (FAKE_LABEL_NAME
, now_seg
, (valueT
) frag_now_fix (), frag_now
);
3910 if (ECOFF_DEBUGGING
)
3911 sym
= ecoff_get_cur_proc_sym ();
3913 sym
= cur_frame_data
? cur_frame_data
->func_sym
: NULL
;
3917 as_bad (_(".prologue directive without a preceding .ent directive"));
3923 case 0: /* No PV required. */
3924 S_SET_OTHER (sym
, STO_ALPHA_NOPV
3925 | (S_GET_OTHER (sym
) & ~STO_ALPHA_STD_GPLOAD
));
3927 case 1: /* Std GP load. */
3928 S_SET_OTHER (sym
, STO_ALPHA_STD_GPLOAD
3929 | (S_GET_OTHER (sym
) & ~STO_ALPHA_STD_GPLOAD
));
3931 case 2: /* Non-std use of PV. */
3935 as_bad (_("Invalid argument %d to .prologue."), arg
);
3940 cur_frame_data
->prologue_sym
= symbol_temp_new_now ();
3943 static char *first_file_directive
;
3946 s_alpha_file (int ignore ATTRIBUTE_UNUSED
)
3948 /* Save the first .file directive we see, so that we can change our
3949 minds about whether ecoff debugging should or shouldn't be enabled. */
3950 if (alpha_flag_mdebug
< 0 && ! first_file_directive
)
3952 char *start
= input_line_pointer
;
3955 discard_rest_of_line ();
3957 len
= input_line_pointer
- start
;
3958 first_file_directive
= (char *) xmalloc (len
+ 1);
3959 memcpy (first_file_directive
, start
, len
);
3960 first_file_directive
[len
] = '\0';
3962 input_line_pointer
= start
;
3965 if (ECOFF_DEBUGGING
)
3966 ecoff_directive_file (0);
3968 dwarf2_directive_file (0);
3972 s_alpha_loc (int ignore ATTRIBUTE_UNUSED
)
3974 if (ECOFF_DEBUGGING
)
3975 ecoff_directive_loc (0);
3977 dwarf2_directive_loc (0);
3981 s_alpha_stab (int n
)
3983 /* If we've been undecided about mdebug, make up our minds in favour. */
3984 if (alpha_flag_mdebug
< 0)
3986 segT sec
= subseg_new (".mdebug", 0);
3987 bfd_set_section_flags (stdoutput
, sec
, SEC_HAS_CONTENTS
| SEC_READONLY
);
3988 bfd_set_section_alignment (stdoutput
, sec
, 3);
3990 ecoff_read_begin_hook ();
3992 if (first_file_directive
)
3994 char *save_ilp
= input_line_pointer
;
3995 input_line_pointer
= first_file_directive
;
3996 ecoff_directive_file (0);
3997 input_line_pointer
= save_ilp
;
3998 free (first_file_directive
);
4001 alpha_flag_mdebug
= 1;
4007 s_alpha_coff_wrapper (int which
)
4009 static void (* const fns
[]) (int) = {
4010 ecoff_directive_begin
,
4011 ecoff_directive_bend
,
4012 ecoff_directive_def
,
4013 ecoff_directive_dim
,
4014 ecoff_directive_endef
,
4015 ecoff_directive_scl
,
4016 ecoff_directive_tag
,
4017 ecoff_directive_val
,
4020 gas_assert (which
>= 0 && which
< (int) (sizeof (fns
)/sizeof (*fns
)));
4022 if (ECOFF_DEBUGGING
)
4026 as_bad (_("ECOFF debugging is disabled."));
4027 ignore_rest_of_line ();
4031 /* Called at the end of assembly. Here we emit unwind info for frames
4032 unless the compiler has done it for us. */
4035 alpha_elf_md_end (void)
4037 struct alpha_elf_frame_data
*p
;
4040 as_warn (_(".ent directive without matching .end"));
4042 /* If someone has generated the unwind info themselves, great. */
4043 if (bfd_get_section_by_name (stdoutput
, ".eh_frame") != NULL
)
4046 /* Generate .eh_frame data for the unwind directives specified. */
4047 for (p
= all_frame_data
; p
; p
= p
->next
)
4048 if (p
->prologue_sym
)
4050 /* Create a temporary symbol at the same location as our
4051 function symbol. This prevents problems with globals. */
4052 cfi_new_fde (symbol_temp_new (S_GET_SEGMENT (p
->func_sym
),
4053 S_GET_VALUE (p
->func_sym
),
4054 symbol_get_frag (p
->func_sym
)));
4056 cfi_set_return_column (p
->ra_regno
);
4057 cfi_add_CFA_def_cfa_register (30);
4058 if (p
->fp_regno
!= 30 || p
->mask
|| p
->fmask
|| p
->frame_size
)
4063 cfi_add_advance_loc (p
->prologue_sym
);
4065 if (p
->fp_regno
!= 30)
4066 if (p
->frame_size
!= 0)
4067 cfi_add_CFA_def_cfa (p
->fp_regno
, p
->frame_size
);
4069 cfi_add_CFA_def_cfa_register (p
->fp_regno
);
4070 else if (p
->frame_size
!= 0)
4071 cfi_add_CFA_def_cfa_offset (p
->frame_size
);
4074 offset
= p
->mask_offset
;
4076 /* Recall that $26 is special-cased and stored first. */
4077 if ((mask
>> 26) & 1)
4079 cfi_add_CFA_offset (26, offset
);
4090 cfi_add_CFA_offset (i
, offset
);
4095 offset
= p
->fmask_offset
;
4103 cfi_add_CFA_offset (i
+ 32, offset
);
4108 cfi_end_fde (p
->func_end_sym
);
4113 s_alpha_usepv (int unused ATTRIBUTE_UNUSED
)
4115 char *name
, name_end
;
4116 char *which
, which_end
;
4120 name
= input_line_pointer
;
4121 name_end
= get_symbol_end ();
4123 if (! is_name_beginner (*name
))
4125 as_bad (_(".usepv directive has no name"));
4126 *input_line_pointer
= name_end
;
4127 ignore_rest_of_line ();
4131 sym
= symbol_find_or_make (name
);
4132 *input_line_pointer
++ = name_end
;
4134 if (name_end
!= ',')
4136 as_bad (_(".usepv directive has no type"));
4137 ignore_rest_of_line ();
4142 which
= input_line_pointer
;
4143 which_end
= get_symbol_end ();
4145 if (strcmp (which
, "no") == 0)
4146 other
= STO_ALPHA_NOPV
;
4147 else if (strcmp (which
, "std") == 0)
4148 other
= STO_ALPHA_STD_GPLOAD
;
4151 as_bad (_("unknown argument for .usepv"));
4155 *input_line_pointer
= which_end
;
4156 demand_empty_rest_of_line ();
4158 S_SET_OTHER (sym
, other
| (S_GET_OTHER (sym
) & ~STO_ALPHA_STD_GPLOAD
));
4160 #endif /* OBJ_ELF */
4162 /* Standard calling conventions leaves the CFA at $30 on entry. */
4165 alpha_cfi_frame_initial_instructions (void)
4167 cfi_add_CFA_def_cfa_register (30);
4172 /* Get name of section. */
4174 s_alpha_section_name (void)
4179 if (*input_line_pointer
== '"')
4183 name
= demand_copy_C_string (&dummy
);
4186 ignore_rest_of_line ();
4192 char *end
= input_line_pointer
;
4194 while (0 == strchr ("\n\t,; ", *end
))
4196 if (end
== input_line_pointer
)
4198 as_warn (_("missing name"));
4199 ignore_rest_of_line ();
4203 name
= xmalloc (end
- input_line_pointer
+ 1);
4204 memcpy (name
, input_line_pointer
, end
- input_line_pointer
);
4205 name
[end
- input_line_pointer
] = '\0';
4206 input_line_pointer
= end
;
4212 /* Put clear/set flags in one flagword. The LSBs are flags to be set,
4213 the MSBs are the flags to be cleared. */
4215 #define EGPS__V_NO_SHIFT 16
4216 #define EGPS__V_MASK 0xffff
4218 /* Parse one VMS section flag. */
4221 s_alpha_section_word (char *str
, size_t len
)
4226 if (len
== 5 && strncmp (str
, "NO", 2) == 0)
4235 if (strncmp (str
, "PIC", 3) == 0)
4237 else if (strncmp (str
, "LIB", 3) == 0)
4239 else if (strncmp (str
, "OVR", 3) == 0)
4241 else if (strncmp (str
, "REL", 3) == 0)
4243 else if (strncmp (str
, "GBL", 3) == 0)
4245 else if (strncmp (str
, "SHR", 3) == 0)
4247 else if (strncmp (str
, "EXE", 3) == 0)
4249 else if (strncmp (str
, "WRT", 3) == 0)
4251 else if (strncmp (str
, "VEC", 3) == 0)
4253 else if (strncmp (str
, "MOD", 3) == 0)
4255 flag
= no
? EGPS__V_NOMOD
: EGPS__V_NOMOD
<< EGPS__V_NO_SHIFT
;
4258 else if (strncmp (str
, "COM", 3) == 0)
4266 as_warn (_("unknown section attribute %s"), str
);
4272 return flag
<< EGPS__V_NO_SHIFT
;
4277 /* Handle the section specific pseudo-op. */
4279 #define EVAX_SECTION_COUNT 5
4281 static char *section_name
[EVAX_SECTION_COUNT
+ 1] =
4282 { "NULL", ".rdata", ".comm", ".link", ".ctors", ".dtors" };
4285 s_alpha_section (int secid
)
4289 flagword vms_flags
= 0;
4294 name
= s_alpha_section_name ();
4297 sec
= subseg_new (name
, 0);
4298 if (*input_line_pointer
== ',')
4300 /* Skip the comma. */
4301 ++input_line_pointer
;
4309 beg
= input_line_pointer
;
4310 c
= get_symbol_end ();
4311 *input_line_pointer
= c
;
4313 vms_flags
|= s_alpha_section_word (beg
, input_line_pointer
- beg
);
4317 while (*input_line_pointer
++ == ',');
4318 --input_line_pointer
;
4321 symbol
= symbol_find_or_make (name
);
4322 S_SET_SEGMENT (symbol
, sec
);
4323 symbol_get_bfdsym (symbol
)->flags
|= BSF_SECTION_SYM
;
4324 bfd_vms_set_section_flags
4326 (vms_flags
>> EGPS__V_NO_SHIFT
) & EGPS__V_MASK
,
4327 vms_flags
& EGPS__V_MASK
);
4331 get_absolute_expression ();
4332 subseg_new (section_name
[secid
], 0);
4335 demand_empty_rest_of_line ();
4336 alpha_insn_label
= NULL
;
4337 alpha_auto_align_on
= 1;
4338 alpha_current_align
= 0;
4342 s_alpha_literals (int ignore ATTRIBUTE_UNUSED
)
4344 subseg_new (".literals", 0);
4345 demand_empty_rest_of_line ();
4346 alpha_insn_label
= NULL
;
4347 alpha_auto_align_on
= 1;
4348 alpha_current_align
= 0;
4351 /* Parse .ent directives. */
4354 s_alpha_ent (int ignore ATTRIBUTE_UNUSED
)
4357 expressionS symexpr
;
4360 = (struct alpha_evax_procs
*) xmalloc (sizeof (struct alpha_evax_procs
));
4362 alpha_evax_proc
->pdsckind
= 0;
4363 alpha_evax_proc
->framereg
= -1;
4364 alpha_evax_proc
->framesize
= 0;
4365 alpha_evax_proc
->rsa_offset
= 0;
4366 alpha_evax_proc
->ra_save
= AXP_REG_RA
;
4367 alpha_evax_proc
->fp_save
= -1;
4368 alpha_evax_proc
->imask
= 0;
4369 alpha_evax_proc
->fmask
= 0;
4370 alpha_evax_proc
->prologue
= 0;
4371 alpha_evax_proc
->type
= 0;
4372 alpha_evax_proc
->handler
= 0;
4373 alpha_evax_proc
->handler_data
= 0;
4375 expression (&symexpr
);
4377 if (symexpr
.X_op
!= O_symbol
)
4379 as_fatal (_(".ent directive has no symbol"));
4380 demand_empty_rest_of_line ();
4384 symbol
= make_expr_symbol (&symexpr
);
4385 symbol_get_bfdsym (symbol
)->flags
|= BSF_FUNCTION
;
4386 alpha_evax_proc
->symbol
= symbol
;
4389 (alpha_evax_proc_hash
,
4390 symbol_get_bfdsym (alpha_evax_proc
->symbol
)->name
, (PTR
)alpha_evax_proc
);
4392 demand_empty_rest_of_line ();
4396 s_alpha_handler (int is_data
)
4399 alpha_evax_proc
->handler_data
= get_absolute_expression ();
4402 char *name
, name_end
;
4403 name
= input_line_pointer
;
4404 name_end
= get_symbol_end ();
4406 if (! is_name_beginner (*name
))
4408 as_warn (_(".handler directive has no name"));
4409 *input_line_pointer
= name_end
;
4415 sym
= symbol_find_or_make (name
);
4416 symbol_get_bfdsym (sym
)->flags
|= BSF_FUNCTION
;
4417 alpha_evax_proc
->handler
= sym
;
4418 *input_line_pointer
= name_end
;
4421 demand_empty_rest_of_line ();
4424 /* Parse .frame <framreg>,<framesize>,RA,<rsa_offset> directives. */
4427 s_alpha_frame (int ignore ATTRIBUTE_UNUSED
)
4431 alpha_evax_proc
->framereg
= tc_get_register (1);
4434 if (*input_line_pointer
++ != ','
4435 || get_absolute_expression_and_terminator (&val
) != ',')
4437 as_warn (_("Bad .frame directive 1./2. param"));
4438 --input_line_pointer
;
4439 demand_empty_rest_of_line ();
4443 alpha_evax_proc
->framesize
= val
;
4445 (void) tc_get_register (1);
4447 if (*input_line_pointer
++ != ',')
4449 as_warn (_("Bad .frame directive 3./4. param"));
4450 --input_line_pointer
;
4451 demand_empty_rest_of_line ();
4454 alpha_evax_proc
->rsa_offset
= get_absolute_expression ();
4457 /* Parse .prologue. */
4460 s_alpha_prologue (int ignore ATTRIBUTE_UNUSED
)
4462 get_absolute_expression ();
4463 demand_empty_rest_of_line ();
4464 alpha_prologue_label
= symbol_new
4465 (FAKE_LABEL_NAME
, now_seg
, (valueT
) frag_now_fix (), frag_now
);
4468 /* Parse .pdesc <entry_name>.
4469 Insert a procedure descriptor. */
4472 s_alpha_pdesc (int ignore ATTRIBUTE_UNUSED
)
4480 segment_info_type
*seginfo
= seg_info (alpha_link_section
);
4481 const char *entry_sym_name
;
4485 if (now_seg
!= alpha_link_section
)
4487 as_bad (_(".pdesc directive not in link (.link) section"));
4488 demand_empty_rest_of_line ();
4493 if (exp
.X_op
!= O_symbol
)
4495 as_warn (_(".pdesc directive has no entry symbol"));
4496 demand_empty_rest_of_line ();
4500 entry_sym
= make_expr_symbol (&exp
);
4501 entry_sym_name
= symbol_get_bfdsym (entry_sym
)->name
;
4504 len
= strlen (entry_sym_name
);
4505 sym_name
= (char *) xmalloc (len
- 4 + 1);
4506 strncpy (sym_name
, entry_sym_name
, len
- 4);
4507 sym_name
[len
- 4] = 0;
4509 alpha_evax_proc
= (struct alpha_evax_procs
*)
4510 hash_find (alpha_evax_proc_hash
, sym_name
);
4512 if (!alpha_evax_proc
|| !S_IS_DEFINED (alpha_evax_proc
->symbol
))
4514 as_fatal (_(".pdesc has no matching .ent"));
4515 demand_empty_rest_of_line ();
4519 /* Define pdesc symbol. */
4520 define_sym_at_dot (alpha_evax_proc
->symbol
);
4522 /* Save bfd symbol of proc entry in function symbol. */
4523 ((struct evax_private_udata_struct
*)
4524 symbol_get_bfdsym (alpha_evax_proc
->symbol
)->udata
.p
)->enbsym
4525 = symbol_get_bfdsym (entry_sym
);
4528 if (*input_line_pointer
++ != ',')
4530 as_warn (_("No comma after .pdesc <entryname>"));
4531 demand_empty_rest_of_line ();
4536 name
= input_line_pointer
;
4537 name_end
= get_symbol_end ();
4539 if (strncmp (name
, "stack", 5) == 0)
4540 alpha_evax_proc
->pdsckind
= PDSC_S_K_KIND_FP_STACK
;
4542 else if (strncmp (name
, "reg", 3) == 0)
4543 alpha_evax_proc
->pdsckind
= PDSC_S_K_KIND_FP_REGISTER
;
4545 else if (strncmp (name
, "null", 4) == 0)
4546 alpha_evax_proc
->pdsckind
= PDSC_S_K_KIND_NULL
;
4550 as_fatal (_("unknown procedure kind"));
4551 demand_empty_rest_of_line ();
4555 *input_line_pointer
= name_end
;
4556 demand_empty_rest_of_line ();
4558 #ifdef md_flush_pending_output
4559 md_flush_pending_output ();
4562 frag_align (3, 0, 0);
4564 fixp
= fix_new (frag_now
, p
- frag_now
->fr_literal
, 8, 0, 0, 0, 0);
4567 *p
= alpha_evax_proc
->pdsckind
4568 | ((alpha_evax_proc
->framereg
== 29) ? PDSC_S_M_BASE_REG_IS_FP
: 0)
4569 | ((alpha_evax_proc
->handler
) ? PDSC_S_M_HANDLER_VALID
: 0)
4570 | ((alpha_evax_proc
->handler_data
) ? PDSC_S_M_HANDLER_DATA_VALID
: 0);
4571 *(p
+ 1) = PDSC_S_M_NATIVE
| PDSC_S_M_NO_JACKET
;
4573 switch (alpha_evax_proc
->pdsckind
)
4575 case PDSC_S_K_KIND_NULL
:
4579 case PDSC_S_K_KIND_FP_REGISTER
:
4580 *(p
+ 2) = alpha_evax_proc
->fp_save
;
4581 *(p
+ 3) = alpha_evax_proc
->ra_save
;
4583 case PDSC_S_K_KIND_FP_STACK
:
4584 md_number_to_chars (p
+ 2, (valueT
) alpha_evax_proc
->rsa_offset
, 2);
4586 default: /* impossible */
4591 *(p
+ 5) = alpha_evax_proc
->type
& 0x0f;
4593 /* Signature offset. */
4594 md_number_to_chars (p
+ 6, (valueT
) 0, 2);
4596 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+8, 8, &exp
, 0, BFD_RELOC_64
);
4598 if (alpha_evax_proc
->pdsckind
== PDSC_S_K_KIND_NULL
)
4601 /* Add dummy fix to make add_to_link_pool work. */
4603 fixp
= fix_new (frag_now
, p
- frag_now
->fr_literal
, 6, 0, 0, 0, 0);
4606 /* pdesc+16: Size. */
4607 md_number_to_chars (p
, (valueT
) alpha_evax_proc
->framesize
, 4);
4609 md_number_to_chars (p
+ 4, (valueT
) 0, 2);
4612 exp
.X_op
= O_subtract
;
4613 exp
.X_add_symbol
= alpha_prologue_label
;
4614 exp
.X_op_symbol
= entry_sym
;
4615 emit_expr (&exp
, 2);
4617 if (alpha_evax_proc
->pdsckind
== PDSC_S_K_KIND_FP_REGISTER
)
4620 /* Add dummy fix to make add_to_link_pool work. */
4622 fixp
= fix_new (frag_now
, p
- frag_now
->fr_literal
, 8, 0, 0, 0, 0);
4625 /* pdesc+24: register masks. */
4627 md_number_to_chars (p
, alpha_evax_proc
->imask
, 4);
4628 md_number_to_chars (p
+ 4, alpha_evax_proc
->fmask
, 4);
4630 if (alpha_evax_proc
->handler
)
4633 fixp
= fix_new (frag_now
, p
- frag_now
->fr_literal
, 8,
4634 alpha_evax_proc
->handler
, 0, 0, BFD_RELOC_64
);
4637 if (alpha_evax_proc
->handler_data
)
4639 /* Add dummy fix to make add_to_link_pool work. */
4641 fixp
= fix_new (frag_now
, p
- frag_now
->fr_literal
, 8, 0, 0, 0, 0);
4643 md_number_to_chars (p
, alpha_evax_proc
->handler_data
, 8);
4647 /* Support for crash debug on vms. */
4650 s_alpha_name (int ignore ATTRIBUTE_UNUSED
)
4654 segment_info_type
*seginfo
= seg_info (alpha_link_section
);
4656 if (now_seg
!= alpha_link_section
)
4658 as_bad (_(".name directive not in link (.link) section"));
4659 demand_empty_rest_of_line ();
4664 if (exp
.X_op
!= O_symbol
)
4666 as_warn (_(".name directive has no symbol"));
4667 demand_empty_rest_of_line ();
4671 demand_empty_rest_of_line ();
4673 #ifdef md_flush_pending_output
4674 md_flush_pending_output ();
4677 frag_align (3, 0, 0);
4680 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 8, &exp
, 0, BFD_RELOC_64
);
4683 /* Parse .linkage <symbol>.
4684 Create a linkage pair relocation. */
4687 s_alpha_linkage (int ignore ATTRIBUTE_UNUSED
)
4693 #ifdef md_flush_pending_output
4694 md_flush_pending_output ();
4698 if (exp
.X_op
!= O_symbol
)
4700 as_fatal (_("No symbol after .linkage"));
4704 struct alpha_linkage_fixups
*linkage_fixup
;
4706 p
= frag_more (LKP_S_K_SIZE
);
4707 memset (p
, 0, LKP_S_K_SIZE
);
4709 (frag_now
, p
- frag_now
->fr_literal
, LKP_S_K_SIZE
, &exp
, 0,\
4710 BFD_RELOC_ALPHA_LINKAGE
);
4712 linkage_fixup
= (struct alpha_linkage_fixups
*)
4713 xmalloc (sizeof (struct alpha_linkage_fixups
));
4715 linkage_fixup
->fixp
= fixp
;
4716 linkage_fixup
->next
= 0;
4718 if (alpha_insn_label
== 0)
4719 alpha_insn_label
= symbol_new
4720 (FAKE_LABEL_NAME
, now_seg
, (valueT
) frag_now_fix (), frag_now
);
4721 linkage_fixup
->label
= alpha_insn_label
;
4723 if (alpha_linkage_fixup_root
== 0)
4725 alpha_linkage_fixup_root
= alpha_linkage_fixup_tail
= linkage_fixup
;
4726 alpha_linkage_fixup_tail
->next
= 0;
4730 alpha_linkage_fixup_tail
->next
= linkage_fixup
;
4731 alpha_linkage_fixup_tail
= linkage_fixup
;
4732 alpha_linkage_fixup_tail
->next
= 0;
4735 demand_empty_rest_of_line ();
4738 /* Parse .code_address <symbol>.
4739 Create a code address relocation. */
4742 s_alpha_code_address (int ignore ATTRIBUTE_UNUSED
)
4747 #ifdef md_flush_pending_output
4748 md_flush_pending_output ();
4752 if (exp
.X_op
!= O_symbol
)
4753 as_fatal (_("No symbol after .code_address"));
4758 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 8, &exp
, 0,\
4759 BFD_RELOC_ALPHA_CODEADDR
);
4761 demand_empty_rest_of_line ();
4765 s_alpha_fp_save (int ignore ATTRIBUTE_UNUSED
)
4768 alpha_evax_proc
->fp_save
= tc_get_register (1);
4770 demand_empty_rest_of_line ();
4774 s_alpha_mask (int ignore ATTRIBUTE_UNUSED
)
4778 if (get_absolute_expression_and_terminator (&val
) != ',')
4780 as_warn (_("Bad .mask directive"));
4781 --input_line_pointer
;
4785 alpha_evax_proc
->imask
= val
;
4786 (void) get_absolute_expression ();
4788 demand_empty_rest_of_line ();
4792 s_alpha_fmask (int ignore ATTRIBUTE_UNUSED
)
4796 if (get_absolute_expression_and_terminator (&val
) != ',')
4798 as_warn (_("Bad .fmask directive"));
4799 --input_line_pointer
;
4803 alpha_evax_proc
->fmask
= val
;
4804 (void) get_absolute_expression ();
4806 demand_empty_rest_of_line ();
4810 s_alpha_end (int ignore ATTRIBUTE_UNUSED
)
4814 c
= get_symbol_end ();
4815 *input_line_pointer
= c
;
4816 demand_empty_rest_of_line ();
4817 alpha_evax_proc
= NULL
;
4821 s_alpha_file (int ignore ATTRIBUTE_UNUSED
)
4825 static char case_hack
[32];
4827 sprintf (case_hack
, "<CASE:%01d%01d>",
4828 alpha_flag_hash_long_names
, alpha_flag_show_after_trunc
);
4830 s
= symbol_find_or_make (case_hack
);
4831 symbol_get_bfdsym (s
)->flags
|= BSF_FILE
;
4833 get_absolute_expression ();
4834 s
= symbol_find_or_make (demand_copy_string (&length
));
4835 symbol_get_bfdsym (s
)->flags
|= BSF_FILE
;
4836 demand_empty_rest_of_line ();
4838 #endif /* OBJ_EVAX */
4840 /* Handle the .gprel32 pseudo op. */
4843 s_alpha_gprel32 (int ignore ATTRIBUTE_UNUSED
)
4855 e
.X_add_symbol
= section_symbol (absolute_section
);
4868 e
.X_add_symbol
= section_symbol (absolute_section
);
4871 e
.X_op
= O_subtract
;
4872 e
.X_op_symbol
= alpha_gp_symbol
;
4880 if (alpha_auto_align_on
&& alpha_current_align
< 2)
4881 alpha_align (2, (char *) NULL
, alpha_insn_label
, 0);
4882 if (alpha_current_align
> 2)
4883 alpha_current_align
= 2;
4884 alpha_insn_label
= NULL
;
4888 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 4,
4889 &e
, 0, BFD_RELOC_GPREL32
);
4892 /* Handle floating point allocation pseudo-ops. This is like the
4893 generic vresion, but it makes sure the current label, if any, is
4894 correctly aligned. */
4897 s_alpha_float_cons (int type
)
4923 if (alpha_auto_align_on
&& alpha_current_align
< log_size
)
4924 alpha_align (log_size
, (char *) NULL
, alpha_insn_label
, 0);
4925 if (alpha_current_align
> log_size
)
4926 alpha_current_align
= log_size
;
4927 alpha_insn_label
= NULL
;
4932 /* Handle the .proc pseudo op. We don't really do much with it except
4936 s_alpha_proc (int is_static ATTRIBUTE_UNUSED
)
4944 /* Takes ".proc name,nargs". */
4946 name
= input_line_pointer
;
4947 c
= get_symbol_end ();
4948 p
= input_line_pointer
;
4949 symbolP
= symbol_find_or_make (name
);
4952 if (*input_line_pointer
!= ',')
4955 as_warn (_("Expected comma after name \"%s\""), name
);
4958 ignore_rest_of_line ();
4962 input_line_pointer
++;
4963 temp
= get_absolute_expression ();
4965 /* *symbol_get_obj (symbolP) = (signed char) temp; */
4967 as_warn (_("unhandled: .proc %s,%d"), name
, temp
);
4968 demand_empty_rest_of_line ();
4971 /* Handle the .set pseudo op. This is used to turn on and off most of
4972 the assembler features. */
4975 s_alpha_set (int x ATTRIBUTE_UNUSED
)
4981 name
= input_line_pointer
;
4982 ch
= get_symbol_end ();
4985 if (s
[0] == 'n' && s
[1] == 'o')
4990 if (!strcmp ("reorder", s
))
4992 else if (!strcmp ("at", s
))
4993 alpha_noat_on
= !yesno
;
4994 else if (!strcmp ("macro", s
))
4995 alpha_macros_on
= yesno
;
4996 else if (!strcmp ("move", s
))
4998 else if (!strcmp ("volatile", s
))
5001 as_warn (_("Tried to .set unrecognized mode `%s'"), name
);
5003 *input_line_pointer
= ch
;
5004 demand_empty_rest_of_line ();
5007 /* Handle the .base pseudo op. This changes the assembler's notion of
5008 the $gp register. */
5011 s_alpha_base (int ignore ATTRIBUTE_UNUSED
)
5015 if (*input_line_pointer
== '$')
5018 input_line_pointer
++;
5019 if (*input_line_pointer
== 'r')
5020 input_line_pointer
++;
5023 alpha_gp_register
= get_absolute_expression ();
5024 if (alpha_gp_register
< 0 || alpha_gp_register
> 31)
5026 alpha_gp_register
= AXP_REG_GP
;
5027 as_warn (_("Bad base register, using $%d."), alpha_gp_register
);
5030 demand_empty_rest_of_line ();
5033 /* Handle the .align pseudo-op. This aligns to a power of two. It
5034 also adjusts any current instruction label. We treat this the same
5035 way the MIPS port does: .align 0 turns off auto alignment. */
5038 s_alpha_align (int ignore ATTRIBUTE_UNUSED
)
5042 long max_alignment
= 16;
5044 align
= get_absolute_expression ();
5045 if (align
> max_alignment
)
5047 align
= max_alignment
;
5048 as_bad (_("Alignment too large: %d. assumed"), align
);
5052 as_warn (_("Alignment negative: 0 assumed"));
5056 if (*input_line_pointer
== ',')
5058 input_line_pointer
++;
5059 fill
= get_absolute_expression ();
5067 alpha_auto_align_on
= 1;
5068 alpha_align (align
, pfill
, NULL
, 1);
5072 alpha_auto_align_on
= 0;
5074 alpha_insn_label
= NULL
;
5076 demand_empty_rest_of_line ();
5079 /* Hook the normal string processor to reset known alignment. */
5082 s_alpha_stringer (int terminate
)
5084 alpha_current_align
= 0;
5085 alpha_insn_label
= NULL
;
5086 stringer (8 + terminate
);
5089 /* Hook the normal space processing to reset known alignment. */
5092 s_alpha_space (int ignore
)
5094 alpha_current_align
= 0;
5095 alpha_insn_label
= NULL
;
5099 /* Hook into cons for auto-alignment. */
5102 alpha_cons_align (int size
)
5107 while ((size
>>= 1) != 0)
5110 if (alpha_auto_align_on
&& alpha_current_align
< log_size
)
5111 alpha_align (log_size
, (char *) NULL
, alpha_insn_label
, 0);
5112 if (alpha_current_align
> log_size
)
5113 alpha_current_align
= log_size
;
5114 alpha_insn_label
= NULL
;
5117 /* Here come the .uword, .ulong, and .uquad explicitly unaligned
5118 pseudos. We just turn off auto-alignment and call down to cons. */
5121 s_alpha_ucons (int bytes
)
5123 int hold
= alpha_auto_align_on
;
5124 alpha_auto_align_on
= 0;
5126 alpha_auto_align_on
= hold
;
5129 /* Switch the working cpu type. */
5132 s_alpha_arch (int ignored ATTRIBUTE_UNUSED
)
5135 const struct cpu_type
*p
;
5138 name
= input_line_pointer
;
5139 ch
= get_symbol_end ();
5141 for (p
= cpu_types
; p
->name
; ++p
)
5142 if (strcmp (name
, p
->name
) == 0)
5144 alpha_target_name
= p
->name
, alpha_target
= p
->flags
;
5147 as_warn (_("Unknown CPU identifier `%s'"), name
);
5150 *input_line_pointer
= ch
;
5151 demand_empty_rest_of_line ();
5155 /* print token expression with alpha specific extension. */
5158 alpha_print_token (FILE *f
, const expressionS
*exp
)
5168 expressionS nexp
= *exp
;
5169 nexp
.X_op
= O_register
;
5170 print_expr_1 (f
, &nexp
);
5175 print_expr_1 (f
, exp
);
5181 /* The target specific pseudo-ops which we support. */
5183 const pseudo_typeS md_pseudo_table
[] =
5186 {"comm", s_alpha_comm
, 0}, /* OSF1 compiler does this. */
5187 {"rdata", s_alpha_rdata
, 0},
5189 {"text", s_alpha_text
, 0},
5190 {"data", s_alpha_data
, 0},
5192 {"sdata", s_alpha_sdata
, 0},
5195 {"section", s_alpha_section
, 0},
5196 {"section.s", s_alpha_section
, 0},
5197 {"sect", s_alpha_section
, 0},
5198 {"sect.s", s_alpha_section
, 0},
5201 {"section", s_alpha_section
, 0},
5202 {"literals", s_alpha_literals
, 0},
5203 {"pdesc", s_alpha_pdesc
, 0},
5204 {"name", s_alpha_name
, 0},
5205 {"linkage", s_alpha_linkage
, 0},
5206 {"code_address", s_alpha_code_address
, 0},
5207 {"ent", s_alpha_ent
, 0},
5208 {"frame", s_alpha_frame
, 0},
5209 {"fp_save", s_alpha_fp_save
, 0},
5210 {"mask", s_alpha_mask
, 0},
5211 {"fmask", s_alpha_fmask
, 0},
5212 {"end", s_alpha_end
, 0},
5213 {"file", s_alpha_file
, 0},
5214 {"rdata", s_alpha_section
, 1},
5215 {"comm", s_alpha_comm
, 0},
5216 {"link", s_alpha_section
, 3},
5217 {"ctors", s_alpha_section
, 4},
5218 {"dtors", s_alpha_section
, 5},
5219 {"handler", s_alpha_handler
, 0},
5220 {"handler_data", s_alpha_handler
, 1},
5223 /* Frame related pseudos. */
5224 {"ent", s_alpha_ent
, 0},
5225 {"end", s_alpha_end
, 0},
5226 {"mask", s_alpha_mask
, 0},
5227 {"fmask", s_alpha_mask
, 1},
5228 {"frame", s_alpha_frame
, 0},
5229 {"prologue", s_alpha_prologue
, 0},
5230 {"file", s_alpha_file
, 5},
5231 {"loc", s_alpha_loc
, 9},
5232 {"stabs", s_alpha_stab
, 's'},
5233 {"stabn", s_alpha_stab
, 'n'},
5234 {"usepv", s_alpha_usepv
, 0},
5235 /* COFF debugging related pseudos. */
5236 {"begin", s_alpha_coff_wrapper
, 0},
5237 {"bend", s_alpha_coff_wrapper
, 1},
5238 {"def", s_alpha_coff_wrapper
, 2},
5239 {"dim", s_alpha_coff_wrapper
, 3},
5240 {"endef", s_alpha_coff_wrapper
, 4},
5241 {"scl", s_alpha_coff_wrapper
, 5},
5242 {"tag", s_alpha_coff_wrapper
, 6},
5243 {"val", s_alpha_coff_wrapper
, 7},
5246 {"prologue", s_alpha_prologue
, 0},
5248 {"prologue", s_ignore
, 0},
5251 {"gprel32", s_alpha_gprel32
, 0},
5252 {"t_floating", s_alpha_float_cons
, 'd'},
5253 {"s_floating", s_alpha_float_cons
, 'f'},
5254 {"f_floating", s_alpha_float_cons
, 'F'},
5255 {"g_floating", s_alpha_float_cons
, 'G'},
5256 {"d_floating", s_alpha_float_cons
, 'D'},
5258 {"proc", s_alpha_proc
, 0},
5259 {"aproc", s_alpha_proc
, 1},
5260 {"set", s_alpha_set
, 0},
5261 {"reguse", s_ignore
, 0},
5262 {"livereg", s_ignore
, 0},
5263 {"base", s_alpha_base
, 0}, /*??*/
5264 {"option", s_ignore
, 0},
5265 {"aent", s_ignore
, 0},
5266 {"ugen", s_ignore
, 0},
5267 {"eflag", s_ignore
, 0},
5269 {"align", s_alpha_align
, 0},
5270 {"double", s_alpha_float_cons
, 'd'},
5271 {"float", s_alpha_float_cons
, 'f'},
5272 {"single", s_alpha_float_cons
, 'f'},
5273 {"ascii", s_alpha_stringer
, 0},
5274 {"asciz", s_alpha_stringer
, 1},
5275 {"string", s_alpha_stringer
, 1},
5276 {"space", s_alpha_space
, 0},
5277 {"skip", s_alpha_space
, 0},
5278 {"zero", s_alpha_space
, 0},
5280 /* Unaligned data pseudos. */
5281 {"uword", s_alpha_ucons
, 2},
5282 {"ulong", s_alpha_ucons
, 4},
5283 {"uquad", s_alpha_ucons
, 8},
5286 /* Dwarf wants these versions of unaligned. */
5287 {"2byte", s_alpha_ucons
, 2},
5288 {"4byte", s_alpha_ucons
, 4},
5289 {"8byte", s_alpha_ucons
, 8},
5292 /* We don't do any optimizing, so we can safely ignore these. */
5293 {"noalias", s_ignore
, 0},
5294 {"alias", s_ignore
, 0},
5296 {"arch", s_alpha_arch
, 0},
5303 /* @@@ GP selection voodoo. All of this seems overly complicated and
5304 unnecessary; which is the primary reason it's for ECOFF only. */
5307 maybe_set_gp (asection
*sec
)
5313 vma
= bfd_get_section_vma (foo
, sec
);
5314 if (vma
&& vma
< alpha_gp_value
)
5315 alpha_gp_value
= vma
;
5319 select_gp_value (void)
5321 gas_assert (alpha_gp_value
== 0);
5323 /* Get minus-one in whatever width... */
5327 /* Select the smallest VMA of these existing sections. */
5328 maybe_set_gp (alpha_lita_section
);
5330 /* @@ Will a simple 0x8000 work here? If not, why not? */
5331 #define GP_ADJUSTMENT (0x8000 - 0x10)
5333 alpha_gp_value
+= GP_ADJUSTMENT
;
5335 S_SET_VALUE (alpha_gp_symbol
, alpha_gp_value
);
5338 printf (_("Chose GP value of %lx\n"), alpha_gp_value
);
5341 #endif /* OBJ_ECOFF */
5344 /* Map 's' to SHF_ALPHA_GPREL. */
5347 alpha_elf_section_letter (int letter
, char **ptr_msg
)
5350 return SHF_ALPHA_GPREL
;
5352 *ptr_msg
= _("bad .section directive: want a,s,w,x,M,S,G,T in string");
5356 /* Map SHF_ALPHA_GPREL to SEC_SMALL_DATA. */
5359 alpha_elf_section_flags (flagword flags
, bfd_vma attr
, int type ATTRIBUTE_UNUSED
)
5361 if (attr
& SHF_ALPHA_GPREL
)
5362 flags
|= SEC_SMALL_DATA
;
5365 #endif /* OBJ_ELF */
5367 /* This is called from HANDLE_ALIGN in write.c. Fill in the contents
5368 of an rs_align_code fragment. */
5371 alpha_handle_align (fragS
*fragp
)
5373 static char const unop
[4] = { 0x00, 0x00, 0xfe, 0x2f };
5374 static char const nopunop
[8] =
5376 0x1f, 0x04, 0xff, 0x47,
5377 0x00, 0x00, 0xfe, 0x2f
5383 if (fragp
->fr_type
!= rs_align_code
)
5386 bytes
= fragp
->fr_next
->fr_address
- fragp
->fr_address
- fragp
->fr_fix
;
5387 p
= fragp
->fr_literal
+ fragp
->fr_fix
;
5400 memcpy (p
, unop
, 4);
5406 memcpy (p
, nopunop
, 8);
5408 fragp
->fr_fix
+= fix
;
5412 /* Public interface functions. */
5414 /* This function is called once, at assembler startup time. It sets
5415 up all the tables, etc. that the MD part of the assembler will
5416 need, that can be determined before arguments are parsed. */
5423 /* Verify that X_op field is wide enough. */
5428 gas_assert (e
.X_op
== O_max
);
5431 /* Create the opcode hash table. */
5432 alpha_opcode_hash
= hash_new ();
5434 for (i
= 0; i
< alpha_num_opcodes
;)
5436 const char *name
, *retval
, *slash
;
5438 name
= alpha_opcodes
[i
].name
;
5439 retval
= hash_insert (alpha_opcode_hash
, name
, (void *) &alpha_opcodes
[i
]);
5441 as_fatal (_("internal error: can't hash opcode `%s': %s"),
5444 /* Some opcodes include modifiers of various sorts with a "/mod"
5445 syntax, like the architecture manual suggests. However, for
5446 use with gcc at least, we also need access to those same opcodes
5449 if ((slash
= strchr (name
, '/')) != NULL
)
5451 char *p
= (char *) xmalloc (strlen (name
));
5453 memcpy (p
, name
, slash
- name
);
5454 strcpy (p
+ (slash
- name
), slash
+ 1);
5456 (void) hash_insert (alpha_opcode_hash
, p
, (void *) &alpha_opcodes
[i
]);
5457 /* Ignore failures -- the opcode table does duplicate some
5458 variants in different forms, like "hw_stq" and "hw_st/q". */
5461 while (++i
< alpha_num_opcodes
5462 && (alpha_opcodes
[i
].name
== name
5463 || !strcmp (alpha_opcodes
[i
].name
, name
)))
5467 /* Create the macro hash table. */
5468 alpha_macro_hash
= hash_new ();
5470 for (i
= 0; i
< alpha_num_macros
;)
5472 const char *name
, *retval
;
5474 name
= alpha_macros
[i
].name
;
5475 retval
= hash_insert (alpha_macro_hash
, name
, (void *) &alpha_macros
[i
]);
5477 as_fatal (_("internal error: can't hash macro `%s': %s"),
5480 while (++i
< alpha_num_macros
5481 && (alpha_macros
[i
].name
== name
5482 || !strcmp (alpha_macros
[i
].name
, name
)))
5486 /* Construct symbols for each of the registers. */
5487 for (i
= 0; i
< 32; ++i
)
5491 sprintf (name
, "$%d", i
);
5492 alpha_register_table
[i
] = symbol_create (name
, reg_section
, i
,
5493 &zero_address_frag
);
5500 sprintf (name
, "$f%d", i
- 32);
5501 alpha_register_table
[i
] = symbol_create (name
, reg_section
, i
,
5502 &zero_address_frag
);
5505 /* Create the special symbols and sections we'll be using. */
5507 /* So .sbss will get used for tiny objects. */
5508 bfd_set_gp_size (stdoutput
, g_switch_value
);
5511 create_literal_section (".lita", &alpha_lita_section
, &alpha_lita_symbol
);
5513 /* For handling the GP, create a symbol that won't be output in the
5514 symbol table. We'll edit it out of relocs later. */
5515 alpha_gp_symbol
= symbol_create ("<GP value>", alpha_lita_section
, 0x8000,
5516 &zero_address_frag
);
5520 create_literal_section (".link", &alpha_link_section
, &alpha_link_symbol
);
5521 alpha_evax_proc_hash
= hash_new ();
5525 if (ECOFF_DEBUGGING
)
5527 segT sec
= subseg_new (".mdebug", (subsegT
) 0);
5528 bfd_set_section_flags (stdoutput
, sec
, SEC_HAS_CONTENTS
| SEC_READONLY
);
5529 bfd_set_section_alignment (stdoutput
, sec
, 3);
5533 /* Create literal lookup hash table. */
5534 alpha_literal_hash
= hash_new ();
5536 subseg_set (text_section
, 0);
5539 /* The public interface to the instruction assembler. */
5542 md_assemble (char *str
)
5544 /* Current maximum is 13. */
5546 expressionS tok
[MAX_INSN_ARGS
];
5550 /* Split off the opcode. */
5551 opnamelen
= strspn (str
, "abcdefghijklmnopqrstuvwxyz_/46819");
5552 trunclen
= (opnamelen
< sizeof (opname
) - 1
5554 : sizeof (opname
) - 1);
5555 memcpy (opname
, str
, trunclen
);
5556 opname
[trunclen
] = '\0';
5558 /* Tokenize the rest of the line. */
5559 if ((ntok
= tokenize_arguments (str
+ opnamelen
, tok
, MAX_INSN_ARGS
)) < 0)
5561 if (ntok
!= TOKENIZE_ERROR_REPORT
)
5562 as_bad (_("syntax error"));
5567 /* Finish it off. */
5568 assemble_tokens (opname
, tok
, ntok
, alpha_macros_on
);
5571 /* Round up a section's size to the appropriate boundary. */
5574 md_section_align (segT seg
, valueT size
)
5576 int align
= bfd_get_section_alignment (stdoutput
, seg
);
5577 valueT mask
= ((valueT
) 1 << align
) - 1;
5579 return (size
+ mask
) & ~mask
;
5582 /* Turn a string in input_line_pointer into a floating point constant
5583 of type TYPE, and store the appropriate bytes in *LITP. The number
5584 of LITTLENUMS emitted is stored in *SIZEP. An error message is
5585 returned, or NULL on OK. */
5588 md_atof (int type
, char *litP
, int *sizeP
)
5590 extern char *vax_md_atof (int, char *, int *);
5596 /* vax_md_atof() doesn't like "G" for some reason. */
5600 return vax_md_atof (type
, litP
, sizeP
);
5603 return ieee_md_atof (type
, litP
, sizeP
, FALSE
);
5607 /* Take care of the target-specific command-line options. */
5610 md_parse_option (int c
, char *arg
)
5615 alpha_nofloats_on
= 1;
5619 alpha_addr32_on
= 1;
5627 g_switch_value
= atoi (arg
);
5632 const struct cpu_type
*p
;
5634 for (p
= cpu_types
; p
->name
; ++p
)
5635 if (strcmp (arg
, p
->name
) == 0)
5637 alpha_target_name
= p
->name
, alpha_target
= p
->flags
;
5640 as_warn (_("Unknown CPU identifier `%s'"), arg
);
5646 case '+': /* For g++. Hash any name > 63 chars long. */
5647 alpha_flag_hash_long_names
= 1;
5650 case 'H': /* Show new symbol after hash truncation. */
5651 alpha_flag_show_after_trunc
= 1;
5654 case 'h': /* For gnu-c/vax compatibility. */
5657 case OPTION_REPLACE
:
5658 alpha_flag_replace
= 1;
5661 case OPTION_NOREPLACE
:
5662 alpha_flag_replace
= 0;
5667 alpha_flag_relax
= 1;
5672 alpha_flag_mdebug
= 1;
5674 case OPTION_NO_MDEBUG
:
5675 alpha_flag_mdebug
= 0;
5686 /* Print a description of the command-line options that we accept. */
5689 md_show_usage (FILE *stream
)
5693 -32addr treat addresses as 32-bit values\n\
5694 -F lack floating point instructions support\n\
5695 -mev4 | -mev45 | -mev5 | -mev56 | -mpca56 | -mev6 | -mev67 | -mev68 | -mall\n\
5696 specify variant of Alpha architecture\n\
5697 -m21064 | -m21066 | -m21164 | -m21164a | -m21164pc | -m21264 | -m21264a | -m21264b\n\
5698 these variants include PALcode opcodes\n"),
5703 -+ encode (don't truncate) names longer than 64 characters\n\
5704 -H show new symbol after hash truncation\n\
5705 -replace/-noreplace enable or disable the optimization of procedure calls\n"),
5710 /* Decide from what point a pc-relative relocation is relative to,
5711 relative to the pc-relative fixup. Er, relatively speaking. */
5714 md_pcrel_from (fixS
*fixP
)
5716 valueT addr
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
5718 switch (fixP
->fx_r_type
)
5720 case BFD_RELOC_23_PCREL_S2
:
5721 case BFD_RELOC_ALPHA_HINT
:
5722 case BFD_RELOC_ALPHA_BRSGP
:
5729 /* Attempt to simplify or even eliminate a fixup. The return value is
5730 ignored; perhaps it was once meaningful, but now it is historical.
5731 To indicate that a fixup has been eliminated, set fixP->fx_done.
5733 For ELF, here it is that we transform the GPDISP_HI16 reloc we used
5734 internally into the GPDISP reloc used externally. We had to do
5735 this so that we'd have the GPDISP_LO16 reloc as a tag to compute
5736 the distance to the "lda" instruction for setting the addend to
5740 md_apply_fix (fixS
*fixP
, valueT
* valP
, segT seg
)
5742 char * const fixpos
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5743 valueT value
= * valP
;
5744 unsigned image
, size
;
5746 switch (fixP
->fx_r_type
)
5748 /* The GPDISP relocations are processed internally with a symbol
5749 referring to the current function's section; we need to drop
5750 in a value which, when added to the address of the start of
5751 the function, gives the desired GP. */
5752 case BFD_RELOC_ALPHA_GPDISP_HI16
:
5754 fixS
*next
= fixP
->fx_next
;
5756 /* With user-specified !gpdisp relocations, we can be missing
5757 the matching LO16 reloc. We will have already issued an
5760 fixP
->fx_offset
= (next
->fx_frag
->fr_address
+ next
->fx_where
5761 - fixP
->fx_frag
->fr_address
- fixP
->fx_where
);
5763 value
= (value
- sign_extend_16 (value
)) >> 16;
5766 fixP
->fx_r_type
= BFD_RELOC_ALPHA_GPDISP
;
5770 case BFD_RELOC_ALPHA_GPDISP_LO16
:
5771 value
= sign_extend_16 (value
);
5772 fixP
->fx_offset
= 0;
5778 fixP
->fx_addsy
= section_symbol (seg
);
5779 md_number_to_chars (fixpos
, value
, 2);
5784 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
5790 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
5796 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
5800 if (fixP
->fx_pcrel
== 0 && fixP
->fx_addsy
== 0)
5802 md_number_to_chars (fixpos
, value
, size
);
5808 case BFD_RELOC_GPREL32
:
5809 gas_assert (fixP
->fx_subsy
== alpha_gp_symbol
);
5811 /* FIXME: inherited this obliviousness of `value' -- why? */
5812 md_number_to_chars (fixpos
, -alpha_gp_value
, 4);
5815 case BFD_RELOC_GPREL32
:
5817 case BFD_RELOC_GPREL16
:
5818 case BFD_RELOC_ALPHA_GPREL_HI16
:
5819 case BFD_RELOC_ALPHA_GPREL_LO16
:
5822 case BFD_RELOC_23_PCREL_S2
:
5823 if (fixP
->fx_pcrel
== 0 && fixP
->fx_addsy
== 0)
5825 image
= bfd_getl32 (fixpos
);
5826 image
= (image
& ~0x1FFFFF) | ((value
>> 2) & 0x1FFFFF);
5831 case BFD_RELOC_ALPHA_HINT
:
5832 if (fixP
->fx_pcrel
== 0 && fixP
->fx_addsy
== 0)
5834 image
= bfd_getl32 (fixpos
);
5835 image
= (image
& ~0x3FFF) | ((value
>> 2) & 0x3FFF);
5841 case BFD_RELOC_ALPHA_BRSGP
:
5844 case BFD_RELOC_ALPHA_TLSGD
:
5845 case BFD_RELOC_ALPHA_TLSLDM
:
5846 case BFD_RELOC_ALPHA_GOTDTPREL16
:
5847 case BFD_RELOC_ALPHA_DTPREL_HI16
:
5848 case BFD_RELOC_ALPHA_DTPREL_LO16
:
5849 case BFD_RELOC_ALPHA_DTPREL16
:
5850 case BFD_RELOC_ALPHA_GOTTPREL16
:
5851 case BFD_RELOC_ALPHA_TPREL_HI16
:
5852 case BFD_RELOC_ALPHA_TPREL_LO16
:
5853 case BFD_RELOC_ALPHA_TPREL16
:
5855 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
5860 case BFD_RELOC_ALPHA_LITERAL
:
5861 md_number_to_chars (fixpos
, value
, 2);
5864 case BFD_RELOC_ALPHA_ELF_LITERAL
:
5865 case BFD_RELOC_ALPHA_LITUSE
:
5866 case BFD_RELOC_ALPHA_LINKAGE
:
5867 case BFD_RELOC_ALPHA_CODEADDR
:
5871 case BFD_RELOC_ALPHA_NOP
:
5872 value
-= (8 + 4); /* PC-relative, base is jsr+4. */
5874 /* From B.4.5.2 of the OpenVMS Linker Utility Manual:
5875 "Finally, the ETIR$C_STC_BSR command passes the same address
5876 as ETIR$C_STC_NOP (so that they will fail or succeed together),
5877 and the same test is done again." */
5878 if (S_GET_SEGMENT (fixP
->fx_addsy
) == undefined_section
)
5880 fixP
->fx_addnumber
= -value
;
5884 if ((abs (value
) >> 2) & ~0xfffff)
5888 /* Change to a nop. */
5893 case BFD_RELOC_ALPHA_LDA
:
5894 /* fixup_segment sets fixP->fx_addsy to NULL when it can pre-compute
5895 the value for an O_subtract. */
5897 && S_GET_SEGMENT (fixP
->fx_addsy
) == undefined_section
)
5899 fixP
->fx_addnumber
= symbol_get_bfdsym (fixP
->fx_subsy
)->value
;
5903 if ((abs (value
)) & ~0x7fff)
5907 /* Change to an lda. */
5908 image
= 0x237B0000 | (value
& 0xFFFF);
5912 case BFD_RELOC_ALPHA_BSR
:
5913 case BFD_RELOC_ALPHA_BOH
:
5914 value
-= 4; /* PC-relative, base is jsr+4. */
5916 /* See comment in the BFD_RELOC_ALPHA_NOP case above. */
5917 if (S_GET_SEGMENT (fixP
->fx_addsy
) == undefined_section
)
5919 fixP
->fx_addnumber
= -value
;
5923 if ((abs (value
) >> 2) & ~0xfffff)
5926 if (fixP
->fx_r_type
== BFD_RELOC_ALPHA_BOH
)
5929 image
= bfd_getl32(fixpos
);
5930 image
= (image
& ~0x3FFF) | ((value
>> 2) & 0x3FFF);
5937 /* Change to a branch. */
5938 image
= 0xD3400000 | ((value
>> 2) & 0x1FFFFF);
5943 case BFD_RELOC_VTABLE_INHERIT
:
5944 case BFD_RELOC_VTABLE_ENTRY
:
5949 const struct alpha_operand
*operand
;
5951 if ((int) fixP
->fx_r_type
>= 0)
5952 as_fatal (_("unhandled relocation type %s"),
5953 bfd_get_reloc_code_name (fixP
->fx_r_type
));
5955 gas_assert (-(int) fixP
->fx_r_type
< (int) alpha_num_operands
);
5956 operand
= &alpha_operands
[-(int) fixP
->fx_r_type
];
5958 /* The rest of these fixups only exist internally during symbol
5959 resolution and have no representation in the object file.
5960 Therefore they must be completely resolved as constants. */
5962 if (fixP
->fx_addsy
!= 0
5963 && S_GET_SEGMENT (fixP
->fx_addsy
) != absolute_section
)
5964 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5965 _("non-absolute expression in constant field"));
5967 image
= bfd_getl32 (fixpos
);
5968 image
= insert_operand (image
, operand
, (offsetT
) value
,
5969 fixP
->fx_file
, fixP
->fx_line
);
5974 if (fixP
->fx_addsy
!= 0 || fixP
->fx_pcrel
!= 0)
5978 as_warn_where (fixP
->fx_file
, fixP
->fx_line
,
5979 _("type %d reloc done?\n"), (int) fixP
->fx_r_type
);
5984 md_number_to_chars (fixpos
, image
, 4);
5990 /* Look for a register name in the given symbol. */
5993 md_undefined_symbol (char *name
)
5997 int is_float
= 0, num
;
6002 if (name
[1] == 'p' && name
[2] == '\0')
6003 return alpha_register_table
[AXP_REG_FP
];
6008 if (!ISDIGIT (*++name
))
6012 case '0': case '1': case '2': case '3': case '4':
6013 case '5': case '6': case '7': case '8': case '9':
6014 if (name
[1] == '\0')
6015 num
= name
[0] - '0';
6016 else if (name
[0] != '0' && ISDIGIT (name
[1]) && name
[2] == '\0')
6018 num
= (name
[0] - '0') * 10 + name
[1] - '0';
6025 if (!alpha_noat_on
&& (num
+ is_float
) == AXP_REG_AT
)
6026 as_warn (_("Used $at without \".set noat\""));
6027 return alpha_register_table
[num
+ is_float
];
6030 if (name
[1] == 't' && name
[2] == '\0')
6033 as_warn (_("Used $at without \".set noat\""));
6034 return alpha_register_table
[AXP_REG_AT
];
6039 if (name
[1] == 'p' && name
[2] == '\0')
6040 return alpha_register_table
[alpha_gp_register
];
6044 if (name
[1] == 'p' && name
[2] == '\0')
6045 return alpha_register_table
[AXP_REG_SP
];
6053 /* @@@ Magic ECOFF bits. */
6056 alpha_frob_ecoff_data (void)
6059 /* $zero and $f31 are read-only. */
6060 alpha_gprmask
&= ~1;
6061 alpha_fprmask
&= ~1;
6065 /* Hook to remember a recently defined label so that the auto-align
6066 code can adjust the symbol after we know what alignment will be
6070 alpha_define_label (symbolS
*sym
)
6072 alpha_insn_label
= sym
;
6074 dwarf2_emit_label (sym
);
6078 /* Return true if we must always emit a reloc for a type and false if
6079 there is some hope of resolving it at assembly time. */
6082 alpha_force_relocation (fixS
*f
)
6084 if (alpha_flag_relax
)
6087 switch (f
->fx_r_type
)
6089 case BFD_RELOC_ALPHA_GPDISP_HI16
:
6090 case BFD_RELOC_ALPHA_GPDISP_LO16
:
6091 case BFD_RELOC_ALPHA_GPDISP
:
6092 case BFD_RELOC_ALPHA_LITERAL
:
6093 case BFD_RELOC_ALPHA_ELF_LITERAL
:
6094 case BFD_RELOC_ALPHA_LITUSE
:
6095 case BFD_RELOC_GPREL16
:
6096 case BFD_RELOC_GPREL32
:
6097 case BFD_RELOC_ALPHA_GPREL_HI16
:
6098 case BFD_RELOC_ALPHA_GPREL_LO16
:
6099 case BFD_RELOC_ALPHA_LINKAGE
:
6100 case BFD_RELOC_ALPHA_CODEADDR
:
6101 case BFD_RELOC_ALPHA_BRSGP
:
6102 case BFD_RELOC_ALPHA_TLSGD
:
6103 case BFD_RELOC_ALPHA_TLSLDM
:
6104 case BFD_RELOC_ALPHA_GOTDTPREL16
:
6105 case BFD_RELOC_ALPHA_DTPREL_HI16
:
6106 case BFD_RELOC_ALPHA_DTPREL_LO16
:
6107 case BFD_RELOC_ALPHA_DTPREL16
:
6108 case BFD_RELOC_ALPHA_GOTTPREL16
:
6109 case BFD_RELOC_ALPHA_TPREL_HI16
:
6110 case BFD_RELOC_ALPHA_TPREL_LO16
:
6111 case BFD_RELOC_ALPHA_TPREL16
:
6113 case BFD_RELOC_ALPHA_NOP
:
6114 case BFD_RELOC_ALPHA_BSR
:
6115 case BFD_RELOC_ALPHA_LDA
:
6116 case BFD_RELOC_ALPHA_BOH
:
6124 return generic_force_reloc (f
);
6127 /* Return true if we can partially resolve a relocation now. */
6130 alpha_fix_adjustable (fixS
*f
)
6132 /* Are there any relocation types for which we must generate a
6133 reloc but we can adjust the values contained within it? */
6134 switch (f
->fx_r_type
)
6136 case BFD_RELOC_ALPHA_GPDISP_HI16
:
6137 case BFD_RELOC_ALPHA_GPDISP_LO16
:
6138 case BFD_RELOC_ALPHA_GPDISP
:
6141 case BFD_RELOC_ALPHA_LITERAL
:
6142 case BFD_RELOC_ALPHA_ELF_LITERAL
:
6143 case BFD_RELOC_ALPHA_LITUSE
:
6144 case BFD_RELOC_ALPHA_LINKAGE
:
6145 case BFD_RELOC_ALPHA_CODEADDR
:
6148 case BFD_RELOC_VTABLE_ENTRY
:
6149 case BFD_RELOC_VTABLE_INHERIT
:
6152 case BFD_RELOC_GPREL16
:
6153 case BFD_RELOC_GPREL32
:
6154 case BFD_RELOC_ALPHA_GPREL_HI16
:
6155 case BFD_RELOC_ALPHA_GPREL_LO16
:
6156 case BFD_RELOC_23_PCREL_S2
:
6160 case BFD_RELOC_ALPHA_HINT
:
6163 case BFD_RELOC_ALPHA_TLSGD
:
6164 case BFD_RELOC_ALPHA_TLSLDM
:
6165 case BFD_RELOC_ALPHA_GOTDTPREL16
:
6166 case BFD_RELOC_ALPHA_DTPREL_HI16
:
6167 case BFD_RELOC_ALPHA_DTPREL_LO16
:
6168 case BFD_RELOC_ALPHA_DTPREL16
:
6169 case BFD_RELOC_ALPHA_GOTTPREL16
:
6170 case BFD_RELOC_ALPHA_TPREL_HI16
:
6171 case BFD_RELOC_ALPHA_TPREL_LO16
:
6172 case BFD_RELOC_ALPHA_TPREL16
:
6173 /* ??? No idea why we can't return a reference to .tbss+10, but
6174 we're preventing this in the other assemblers. Follow for now. */
6178 case BFD_RELOC_ALPHA_BRSGP
:
6179 /* If we have a BRSGP reloc to a local symbol, adjust it to BRADDR and
6180 let it get resolved at assembly time. */
6182 symbolS
*sym
= f
->fx_addsy
;
6186 if (generic_force_reloc (f
))
6189 switch (S_GET_OTHER (sym
) & STO_ALPHA_STD_GPLOAD
)
6191 case STO_ALPHA_NOPV
:
6193 case STO_ALPHA_STD_GPLOAD
:
6197 if (S_IS_LOCAL (sym
))
6200 name
= S_GET_NAME (sym
);
6201 as_bad_where (f
->fx_file
, f
->fx_line
,
6202 _("!samegp reloc against symbol without .prologue: %s"),
6206 f
->fx_r_type
= BFD_RELOC_23_PCREL_S2
;
6207 f
->fx_offset
+= offset
;
6212 case BFD_RELOC_ALPHA_NOP
:
6213 case BFD_RELOC_ALPHA_BSR
:
6214 case BFD_RELOC_ALPHA_LDA
:
6215 case BFD_RELOC_ALPHA_BOH
:
6224 /* Generate the BFD reloc to be stuck in the object file from the
6225 fixup used internally in the assembler. */
6228 tc_gen_reloc (asection
*sec ATTRIBUTE_UNUSED
,
6233 reloc
= (arelent
*) xmalloc (sizeof (* reloc
));
6234 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
6235 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
6236 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6238 /* Make sure none of our internal relocations make it this far.
6239 They'd better have been fully resolved by this point. */
6240 gas_assert ((int) fixp
->fx_r_type
> 0);
6242 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
6243 if (reloc
->howto
== NULL
)
6245 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
6246 _("cannot represent `%s' relocation in object file"),
6247 bfd_get_reloc_code_name (fixp
->fx_r_type
));
6251 if (!fixp
->fx_pcrel
!= !reloc
->howto
->pc_relative
)
6252 as_fatal (_("internal error? cannot generate `%s' relocation"),
6253 bfd_get_reloc_code_name (fixp
->fx_r_type
));
6255 gas_assert (!fixp
->fx_pcrel
== !reloc
->howto
->pc_relative
);
6257 reloc
->addend
= fixp
->fx_offset
;
6260 /* Fake out bfd_perform_relocation. sigh. */
6261 /* ??? Better would be to use the special_function hook. */
6262 if (fixp
->fx_r_type
== BFD_RELOC_ALPHA_LITERAL
)
6263 reloc
->addend
= -alpha_gp_value
;
6267 switch (fixp
->fx_r_type
)
6269 struct evax_private_udata_struct
*udata
;
6273 case BFD_RELOC_ALPHA_LINKAGE
:
6274 /* Copy the linkage index. */
6275 reloc
->addend
= fixp
->fx_addnumber
;
6278 case BFD_RELOC_ALPHA_NOP
:
6279 case BFD_RELOC_ALPHA_BSR
:
6280 case BFD_RELOC_ALPHA_LDA
:
6281 case BFD_RELOC_ALPHA_BOH
:
6282 pname
= symbol_get_bfdsym (fixp
->fx_addsy
)->name
;
6284 /* We need the non-suffixed name of the procedure. Beware that
6285 the main symbol might be equated so look it up and take its name. */
6286 pname_len
= strlen (pname
);
6287 if (pname_len
> 4 && strcmp (pname
+ pname_len
- 4, "..en") == 0)
6290 char *my_pname
= xstrdup (pname
);
6291 my_pname
[pname_len
- 4] = 0;
6292 sym
= symbol_find (my_pname
);
6295 while (symbol_equated_reloc_p (sym
))
6297 symbolS
*n
= symbol_get_value_expression (sym
)->X_add_symbol
;
6299 /* We must avoid looping, as that can occur with a badly
6305 pname
= symbol_get_bfdsym (sym
)->name
;
6308 udata
= (struct evax_private_udata_struct
*)
6309 xmalloc (sizeof (struct evax_private_udata_struct
));
6310 udata
->enbsym
= symbol_get_bfdsym (fixp
->fx_addsy
);
6311 udata
->bsym
= symbol_get_bfdsym (fixp
->tc_fix_data
.info
->psym
);
6312 udata
->origname
= (char *)pname
;
6313 udata
->lkindex
= ((struct evax_private_udata_struct
*)
6314 symbol_get_bfdsym (fixp
->tc_fix_data
.info
->sym
)->udata
.p
)->lkindex
;
6315 reloc
->sym_ptr_ptr
= (void *)udata
;
6316 reloc
->addend
= fixp
->fx_addnumber
;
6326 /* Parse a register name off of the input_line and return a register
6327 number. Gets md_undefined_symbol above to do the register name
6330 Only called as a part of processing the ECOFF .frame directive. */
6333 tc_get_register (int frame ATTRIBUTE_UNUSED
)
6335 int framereg
= AXP_REG_SP
;
6338 if (*input_line_pointer
== '$')
6340 char *s
= input_line_pointer
;
6341 char c
= get_symbol_end ();
6342 symbolS
*sym
= md_undefined_symbol (s
);
6344 *strchr (s
, '\0') = c
;
6345 if (sym
&& (framereg
= S_GET_VALUE (sym
)) <= 31)
6348 as_warn (_("frame reg expected, using $%d."), framereg
);
6351 note_gpreg (framereg
);
6355 /* This is called before the symbol table is processed. In order to
6356 work with gcc when using mips-tfile, we must keep all local labels.
6357 However, in other cases, we want to discard them. If we were
6358 called with -g, but we didn't see any debugging information, it may
6359 mean that gcc is smuggling debugging information through to
6360 mips-tfile, in which case we must generate all local labels. */
6365 alpha_frob_file_before_adjust (void)
6367 if (alpha_debug
!= 0
6368 && ! ecoff_debugging_seen
)
6369 flag_keep_locals
= 1;
6372 #endif /* OBJ_ECOFF */
6374 /* The Alpha has support for some VAX floating point types, as well as for
6375 IEEE floating point. We consider IEEE to be the primary floating point
6376 format, and sneak in the VAX floating point support here. */
6377 #include "config/atof-vax.c"