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 Free Software Foundation, Inc.
4 Contributed by Carnegie Mellon University, 1993.
5 Written by Alessandro Forin, based on earlier gas-1.38 target CPU files.
6 Modified by Ken Raeburn for gas-2.x and ECOFF support.
7 Modified by Richard Henderson for ELF support.
8 Modified by Klaus K"ampf for EVAX (OpenVMS/Alpha) support.
10 This file is part of GAS, the GNU Assembler.
12 GAS is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3, or (at your option)
17 GAS is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with GAS; see the file COPYING. If not, write to the Free
24 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
27 /* Mach Operating System
28 Copyright (c) 1993 Carnegie Mellon University
31 Permission to use, copy, modify and distribute this software and its
32 documentation is hereby granted, provided that both the copyright
33 notice and this permission notice appear in all copies of the
34 software, derivative works or modified versions, and any portions
35 thereof, and that both notices appear in supporting documentation.
37 CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
38 CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
39 ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
41 Carnegie Mellon requests users of this software to return to
43 Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
44 School of Computer Science
45 Carnegie Mellon University
46 Pittsburgh PA 15213-3890
48 any improvements or extensions that they make and grant Carnegie the
49 rights to redistribute these changes. */
53 #include "struc-symbol.h"
56 #include "opcode/alpha.h"
59 #include "elf/alpha.h"
66 #include "dwarf2dbg.h"
67 #include "dw2gencfi.h"
68 #include "safe-ctype.h"
72 #define TOKENIZE_ERROR -1
73 #define TOKENIZE_ERROR_REPORT -2
74 #define MAX_INSN_FIXUPS 2
75 #define MAX_INSN_ARGS 5
80 bfd_reloc_code_real_type reloc
;
82 symbolS
*xtrasym
, *procsym
;
90 struct alpha_fixup fixups
[MAX_INSN_FIXUPS
];
108 void (*emit
) (const expressionS
*, int, const void *);
110 enum alpha_macro_arg argsets
[16];
113 /* Extra expression types. */
115 #define O_pregister O_md1 /* O_register, in parentheses. */
116 #define O_cpregister O_md2 /* + a leading comma. */
118 /* The alpha_reloc_op table below depends on the ordering of these. */
119 #define O_literal O_md3 /* !literal relocation. */
120 #define O_lituse_addr O_md4 /* !lituse_addr relocation. */
121 #define O_lituse_base O_md5 /* !lituse_base relocation. */
122 #define O_lituse_bytoff O_md6 /* !lituse_bytoff relocation. */
123 #define O_lituse_jsr O_md7 /* !lituse_jsr relocation. */
124 #define O_lituse_tlsgd O_md8 /* !lituse_tlsgd relocation. */
125 #define O_lituse_tlsldm O_md9 /* !lituse_tlsldm relocation. */
126 #define O_lituse_jsrdirect O_md10 /* !lituse_jsrdirect relocation. */
127 #define O_gpdisp O_md11 /* !gpdisp relocation. */
128 #define O_gprelhigh O_md12 /* !gprelhigh relocation. */
129 #define O_gprellow O_md13 /* !gprellow relocation. */
130 #define O_gprel O_md14 /* !gprel relocation. */
131 #define O_samegp O_md15 /* !samegp relocation. */
132 #define O_tlsgd O_md16 /* !tlsgd relocation. */
133 #define O_tlsldm O_md17 /* !tlsldm relocation. */
134 #define O_gotdtprel O_md18 /* !gotdtprel relocation. */
135 #define O_dtprelhi O_md19 /* !dtprelhi relocation. */
136 #define O_dtprello O_md20 /* !dtprello relocation. */
137 #define O_dtprel O_md21 /* !dtprel relocation. */
138 #define O_gottprel O_md22 /* !gottprel relocation. */
139 #define O_tprelhi O_md23 /* !tprelhi relocation. */
140 #define O_tprello O_md24 /* !tprello relocation. */
141 #define O_tprel O_md25 /* !tprel relocation. */
143 #define DUMMY_RELOC_LITUSE_ADDR (BFD_RELOC_UNUSED + 1)
144 #define DUMMY_RELOC_LITUSE_BASE (BFD_RELOC_UNUSED + 2)
145 #define DUMMY_RELOC_LITUSE_BYTOFF (BFD_RELOC_UNUSED + 3)
146 #define DUMMY_RELOC_LITUSE_JSR (BFD_RELOC_UNUSED + 4)
147 #define DUMMY_RELOC_LITUSE_TLSGD (BFD_RELOC_UNUSED + 5)
148 #define DUMMY_RELOC_LITUSE_TLSLDM (BFD_RELOC_UNUSED + 6)
149 #define DUMMY_RELOC_LITUSE_JSRDIRECT (BFD_RELOC_UNUSED + 7)
151 #define USER_RELOC_P(R) ((R) >= O_literal && (R) <= O_tprel)
153 /* Macros for extracting the type and number of encoded register tokens. */
155 #define is_ir_num(x) (((x) & 32) == 0)
156 #define is_fpr_num(x) (((x) & 32) != 0)
157 #define regno(x) ((x) & 31)
159 /* Something odd inherited from the old assembler. */
161 #define note_gpreg(R) (alpha_gprmask |= (1 << (R)))
162 #define note_fpreg(R) (alpha_fprmask |= (1 << (R)))
164 /* Predicates for 16- and 32-bit ranges */
165 /* XXX: The non-shift version appears to trigger a compiler bug when
166 cross-assembling from x86 w/ gcc 2.7.2. */
169 #define range_signed_16(x) \
170 (((offsetT) (x) >> 15) == 0 || ((offsetT) (x) >> 15) == -1)
171 #define range_signed_32(x) \
172 (((offsetT) (x) >> 31) == 0 || ((offsetT) (x) >> 31) == -1)
174 #define range_signed_16(x) ((offsetT) (x) >= -(offsetT) 0x8000 && \
175 (offsetT) (x) <= (offsetT) 0x7FFF)
176 #define range_signed_32(x) ((offsetT) (x) >= -(offsetT) 0x80000000 && \
177 (offsetT) (x) <= (offsetT) 0x7FFFFFFF)
180 /* Macros for sign extending from 16- and 32-bits. */
181 /* XXX: The cast macros will work on all the systems that I care about,
182 but really a predicate should be found to use the non-cast forms. */
185 #define sign_extend_16(x) ((short) (x))
186 #define sign_extend_32(x) ((int) (x))
188 #define sign_extend_16(x) ((offsetT) (((x) & 0xFFFF) ^ 0x8000) - 0x8000)
189 #define sign_extend_32(x) ((offsetT) (((x) & 0xFFFFFFFF) \
190 ^ 0x80000000) - 0x80000000)
193 /* Macros to build tokens. */
195 #define set_tok_reg(t, r) (memset (&(t), 0, sizeof (t)), \
196 (t).X_op = O_register, \
197 (t).X_add_number = (r))
198 #define set_tok_preg(t, r) (memset (&(t), 0, sizeof (t)), \
199 (t).X_op = O_pregister, \
200 (t).X_add_number = (r))
201 #define set_tok_cpreg(t, r) (memset (&(t), 0, sizeof (t)), \
202 (t).X_op = O_cpregister, \
203 (t).X_add_number = (r))
204 #define set_tok_freg(t, r) (memset (&(t), 0, sizeof (t)), \
205 (t).X_op = O_register, \
206 (t).X_add_number = (r) + 32)
207 #define set_tok_sym(t, s, a) (memset (&(t), 0, sizeof (t)), \
208 (t).X_op = O_symbol, \
209 (t).X_add_symbol = (s), \
210 (t).X_add_number = (a))
211 #define set_tok_const(t, n) (memset (&(t), 0, sizeof (t)), \
212 (t).X_op = O_constant, \
213 (t).X_add_number = (n))
215 /* Generic assembler global variables which must be defined by all
218 /* Characters which always start a comment. */
219 const char comment_chars
[] = "#";
221 /* Characters which start a comment at the beginning of a line. */
222 const char line_comment_chars
[] = "#";
224 /* Characters which may be used to separate multiple commands on a
226 const char line_separator_chars
[] = ";";
228 /* Characters which are used to indicate an exponent in a floating
230 const char EXP_CHARS
[] = "eE";
232 /* Characters which mean that a number is a floating point constant,
234 /* XXX: Do all of these really get used on the alpha?? */
235 char FLT_CHARS
[] = "rRsSfFdDxXpP";
238 const char *md_shortopts
= "Fm:g+1h:HG:";
240 const char *md_shortopts
= "Fm:gG:";
243 struct option md_longopts
[] =
245 #define OPTION_32ADDR (OPTION_MD_BASE)
246 { "32addr", no_argument
, NULL
, OPTION_32ADDR
},
247 #define OPTION_RELAX (OPTION_32ADDR + 1)
248 { "relax", no_argument
, NULL
, OPTION_RELAX
},
250 #define OPTION_MDEBUG (OPTION_RELAX + 1)
251 #define OPTION_NO_MDEBUG (OPTION_MDEBUG + 1)
252 { "mdebug", no_argument
, NULL
, OPTION_MDEBUG
},
253 { "no-mdebug", no_argument
, NULL
, OPTION_NO_MDEBUG
},
256 #define OPTION_REPLACE (OPTION_RELAX + 1)
257 #define OPTION_NOREPLACE (OPTION_REPLACE+1)
258 { "replace", no_argument
, NULL
, OPTION_REPLACE
},
259 { "noreplace", no_argument
, NULL
, OPTION_NOREPLACE
},
261 { NULL
, no_argument
, NULL
, 0 }
264 size_t md_longopts_size
= sizeof (md_longopts
);
268 #define AXP_REG_R16 16
269 #define AXP_REG_R17 17
271 #define AXP_REG_T9 22
273 #define AXP_REG_T10 23
275 #define AXP_REG_T11 24
277 #define AXP_REG_T12 25
278 #define AXP_REG_AI 25
280 #define AXP_REG_FP 29
283 #define AXP_REG_GP AXP_REG_PV
285 static struct hash_control
*alpha_evax_proc_hash
;
287 #endif /* OBJ_EVAX */
289 /* The cpu for which we are generating code. */
290 static unsigned alpha_target
= AXP_OPCODE_BASE
;
291 static const char *alpha_target_name
= "<all>";
293 /* The hash table of instruction opcodes. */
294 static struct hash_control
*alpha_opcode_hash
;
296 /* The hash table of macro opcodes. */
297 static struct hash_control
*alpha_macro_hash
;
300 /* The $gp relocation symbol. */
301 static symbolS
*alpha_gp_symbol
;
303 /* XXX: what is this, and why is it exported? */
304 valueT alpha_gp_value
;
307 /* The current $gp register. */
308 static int alpha_gp_register
= AXP_REG_GP
;
310 /* A table of the register symbols. */
311 static symbolS
*alpha_register_table
[64];
313 /* Constant sections, or sections of constants. */
315 static segT alpha_lita_section
;
318 segT alpha_link_section
;
321 static segT alpha_lit8_section
;
324 /* Symbols referring to said sections. */
326 static symbolS
*alpha_lita_symbol
;
329 static symbolS
*alpha_link_symbol
;
332 static symbolS
*alpha_lit8_symbol
;
335 /* Literal for .litX+0x8000 within .lita. */
337 static offsetT alpha_lit8_literal
;
340 /* Is the assembler not allowed to use $at? */
341 static int alpha_noat_on
= 0;
343 /* Are macros enabled? */
344 static int alpha_macros_on
= 1;
346 /* Are floats disabled? */
347 static int alpha_nofloats_on
= 0;
349 /* Are addresses 32 bit? */
350 static int alpha_addr32_on
= 0;
352 /* Symbol labelling the current insn. When the Alpha gas sees
355 and the section happens to not be on an eight byte boundary, it
356 will align both the symbol and the .quad to an eight byte boundary. */
357 static symbolS
*alpha_insn_label
;
359 static symbolS
*alpha_prologue_label
;
363 /* Symbol associate with the current jsr instruction. */
364 static symbolS
*alpha_linkage_symbol
;
367 /* Whether we should automatically align data generation pseudo-ops.
368 .align 0 will turn this off. */
369 static int alpha_auto_align_on
= 1;
371 /* The known current alignment of the current section. */
372 static int alpha_current_align
;
374 /* These are exported to ECOFF code. */
375 unsigned long alpha_gprmask
, alpha_fprmask
;
377 /* Whether the debugging option was seen. */
378 static int alpha_debug
;
381 /* Whether we are emitting an mdebug section. */
382 int alpha_flag_mdebug
= -1;
386 /* Whether to perform the VMS procedure call optimization. */
387 int alpha_flag_replace
= 1;
390 /* Don't fully resolve relocations, allowing code movement in the linker. */
391 static int alpha_flag_relax
;
393 /* What value to give to bfd_set_gp_size. */
394 static int g_switch_value
= 8;
397 /* Collect information about current procedure here. */
398 struct alpha_evax_procs
400 symbolS
*symbol
; /* Proc pdesc symbol. */
402 int framereg
; /* Register for frame pointer. */
403 int framesize
; /* Size of frame. */
415 struct alpha_linkage_fixups
*alpha_linkage_fixup_root
;
416 static struct alpha_linkage_fixups
*alpha_linkage_fixup_tail
;
418 static struct alpha_evax_procs
*alpha_evax_proc
;
420 static int alpha_flag_hash_long_names
= 0; /* -+ */
421 static int alpha_flag_show_after_trunc
= 0; /* -H */
423 /* If the -+ switch is given, then a hash is appended to any name that is
424 longer than 64 characters, else longer symbol names are truncated. */
429 /* A table to map the spelling of a relocation operand into an appropriate
430 bfd_reloc_code_real_type type. The table is assumed to be ordered such
431 that op-O_literal indexes into it. */
433 #define ALPHA_RELOC_TABLE(op) \
434 (&alpha_reloc_op[ ((!USER_RELOC_P (op)) \
436 : (int) (op) - (int) O_literal) ])
438 #define DEF(NAME, RELOC, REQ, ALLOW) \
439 { #NAME, sizeof(#NAME)-1, O_##NAME, RELOC, REQ, ALLOW}
441 static const struct alpha_reloc_op_tag
443 const char *name
; /* String to lookup. */
444 size_t length
; /* Size of the string. */
445 operatorT op
; /* Which operator to use. */
446 bfd_reloc_code_real_type reloc
; /* Relocation before frob. */
447 unsigned int require_seq
: 1; /* Require a sequence number. */
448 unsigned int allow_seq
: 1; /* Allow a sequence number. */
452 DEF (literal
, BFD_RELOC_ALPHA_ELF_LITERAL
, 0, 1),
453 DEF (lituse_addr
, DUMMY_RELOC_LITUSE_ADDR
, 1, 1),
454 DEF (lituse_base
, DUMMY_RELOC_LITUSE_BASE
, 1, 1),
455 DEF (lituse_bytoff
, DUMMY_RELOC_LITUSE_BYTOFF
, 1, 1),
456 DEF (lituse_jsr
, DUMMY_RELOC_LITUSE_JSR
, 1, 1),
457 DEF (lituse_tlsgd
, DUMMY_RELOC_LITUSE_TLSGD
, 1, 1),
458 DEF (lituse_tlsldm
, DUMMY_RELOC_LITUSE_TLSLDM
, 1, 1),
459 DEF (lituse_jsrdirect
, DUMMY_RELOC_LITUSE_JSRDIRECT
, 1, 1),
460 DEF (gpdisp
, BFD_RELOC_ALPHA_GPDISP
, 1, 1),
461 DEF (gprelhigh
, BFD_RELOC_ALPHA_GPREL_HI16
, 0, 0),
462 DEF (gprellow
, BFD_RELOC_ALPHA_GPREL_LO16
, 0, 0),
463 DEF (gprel
, BFD_RELOC_GPREL16
, 0, 0),
464 DEF (samegp
, BFD_RELOC_ALPHA_BRSGP
, 0, 0),
465 DEF (tlsgd
, BFD_RELOC_ALPHA_TLSGD
, 0, 1),
466 DEF (tlsldm
, BFD_RELOC_ALPHA_TLSLDM
, 0, 1),
467 DEF (gotdtprel
, BFD_RELOC_ALPHA_GOTDTPREL16
, 0, 0),
468 DEF (dtprelhi
, BFD_RELOC_ALPHA_DTPREL_HI16
, 0, 0),
469 DEF (dtprello
, BFD_RELOC_ALPHA_DTPREL_LO16
, 0, 0),
470 DEF (dtprel
, BFD_RELOC_ALPHA_DTPREL16
, 0, 0),
471 DEF (gottprel
, BFD_RELOC_ALPHA_GOTTPREL16
, 0, 0),
472 DEF (tprelhi
, BFD_RELOC_ALPHA_TPREL_HI16
, 0, 0),
473 DEF (tprello
, BFD_RELOC_ALPHA_TPREL_LO16
, 0, 0),
474 DEF (tprel
, BFD_RELOC_ALPHA_TPREL16
, 0, 0),
479 static const int alpha_num_reloc_op
480 = sizeof (alpha_reloc_op
) / sizeof (*alpha_reloc_op
);
481 #endif /* RELOC_OP_P */
483 /* Maximum # digits needed to hold the largest sequence #. */
484 #define ALPHA_RELOC_DIGITS 25
486 /* Structure to hold explicit sequence information. */
487 struct alpha_reloc_tag
489 fixS
*master
; /* The literal reloc. */
494 fixS
*slaves
; /* Head of linked list of lituses. */
495 segT segment
; /* Segment relocs are in or undefined_section. */
496 long sequence
; /* Sequence #. */
497 unsigned n_master
; /* # of literals. */
498 unsigned n_slaves
; /* # of lituses. */
499 unsigned saw_tlsgd
: 1; /* True if ... */
500 unsigned saw_tlsldm
: 1;
501 unsigned saw_lu_tlsgd
: 1;
502 unsigned saw_lu_tlsldm
: 1;
503 unsigned multi_section_p
: 1; /* True if more than one section was used. */
504 char string
[1]; /* Printable form of sequence to hash with. */
507 /* Hash table to link up literals with the appropriate lituse. */
508 static struct hash_control
*alpha_literal_hash
;
510 /* Sequence numbers for internal use by macros. */
511 static long next_sequence_num
= -1;
513 /* A table of CPU names and opcode sets. */
515 static const struct cpu_type
522 /* Ad hoc convention: cpu number gets palcode, process code doesn't.
523 This supports usage under DU 4.0b that does ".arch ev4", and
524 usage in MILO that does -m21064. Probably something more
525 specific like -m21064-pal should be used, but oh well. */
527 { "21064", AXP_OPCODE_BASE
|AXP_OPCODE_EV4
},
528 { "21064a", AXP_OPCODE_BASE
|AXP_OPCODE_EV4
},
529 { "21066", AXP_OPCODE_BASE
|AXP_OPCODE_EV4
},
530 { "21068", AXP_OPCODE_BASE
|AXP_OPCODE_EV4
},
531 { "21164", AXP_OPCODE_BASE
|AXP_OPCODE_EV5
},
532 { "21164a", AXP_OPCODE_BASE
|AXP_OPCODE_EV5
|AXP_OPCODE_BWX
},
533 { "21164pc", (AXP_OPCODE_BASE
|AXP_OPCODE_EV5
|AXP_OPCODE_BWX
535 { "21264", (AXP_OPCODE_BASE
|AXP_OPCODE_EV6
|AXP_OPCODE_BWX
536 |AXP_OPCODE_MAX
|AXP_OPCODE_CIX
) },
537 { "21264a", (AXP_OPCODE_BASE
|AXP_OPCODE_EV6
|AXP_OPCODE_BWX
538 |AXP_OPCODE_MAX
|AXP_OPCODE_CIX
) },
539 { "21264b", (AXP_OPCODE_BASE
|AXP_OPCODE_EV6
|AXP_OPCODE_BWX
540 |AXP_OPCODE_MAX
|AXP_OPCODE_CIX
) },
542 { "ev4", AXP_OPCODE_BASE
},
543 { "ev45", AXP_OPCODE_BASE
},
544 { "lca45", AXP_OPCODE_BASE
},
545 { "ev5", AXP_OPCODE_BASE
},
546 { "ev56", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
},
547 { "pca56", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
|AXP_OPCODE_MAX
},
548 { "ev6", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
|AXP_OPCODE_MAX
|AXP_OPCODE_CIX
},
549 { "ev67", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
|AXP_OPCODE_MAX
|AXP_OPCODE_CIX
},
550 { "ev68", AXP_OPCODE_BASE
|AXP_OPCODE_BWX
|AXP_OPCODE_MAX
|AXP_OPCODE_CIX
},
552 { "all", AXP_OPCODE_BASE
},
556 /* Some instruction sets indexed by lg(size). */
557 static const char * const sextX_op
[] = { "sextb", "sextw", "sextl", NULL
};
558 static const char * const insXl_op
[] = { "insbl", "inswl", "insll", "insql" };
559 static const char * const insXh_op
[] = { NULL
, "inswh", "inslh", "insqh" };
560 static const char * const extXl_op
[] = { "extbl", "extwl", "extll", "extql" };
561 static const char * const extXh_op
[] = { NULL
, "extwh", "extlh", "extqh" };
562 static const char * const mskXl_op
[] = { "mskbl", "mskwl", "mskll", "mskql" };
563 static const char * const mskXh_op
[] = { NULL
, "mskwh", "msklh", "mskqh" };
564 static const char * const stX_op
[] = { "stb", "stw", "stl", "stq" };
565 static const char * const ldXu_op
[] = { "ldbu", "ldwu", NULL
, NULL
};
567 static void assemble_insn (const struct alpha_opcode
*, const expressionS
*, int, struct alpha_insn
*, bfd_reloc_code_real_type
);
568 static void emit_insn (struct alpha_insn
*);
569 static void assemble_tokens (const char *, const expressionS
*, int, int);
571 static char *s_alpha_section_name (void);
572 static symbolS
*add_to_link_pool (symbolS
*, symbolS
*, offsetT
);
575 static struct alpha_reloc_tag
*
576 get_alpha_reloc_tag (long sequence
)
578 char buffer
[ALPHA_RELOC_DIGITS
];
579 struct alpha_reloc_tag
*info
;
581 sprintf (buffer
, "!%ld", sequence
);
583 info
= (struct alpha_reloc_tag
*) hash_find (alpha_literal_hash
, buffer
);
586 size_t len
= strlen (buffer
);
589 info
= xcalloc (sizeof (struct alpha_reloc_tag
) + len
, 1);
591 info
->segment
= now_seg
;
592 info
->sequence
= sequence
;
593 strcpy (info
->string
, buffer
);
594 errmsg
= hash_insert (alpha_literal_hash
, info
->string
, (void *) info
);
609 alpha_adjust_relocs (bfd
*abfd ATTRIBUTE_UNUSED
,
611 void * ptr ATTRIBUTE_UNUSED
)
613 segment_info_type
*seginfo
= seg_info (sec
);
619 /* If seginfo is NULL, we did not create this section; don't do
620 anything with it. By using a pointer to a pointer, we can update
621 the links in place. */
625 /* If there are no relocations, skip the section. */
626 if (! seginfo
->fix_root
)
629 /* First rebuild the fixup chain without the explicit lituse and
630 gpdisp_lo16 relocs. */
631 prevP
= &seginfo
->fix_root
;
632 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= next
)
634 next
= fixp
->fx_next
;
635 fixp
->fx_next
= (fixS
*) 0;
637 switch (fixp
->fx_r_type
)
639 case BFD_RELOC_ALPHA_LITUSE
:
640 if (fixp
->tc_fix_data
.info
->n_master
== 0)
641 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
642 _("No !literal!%ld was found"),
643 fixp
->tc_fix_data
.info
->sequence
);
645 if (fixp
->fx_offset
== LITUSE_ALPHA_TLSGD
)
647 if (! fixp
->tc_fix_data
.info
->saw_tlsgd
)
648 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
649 _("No !tlsgd!%ld was found"),
650 fixp
->tc_fix_data
.info
->sequence
);
652 else if (fixp
->fx_offset
== LITUSE_ALPHA_TLSLDM
)
654 if (! fixp
->tc_fix_data
.info
->saw_tlsldm
)
655 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
656 _("No !tlsldm!%ld was found"),
657 fixp
->tc_fix_data
.info
->sequence
);
662 case BFD_RELOC_ALPHA_GPDISP_LO16
:
663 if (fixp
->tc_fix_data
.info
->n_master
== 0)
664 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
665 _("No ldah !gpdisp!%ld was found"),
666 fixp
->tc_fix_data
.info
->sequence
);
669 case BFD_RELOC_ALPHA_ELF_LITERAL
:
670 if (fixp
->tc_fix_data
.info
671 && (fixp
->tc_fix_data
.info
->saw_tlsgd
672 || fixp
->tc_fix_data
.info
->saw_tlsldm
))
678 prevP
= &fixp
->fx_next
;
683 /* Go back and re-chain dependent relocations. They are currently
684 linked through the next_reloc field in reverse order, so as we
685 go through the next_reloc chain, we effectively reverse the chain
688 Except if there is more than one !literal for a given sequence
689 number. In that case, the programmer and/or compiler is not sure
690 how control flows from literal to lituse, and we can't be sure to
691 get the relaxation correct.
693 ??? Well, actually we could, if there are enough lituses such that
694 we can make each literal have at least one of each lituse type
695 present. Not implemented.
697 Also suppress the optimization if the !literals/!lituses are spread
698 in different segments. This can happen with "intersting" uses of
699 inline assembly; examples are present in the Linux kernel semaphores. */
701 for (fixp
= seginfo
->fix_root
; fixp
; fixp
= next
)
703 next
= fixp
->fx_next
;
704 switch (fixp
->fx_r_type
)
706 case BFD_RELOC_ALPHA_TLSGD
:
707 case BFD_RELOC_ALPHA_TLSLDM
:
708 if (!fixp
->tc_fix_data
.info
)
710 if (fixp
->tc_fix_data
.info
->n_master
== 0)
712 else if (fixp
->tc_fix_data
.info
->n_master
> 1)
714 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
715 _("too many !literal!%ld for %s"),
716 fixp
->tc_fix_data
.info
->sequence
,
717 (fixp
->fx_r_type
== BFD_RELOC_ALPHA_TLSGD
718 ? "!tlsgd" : "!tlsldm"));
722 fixp
->tc_fix_data
.info
->master
->fx_next
= fixp
->fx_next
;
723 fixp
->fx_next
= fixp
->tc_fix_data
.info
->master
;
724 fixp
= fixp
->fx_next
;
727 case BFD_RELOC_ALPHA_ELF_LITERAL
:
728 if (fixp
->tc_fix_data
.info
729 && fixp
->tc_fix_data
.info
->n_master
== 1
730 && ! fixp
->tc_fix_data
.info
->multi_section_p
)
732 for (slave
= fixp
->tc_fix_data
.info
->slaves
;
734 slave
= slave
->tc_fix_data
.next_reloc
)
736 slave
->fx_next
= fixp
->fx_next
;
737 fixp
->fx_next
= slave
;
742 case BFD_RELOC_ALPHA_GPDISP_HI16
:
743 if (fixp
->tc_fix_data
.info
->n_slaves
== 0)
744 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
745 _("No lda !gpdisp!%ld was found"),
746 fixp
->tc_fix_data
.info
->sequence
);
749 slave
= fixp
->tc_fix_data
.info
->slaves
;
750 slave
->fx_next
= next
;
751 fixp
->fx_next
= slave
;
761 /* Before the relocations are written, reorder them, so that user
762 supplied !lituse relocations follow the appropriate !literal
763 relocations, and similarly for !gpdisp relocations. */
766 alpha_before_fix (void)
768 if (alpha_literal_hash
)
769 bfd_map_over_sections (stdoutput
, alpha_adjust_relocs
, NULL
);
776 debug_exp (expressionS tok
[], int ntok
)
780 fprintf (stderr
, "debug_exp: %d tokens", ntok
);
781 for (i
= 0; i
< ntok
; i
++)
783 expressionS
*t
= &tok
[i
];
788 default: name
= "unknown"; break;
789 case O_illegal
: name
= "O_illegal"; break;
790 case O_absent
: name
= "O_absent"; break;
791 case O_constant
: name
= "O_constant"; break;
792 case O_symbol
: name
= "O_symbol"; break;
793 case O_symbol_rva
: name
= "O_symbol_rva"; break;
794 case O_register
: name
= "O_register"; break;
795 case O_big
: name
= "O_big"; break;
796 case O_uminus
: name
= "O_uminus"; break;
797 case O_bit_not
: name
= "O_bit_not"; break;
798 case O_logical_not
: name
= "O_logical_not"; break;
799 case O_multiply
: name
= "O_multiply"; break;
800 case O_divide
: name
= "O_divide"; break;
801 case O_modulus
: name
= "O_modulus"; break;
802 case O_left_shift
: name
= "O_left_shift"; break;
803 case O_right_shift
: name
= "O_right_shift"; break;
804 case O_bit_inclusive_or
: name
= "O_bit_inclusive_or"; break;
805 case O_bit_or_not
: name
= "O_bit_or_not"; break;
806 case O_bit_exclusive_or
: name
= "O_bit_exclusive_or"; break;
807 case O_bit_and
: name
= "O_bit_and"; break;
808 case O_add
: name
= "O_add"; break;
809 case O_subtract
: name
= "O_subtract"; break;
810 case O_eq
: name
= "O_eq"; break;
811 case O_ne
: name
= "O_ne"; break;
812 case O_lt
: name
= "O_lt"; break;
813 case O_le
: name
= "O_le"; break;
814 case O_ge
: name
= "O_ge"; break;
815 case O_gt
: name
= "O_gt"; break;
816 case O_logical_and
: name
= "O_logical_and"; break;
817 case O_logical_or
: name
= "O_logical_or"; break;
818 case O_index
: name
= "O_index"; break;
819 case O_pregister
: name
= "O_pregister"; break;
820 case O_cpregister
: name
= "O_cpregister"; break;
821 case O_literal
: name
= "O_literal"; break;
822 case O_lituse_addr
: name
= "O_lituse_addr"; break;
823 case O_lituse_base
: name
= "O_lituse_base"; break;
824 case O_lituse_bytoff
: name
= "O_lituse_bytoff"; break;
825 case O_lituse_jsr
: name
= "O_lituse_jsr"; break;
826 case O_lituse_tlsgd
: name
= "O_lituse_tlsgd"; break;
827 case O_lituse_tlsldm
: name
= "O_lituse_tlsldm"; break;
828 case O_lituse_jsrdirect
: name
= "O_lituse_jsrdirect"; break;
829 case O_gpdisp
: name
= "O_gpdisp"; break;
830 case O_gprelhigh
: name
= "O_gprelhigh"; break;
831 case O_gprellow
: name
= "O_gprellow"; break;
832 case O_gprel
: name
= "O_gprel"; break;
833 case O_samegp
: name
= "O_samegp"; break;
834 case O_tlsgd
: name
= "O_tlsgd"; break;
835 case O_tlsldm
: name
= "O_tlsldm"; break;
836 case O_gotdtprel
: name
= "O_gotdtprel"; break;
837 case O_dtprelhi
: name
= "O_dtprelhi"; break;
838 case O_dtprello
: name
= "O_dtprello"; break;
839 case O_dtprel
: name
= "O_dtprel"; break;
840 case O_gottprel
: name
= "O_gottprel"; break;
841 case O_tprelhi
: name
= "O_tprelhi"; break;
842 case O_tprello
: name
= "O_tprello"; break;
843 case O_tprel
: name
= "O_tprel"; break;
846 fprintf (stderr
, ", %s(%s, %s, %d)", name
,
847 (t
->X_add_symbol
) ? S_GET_NAME (t
->X_add_symbol
) : "--",
848 (t
->X_op_symbol
) ? S_GET_NAME (t
->X_op_symbol
) : "--",
849 (int) t
->X_add_number
);
851 fprintf (stderr
, "\n");
856 /* Parse the arguments to an opcode. */
859 tokenize_arguments (char *str
,
863 expressionS
*end_tok
= tok
+ ntok
;
864 char *old_input_line_pointer
;
865 int saw_comma
= 0, saw_arg
= 0;
867 expressionS
*orig_tok
= tok
;
871 const struct alpha_reloc_op_tag
*r
;
874 int reloc_found_p
= 0;
877 memset (tok
, 0, sizeof (*tok
) * ntok
);
879 /* Save and restore input_line_pointer around this function. */
880 old_input_line_pointer
= input_line_pointer
;
881 input_line_pointer
= str
;
884 /* ??? Wrest control of ! away from the regular expression parser. */
885 is_end_of_line
[(unsigned char) '!'] = 1;
888 while (tok
< end_tok
&& *input_line_pointer
)
891 switch (*input_line_pointer
)
898 /* A relocation operand can be placed after the normal operand on an
899 assembly language statement, and has the following form:
900 !relocation_type!sequence_number. */
903 /* Only support one relocation op per insn. */
904 as_bad (_("More than one relocation op per insn"));
911 ++input_line_pointer
;
913 p
= input_line_pointer
;
914 c
= get_symbol_end ();
916 /* Parse !relocation_type. */
917 len
= input_line_pointer
- p
;
920 as_bad (_("No relocation operand"));
924 r
= &alpha_reloc_op
[0];
925 for (i
= alpha_num_reloc_op
- 1; i
>= 0; i
--, r
++)
926 if (len
== r
->length
&& memcmp (p
, r
->name
, len
) == 0)
930 as_bad (_("Unknown relocation operand: !%s"), p
);
934 *input_line_pointer
= c
;
936 if (*input_line_pointer
!= '!')
940 as_bad (_("no sequence number after !%s"), p
);
944 tok
->X_add_number
= 0;
950 as_bad (_("!%s does not use a sequence number"), p
);
954 input_line_pointer
++;
956 /* Parse !sequence_number. */
958 if (tok
->X_op
!= O_constant
|| tok
->X_add_number
<= 0)
960 as_bad (_("Bad sequence number: !%s!%s"),
961 r
->name
, input_line_pointer
);
970 #endif /* RELOC_OP_P */
973 ++input_line_pointer
;
974 if (saw_comma
|| !saw_arg
)
981 char *hold
= input_line_pointer
++;
983 /* First try for parenthesized register ... */
985 if (*input_line_pointer
== ')' && tok
->X_op
== O_register
)
987 tok
->X_op
= (saw_comma
? O_cpregister
: O_pregister
);
990 ++input_line_pointer
;
995 /* ... then fall through to plain expression. */
996 input_line_pointer
= hold
;
1000 if (saw_arg
&& !saw_comma
)
1004 if (tok
->X_op
== O_illegal
|| tok
->X_op
== O_absent
)
1017 input_line_pointer
= old_input_line_pointer
;
1020 debug_exp (orig_tok
, ntok
- (end_tok
- tok
));
1023 is_end_of_line
[(unsigned char) '!'] = 0;
1026 return ntok
- (end_tok
- tok
);
1030 is_end_of_line
[(unsigned char) '!'] = 0;
1032 input_line_pointer
= old_input_line_pointer
;
1033 return TOKENIZE_ERROR
;
1037 is_end_of_line
[(unsigned char) '!'] = 0;
1039 input_line_pointer
= old_input_line_pointer
;
1040 return TOKENIZE_ERROR_REPORT
;
1043 /* Search forward through all variants of an opcode looking for a
1046 static const struct alpha_opcode
*
1047 find_opcode_match (const struct alpha_opcode
*first_opcode
,
1048 const expressionS
*tok
,
1052 const struct alpha_opcode
*opcode
= first_opcode
;
1054 int got_cpu_match
= 0;
1058 const unsigned char *opidx
;
1061 /* Don't match opcodes that don't exist on this architecture. */
1062 if (!(opcode
->flags
& alpha_target
))
1067 for (opidx
= opcode
->operands
; *opidx
; ++opidx
)
1069 const struct alpha_operand
*operand
= &alpha_operands
[*opidx
];
1071 /* Only take input from real operands. */
1072 if (operand
->flags
& AXP_OPERAND_FAKE
)
1075 /* When we expect input, make sure we have it. */
1078 if ((operand
->flags
& AXP_OPERAND_OPTIONAL_MASK
) == 0)
1083 /* Match operand type with expression type. */
1084 switch (operand
->flags
& AXP_OPERAND_TYPECHECK_MASK
)
1086 case AXP_OPERAND_IR
:
1087 if (tok
[tokidx
].X_op
!= O_register
1088 || !is_ir_num (tok
[tokidx
].X_add_number
))
1091 case AXP_OPERAND_FPR
:
1092 if (tok
[tokidx
].X_op
!= O_register
1093 || !is_fpr_num (tok
[tokidx
].X_add_number
))
1096 case AXP_OPERAND_IR
| AXP_OPERAND_PARENS
:
1097 if (tok
[tokidx
].X_op
!= O_pregister
1098 || !is_ir_num (tok
[tokidx
].X_add_number
))
1101 case AXP_OPERAND_IR
| AXP_OPERAND_PARENS
| AXP_OPERAND_COMMA
:
1102 if (tok
[tokidx
].X_op
!= O_cpregister
1103 || !is_ir_num (tok
[tokidx
].X_add_number
))
1107 case AXP_OPERAND_RELATIVE
:
1108 case AXP_OPERAND_SIGNED
:
1109 case AXP_OPERAND_UNSIGNED
:
1110 switch (tok
[tokidx
].X_op
)
1125 /* Everything else should have been fake. */
1131 /* Possible match -- did we use all of our input? */
1140 while (++opcode
- alpha_opcodes
< (int) alpha_num_opcodes
1141 && !strcmp (opcode
->name
, first_opcode
->name
));
1144 *pcpumatch
= got_cpu_match
;
1149 /* Given an opcode name and a pre-tokenized set of arguments, assemble
1150 the insn, but do not emit it.
1152 Note that this implies no macros allowed, since we can't store more
1153 than one insn in an insn structure. */
1156 assemble_tokens_to_insn (const char *opname
,
1157 const expressionS
*tok
,
1159 struct alpha_insn
*insn
)
1161 const struct alpha_opcode
*opcode
;
1163 /* Search opcodes. */
1164 opcode
= (const struct alpha_opcode
*) hash_find (alpha_opcode_hash
, opname
);
1168 opcode
= find_opcode_match (opcode
, tok
, &ntok
, &cpumatch
);
1171 assemble_insn (opcode
, tok
, ntok
, insn
, BFD_RELOC_UNUSED
);
1175 as_bad (_("inappropriate arguments for opcode `%s'"), opname
);
1177 as_bad (_("opcode `%s' not supported for target %s"), opname
,
1181 as_bad (_("unknown opcode `%s'"), opname
);
1184 /* Build a BFD section with its flags set appropriately for the .lita,
1185 .lit8, or .lit4 sections. */
1188 create_literal_section (const char *name
,
1192 segT current_section
= now_seg
;
1193 int current_subsec
= now_subseg
;
1196 *secp
= new_sec
= subseg_new (name
, 0);
1197 subseg_set (current_section
, current_subsec
);
1198 bfd_set_section_alignment (stdoutput
, new_sec
, 4);
1199 bfd_set_section_flags (stdoutput
, new_sec
,
1200 SEC_RELOC
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1203 S_CLEAR_EXTERNAL (*symp
= section_symbol (new_sec
));
1206 /* Load a (partial) expression into a target register.
1208 If poffset is not null, after the call it will either contain
1209 O_constant 0, or a 16-bit offset appropriate for any MEM format
1210 instruction. In addition, pbasereg will be modified to point to
1211 the base register to use in that MEM format instruction.
1213 In any case, *pbasereg should contain a base register to add to the
1214 expression. This will normally be either AXP_REG_ZERO or
1215 alpha_gp_register. Symbol addresses will always be loaded via $gp,
1216 so "foo($0)" is interpreted as adding the address of foo to $0;
1217 i.e. "ldq $targ, LIT($gp); addq $targ, $0, $targ". Odd, perhaps,
1218 but this is what OSF/1 does.
1220 If explicit relocations of the form !literal!<number> are allowed,
1221 and used, then explicit_reloc with be an expression pointer.
1223 Finally, the return value is nonzero if the calling macro may emit
1224 a LITUSE reloc if otherwise appropriate; the return value is the
1225 sequence number to use. */
1228 load_expression (int targreg
,
1229 const expressionS
*exp
,
1231 expressionS
*poffset
,
1234 long emit_lituse
= 0;
1235 offsetT addend
= exp
->X_add_number
;
1236 int basereg
= *pbasereg
;
1237 struct alpha_insn insn
;
1238 expressionS newtok
[3];
1247 /* Attempt to reduce .lit load by splitting the offset from
1248 its symbol when possible, but don't create a situation in
1250 if (!range_signed_32 (addend
) &&
1251 (alpha_noat_on
|| targreg
== AXP_REG_AT
))
1253 lit
= add_to_literal_pool (exp
->X_add_symbol
, addend
,
1254 alpha_lita_section
, 8);
1258 lit
= add_to_literal_pool (exp
->X_add_symbol
, 0,
1259 alpha_lita_section
, 8);
1262 as_fatal (_("overflow in literal (.lita) table"));
1264 /* Emit "ldq r, lit(gp)". */
1266 if (basereg
!= alpha_gp_register
&& targreg
== basereg
)
1269 as_bad (_("macro requires $at register while noat in effect"));
1270 if (targreg
== AXP_REG_AT
)
1271 as_bad (_("macro requires $at while $at in use"));
1273 set_tok_reg (newtok
[0], AXP_REG_AT
);
1276 set_tok_reg (newtok
[0], targreg
);
1278 set_tok_sym (newtok
[1], alpha_lita_symbol
, lit
);
1279 set_tok_preg (newtok
[2], alpha_gp_register
);
1281 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1283 assert (insn
.nfixups
== 1);
1284 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_LITERAL
;
1285 insn
.sequence
= emit_lituse
= next_sequence_num
--;
1286 #endif /* OBJ_ECOFF */
1288 /* Emit "ldq r, gotoff(gp)". */
1290 if (basereg
!= alpha_gp_register
&& targreg
== basereg
)
1293 as_bad (_("macro requires $at register while noat in effect"));
1294 if (targreg
== AXP_REG_AT
)
1295 as_bad (_("macro requires $at while $at in use"));
1297 set_tok_reg (newtok
[0], AXP_REG_AT
);
1300 set_tok_reg (newtok
[0], targreg
);
1302 /* XXX: Disable this .got minimizing optimization so that we can get
1303 better instruction offset knowledge in the compiler. This happens
1304 very infrequently anyway. */
1306 || (!range_signed_32 (addend
)
1307 && (alpha_noat_on
|| targreg
== AXP_REG_AT
)))
1313 set_tok_sym (newtok
[1], exp
->X_add_symbol
, 0);
1315 set_tok_preg (newtok
[2], alpha_gp_register
);
1317 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1319 assert (insn
.nfixups
== 1);
1320 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_ELF_LITERAL
;
1321 insn
.sequence
= emit_lituse
= next_sequence_num
--;
1322 #endif /* OBJ_ELF */
1324 /* Find symbol or symbol pointer in link section. */
1326 if (exp
->X_add_symbol
== alpha_evax_proc
->symbol
)
1328 if (range_signed_16 (addend
))
1330 set_tok_reg (newtok
[0], targreg
);
1331 set_tok_const (newtok
[1], addend
);
1332 set_tok_preg (newtok
[2], basereg
);
1333 assemble_tokens_to_insn ("lda", newtok
, 3, &insn
);
1338 set_tok_reg (newtok
[0], targreg
);
1339 set_tok_const (newtok
[1], 0);
1340 set_tok_preg (newtok
[2], basereg
);
1341 assemble_tokens_to_insn ("lda", newtok
, 3, &insn
);
1346 const char *symname
= S_GET_NAME (exp
->X_add_symbol
);
1347 const char *ptr1
, *ptr2
;
1348 int symlen
= strlen (symname
);
1351 strcmp (ptr2
= &symname
[symlen
- 4], "..lk") == 0))
1353 set_tok_reg (newtok
[0], targreg
);
1356 newtok
[1].X_op
= O_subtract
;
1357 newtok
[1].X_op_symbol
= alpha_evax_proc
->symbol
;
1359 set_tok_preg (newtok
[2], basereg
);
1360 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1361 alpha_linkage_symbol
= exp
->X_add_symbol
;
1364 set_tok_const (*poffset
, 0);
1366 if (alpha_flag_replace
&& targreg
== 26)
1370 volatile asymbol
*dummy
;
1372 ptr1
= strstr (symname
, "..") + 2;
1375 ensymname
= (char *) xmalloc (ptr2
- ptr1
+ 5);
1376 memcpy (ensymname
, ptr1
, ptr2
- ptr1
);
1377 memcpy (ensymname
+ (ptr2
- ptr1
), "..en", 5);
1379 assert (insn
.nfixups
+ 1 <= MAX_INSN_FIXUPS
);
1380 insn
.fixups
[insn
.nfixups
].reloc
= BFD_RELOC_ALPHA_NOP
;
1381 ensym
= symbol_find_or_make (ensymname
);
1383 /* The fixup must be the same as the BFD_RELOC_ALPHA_BOH
1384 case in emit_jsrjmp. See B.4.5.2 of the OpenVMS Linker
1386 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_symbol
;
1387 insn
.fixups
[insn
.nfixups
].exp
.X_add_symbol
= ensym
;
1388 insn
.fixups
[insn
.nfixups
].exp
.X_add_number
= 0;
1389 insn
.fixups
[insn
.nfixups
].xtrasym
= alpha_linkage_symbol
;
1390 insn
.fixups
[insn
.nfixups
].procsym
= alpha_evax_proc
->symbol
;
1393 /* ??? Force bsym to be instantiated now, as it will be
1394 too late to do so in tc_gen_reloc. */
1395 dummy
= symbol_get_bfdsym (exp
->X_add_symbol
);
1397 else if (alpha_flag_replace
&& targreg
== 27)
1402 ptr1
= strstr (symname
, "..") + 2;
1405 psymname
= (char *) xmalloc (ptr2
- ptr1
+ 1);
1406 memcpy (psymname
, ptr1
, ptr2
- ptr1
);
1407 psymname
[ptr2
- ptr1
] = 0;
1408 assert (insn
.nfixups
+ 1 <= MAX_INSN_FIXUPS
);
1409 insn
.fixups
[insn
.nfixups
].reloc
= BFD_RELOC_ALPHA_LDA
;
1410 psym
= symbol_find_or_make (psymname
);
1412 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_subtract
;
1413 insn
.fixups
[insn
.nfixups
].exp
.X_add_symbol
= psym
;
1414 insn
.fixups
[insn
.nfixups
].exp
.X_op_symbol
= alpha_evax_proc
->symbol
;
1415 insn
.fixups
[insn
.nfixups
].exp
.X_add_number
= 0;
1416 insn
.fixups
[insn
.nfixups
].xtrasym
= alpha_linkage_symbol
;
1417 insn
.fixups
[insn
.nfixups
].procsym
= alpha_evax_proc
->symbol
;
1428 if (!range_signed_32 (addend
))
1429 addend
= sign_extend_32 (addend
);
1430 linkexp
= add_to_link_pool (alpha_evax_proc
->symbol
,
1431 exp
->X_add_symbol
, 0);
1432 set_tok_reg (newtok
[0], targreg
);
1433 set_tok_sym (newtok
[1], linkexp
, 0);
1434 set_tok_preg (newtok
[2], basereg
);
1435 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1438 #endif /* OBJ_EVAX */
1443 if (basereg
!= alpha_gp_register
&& basereg
!= AXP_REG_ZERO
)
1445 /* Emit "addq r, base, r". */
1447 set_tok_reg (newtok
[1], basereg
);
1448 set_tok_reg (newtok
[2], targreg
);
1449 assemble_tokens ("addq", newtok
, 3, 0);
1460 /* Assume that this difference expression will be resolved to an
1461 absolute value and that that value will fit in 16 bits. */
1463 set_tok_reg (newtok
[0], targreg
);
1465 set_tok_preg (newtok
[2], basereg
);
1466 assemble_tokens (opname
, newtok
, 3, 0);
1469 set_tok_const (*poffset
, 0);
1473 if (exp
->X_add_number
> 0)
1474 as_bad (_("bignum invalid; zero assumed"));
1476 as_bad (_("floating point number invalid; zero assumed"));
1481 as_bad (_("can't handle expression"));
1486 if (!range_signed_32 (addend
))
1492 long seq_num
= next_sequence_num
--;
1495 /* For 64-bit addends, just put it in the literal pool. */
1497 /* Emit "ldq targreg, lit(basereg)". */
1498 litexp
= add_to_link_pool (alpha_evax_proc
->symbol
,
1499 section_symbol (absolute_section
), addend
);
1500 set_tok_reg (newtok
[0], targreg
);
1501 set_tok_sym (newtok
[1], litexp
, 0);
1502 set_tok_preg (newtok
[2], alpha_gp_register
);
1503 assemble_tokens ("ldq", newtok
, 3, 0);
1506 if (alpha_lit8_section
== NULL
)
1508 create_literal_section (".lit8",
1509 &alpha_lit8_section
,
1510 &alpha_lit8_symbol
);
1513 alpha_lit8_literal
= add_to_literal_pool (alpha_lit8_symbol
, 0x8000,
1514 alpha_lita_section
, 8);
1515 if (alpha_lit8_literal
>= 0x8000)
1516 as_fatal (_("overflow in literal (.lita) table"));
1520 lit
= add_to_literal_pool (NULL
, addend
, alpha_lit8_section
, 8) - 0x8000;
1522 as_fatal (_("overflow in literal (.lit8) table"));
1524 /* Emit "lda litreg, .lit8+0x8000". */
1526 if (targreg
== basereg
)
1529 as_bad (_("macro requires $at register while noat in effect"));
1530 if (targreg
== AXP_REG_AT
)
1531 as_bad (_("macro requires $at while $at in use"));
1533 set_tok_reg (newtok
[0], AXP_REG_AT
);
1536 set_tok_reg (newtok
[0], targreg
);
1538 set_tok_sym (newtok
[1], alpha_lita_symbol
, alpha_lit8_literal
);
1541 set_tok_sym (newtok
[1], alpha_lit8_symbol
, 0x8000);
1543 set_tok_preg (newtok
[2], alpha_gp_register
);
1545 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1547 assert (insn
.nfixups
== 1);
1549 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_LITERAL
;
1552 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_ELF_LITERAL
;
1554 insn
.sequence
= seq_num
;
1558 /* Emit "ldq litreg, lit(litreg)". */
1560 set_tok_const (newtok
[1], lit
);
1561 set_tok_preg (newtok
[2], newtok
[0].X_add_number
);
1563 assemble_tokens_to_insn ("ldq", newtok
, 3, &insn
);
1565 assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
1566 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
1567 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
1569 insn
.sequence
= seq_num
;
1574 /* Emit "addq litreg, base, target". */
1576 if (basereg
!= AXP_REG_ZERO
)
1578 set_tok_reg (newtok
[1], basereg
);
1579 set_tok_reg (newtok
[2], targreg
);
1580 assemble_tokens ("addq", newtok
, 3, 0);
1582 #endif /* !OBJ_EVAX */
1585 set_tok_const (*poffset
, 0);
1586 *pbasereg
= targreg
;
1590 offsetT low
, high
, extra
, tmp
;
1592 /* For 32-bit operands, break up the addend. */
1594 low
= sign_extend_16 (addend
);
1596 high
= sign_extend_16 (tmp
>> 16);
1598 if (tmp
- (high
<< 16))
1602 high
= sign_extend_16 (tmp
>> 16);
1607 set_tok_reg (newtok
[0], targreg
);
1608 set_tok_preg (newtok
[2], basereg
);
1612 /* Emit "ldah r, extra(r). */
1613 set_tok_const (newtok
[1], extra
);
1614 assemble_tokens ("ldah", newtok
, 3, 0);
1615 set_tok_preg (newtok
[2], basereg
= targreg
);
1620 /* Emit "ldah r, high(r). */
1621 set_tok_const (newtok
[1], high
);
1622 assemble_tokens ("ldah", newtok
, 3, 0);
1624 set_tok_preg (newtok
[2], basereg
);
1627 if ((low
&& !poffset
) || (!poffset
&& basereg
!= targreg
))
1629 /* Emit "lda r, low(base)". */
1630 set_tok_const (newtok
[1], low
);
1631 assemble_tokens ("lda", newtok
, 3, 0);
1637 set_tok_const (*poffset
, low
);
1638 *pbasereg
= basereg
;
1644 /* The lda macro differs from the lda instruction in that it handles
1645 most simple expressions, particularly symbol address loads and
1649 emit_lda (const expressionS
*tok
,
1651 const void * unused ATTRIBUTE_UNUSED
)
1656 basereg
= (tok
[1].X_op
== O_constant
? AXP_REG_ZERO
: alpha_gp_register
);
1658 basereg
= tok
[2].X_add_number
;
1660 (void) load_expression (tok
[0].X_add_number
, &tok
[1], &basereg
, NULL
, "lda");
1663 /* The ldah macro differs from the ldah instruction in that it has $31
1664 as an implied base register. */
1667 emit_ldah (const expressionS
*tok
,
1668 int ntok ATTRIBUTE_UNUSED
,
1669 const void * unused ATTRIBUTE_UNUSED
)
1671 expressionS newtok
[3];
1675 set_tok_preg (newtok
[2], AXP_REG_ZERO
);
1677 assemble_tokens ("ldah", newtok
, 3, 0);
1680 /* Called internally to handle all alignment needs. This takes care
1681 of eliding calls to frag_align if'n the cached current alignment
1682 says we've already got it, as well as taking care of the auto-align
1683 feature wrt labels. */
1689 int force ATTRIBUTE_UNUSED
)
1691 if (alpha_current_align
>= n
)
1696 if (subseg_text_p (now_seg
))
1697 frag_align_code (n
, 0);
1699 frag_align (n
, 0, 0);
1702 frag_align (n
, *pfill
, 0);
1704 alpha_current_align
= n
;
1706 if (label
!= NULL
&& S_GET_SEGMENT (label
) == now_seg
)
1708 symbol_set_frag (label
, frag_now
);
1709 S_SET_VALUE (label
, (valueT
) frag_now_fix ());
1712 record_alignment (now_seg
, n
);
1714 /* ??? If alpha_flag_relax && force && elf, record the requested alignment
1715 in a reloc for the linker to see. */
1718 /* Actually output an instruction with its fixup. */
1721 emit_insn (struct alpha_insn
*insn
)
1726 /* Take care of alignment duties. */
1727 if (alpha_auto_align_on
&& alpha_current_align
< 2)
1728 alpha_align (2, (char *) NULL
, alpha_insn_label
, 0);
1729 if (alpha_current_align
> 2)
1730 alpha_current_align
= 2;
1731 alpha_insn_label
= NULL
;
1733 /* Write out the instruction. */
1735 md_number_to_chars (f
, insn
->insn
, 4);
1738 dwarf2_emit_insn (4);
1741 /* Apply the fixups in order. */
1742 for (i
= 0; i
< insn
->nfixups
; ++i
)
1744 const struct alpha_operand
*operand
= (const struct alpha_operand
*) 0;
1745 struct alpha_fixup
*fixup
= &insn
->fixups
[i
];
1746 struct alpha_reloc_tag
*info
= NULL
;
1750 /* Some fixups are only used internally and so have no howto. */
1751 if ((int) fixup
->reloc
< 0)
1753 operand
= &alpha_operands
[-(int) fixup
->reloc
];
1755 pcrel
= ((operand
->flags
& AXP_OPERAND_RELATIVE
) != 0);
1757 else if (fixup
->reloc
> BFD_RELOC_UNUSED
1758 || fixup
->reloc
== BFD_RELOC_ALPHA_GPDISP_HI16
1759 || fixup
->reloc
== BFD_RELOC_ALPHA_GPDISP_LO16
)
1766 reloc_howto_type
*reloc_howto
1767 = bfd_reloc_type_lookup (stdoutput
, fixup
->reloc
);
1768 assert (reloc_howto
);
1770 size
= bfd_get_reloc_size (reloc_howto
);
1772 switch (fixup
->reloc
)
1775 case BFD_RELOC_ALPHA_NOP
:
1776 case BFD_RELOC_ALPHA_BSR
:
1777 case BFD_RELOC_ALPHA_LDA
:
1778 case BFD_RELOC_ALPHA_BOH
:
1782 assert (size
>= 1 && size
<= 4);
1785 pcrel
= reloc_howto
->pc_relative
;
1788 fixP
= fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, size
,
1789 &fixup
->exp
, pcrel
, fixup
->reloc
);
1791 /* Turn off complaints that the addend is too large for some fixups,
1792 and copy in the sequence number for the explicit relocations. */
1793 switch (fixup
->reloc
)
1795 case BFD_RELOC_ALPHA_HINT
:
1796 case BFD_RELOC_GPREL32
:
1797 case BFD_RELOC_GPREL16
:
1798 case BFD_RELOC_ALPHA_GPREL_HI16
:
1799 case BFD_RELOC_ALPHA_GPREL_LO16
:
1800 case BFD_RELOC_ALPHA_GOTDTPREL16
:
1801 case BFD_RELOC_ALPHA_DTPREL_HI16
:
1802 case BFD_RELOC_ALPHA_DTPREL_LO16
:
1803 case BFD_RELOC_ALPHA_DTPREL16
:
1804 case BFD_RELOC_ALPHA_GOTTPREL16
:
1805 case BFD_RELOC_ALPHA_TPREL_HI16
:
1806 case BFD_RELOC_ALPHA_TPREL_LO16
:
1807 case BFD_RELOC_ALPHA_TPREL16
:
1808 fixP
->fx_no_overflow
= 1;
1811 case BFD_RELOC_ALPHA_GPDISP_HI16
:
1812 fixP
->fx_no_overflow
= 1;
1813 fixP
->fx_addsy
= section_symbol (now_seg
);
1814 fixP
->fx_offset
= 0;
1816 info
= get_alpha_reloc_tag (insn
->sequence
);
1817 if (++info
->n_master
> 1)
1818 as_bad (_("too many ldah insns for !gpdisp!%ld"), insn
->sequence
);
1819 if (info
->segment
!= now_seg
)
1820 as_bad (_("both insns for !gpdisp!%ld must be in the same section"),
1822 fixP
->tc_fix_data
.info
= info
;
1825 case BFD_RELOC_ALPHA_GPDISP_LO16
:
1826 fixP
->fx_no_overflow
= 1;
1828 info
= get_alpha_reloc_tag (insn
->sequence
);
1829 if (++info
->n_slaves
> 1)
1830 as_bad (_("too many lda insns for !gpdisp!%ld"), insn
->sequence
);
1831 if (info
->segment
!= now_seg
)
1832 as_bad (_("both insns for !gpdisp!%ld must be in the same section"),
1834 fixP
->tc_fix_data
.info
= info
;
1835 info
->slaves
= fixP
;
1838 case BFD_RELOC_ALPHA_LITERAL
:
1839 case BFD_RELOC_ALPHA_ELF_LITERAL
:
1840 fixP
->fx_no_overflow
= 1;
1842 if (insn
->sequence
== 0)
1844 info
= get_alpha_reloc_tag (insn
->sequence
);
1845 info
->master
= fixP
;
1847 if (info
->segment
!= now_seg
)
1848 info
->multi_section_p
= 1;
1849 fixP
->tc_fix_data
.info
= info
;
1853 case DUMMY_RELOC_LITUSE_ADDR
:
1854 fixP
->fx_offset
= LITUSE_ALPHA_ADDR
;
1856 case DUMMY_RELOC_LITUSE_BASE
:
1857 fixP
->fx_offset
= LITUSE_ALPHA_BASE
;
1859 case DUMMY_RELOC_LITUSE_BYTOFF
:
1860 fixP
->fx_offset
= LITUSE_ALPHA_BYTOFF
;
1862 case DUMMY_RELOC_LITUSE_JSR
:
1863 fixP
->fx_offset
= LITUSE_ALPHA_JSR
;
1865 case DUMMY_RELOC_LITUSE_TLSGD
:
1866 fixP
->fx_offset
= LITUSE_ALPHA_TLSGD
;
1868 case DUMMY_RELOC_LITUSE_TLSLDM
:
1869 fixP
->fx_offset
= LITUSE_ALPHA_TLSLDM
;
1871 case DUMMY_RELOC_LITUSE_JSRDIRECT
:
1872 fixP
->fx_offset
= LITUSE_ALPHA_JSRDIRECT
;
1875 fixP
->fx_addsy
= section_symbol (now_seg
);
1876 fixP
->fx_r_type
= BFD_RELOC_ALPHA_LITUSE
;
1878 info
= get_alpha_reloc_tag (insn
->sequence
);
1879 if (fixup
->reloc
== DUMMY_RELOC_LITUSE_TLSGD
)
1880 info
->saw_lu_tlsgd
= 1;
1881 else if (fixup
->reloc
== DUMMY_RELOC_LITUSE_TLSLDM
)
1882 info
->saw_lu_tlsldm
= 1;
1883 if (++info
->n_slaves
> 1)
1885 if (info
->saw_lu_tlsgd
)
1886 as_bad (_("too many lituse insns for !lituse_tlsgd!%ld"),
1888 else if (info
->saw_lu_tlsldm
)
1889 as_bad (_("too many lituse insns for !lituse_tlsldm!%ld"),
1892 fixP
->tc_fix_data
.info
= info
;
1893 fixP
->tc_fix_data
.next_reloc
= info
->slaves
;
1894 info
->slaves
= fixP
;
1895 if (info
->segment
!= now_seg
)
1896 info
->multi_section_p
= 1;
1899 case BFD_RELOC_ALPHA_TLSGD
:
1900 fixP
->fx_no_overflow
= 1;
1902 if (insn
->sequence
== 0)
1904 info
= get_alpha_reloc_tag (insn
->sequence
);
1905 if (info
->saw_tlsgd
)
1906 as_bad (_("duplicate !tlsgd!%ld"), insn
->sequence
);
1907 else if (info
->saw_tlsldm
)
1908 as_bad (_("sequence number in use for !tlsldm!%ld"),
1911 info
->saw_tlsgd
= 1;
1912 fixP
->tc_fix_data
.info
= info
;
1915 case BFD_RELOC_ALPHA_TLSLDM
:
1916 fixP
->fx_no_overflow
= 1;
1918 if (insn
->sequence
== 0)
1920 info
= get_alpha_reloc_tag (insn
->sequence
);
1921 if (info
->saw_tlsldm
)
1922 as_bad (_("duplicate !tlsldm!%ld"), insn
->sequence
);
1923 else if (info
->saw_tlsgd
)
1924 as_bad (_("sequence number in use for !tlsgd!%ld"),
1927 info
->saw_tlsldm
= 1;
1928 fixP
->tc_fix_data
.info
= info
;
1932 case BFD_RELOC_ALPHA_NOP
:
1933 case BFD_RELOC_ALPHA_LDA
:
1934 case BFD_RELOC_ALPHA_BSR
:
1935 case BFD_RELOC_ALPHA_BOH
:
1936 info
= get_alpha_reloc_tag (next_sequence_num
--);
1937 fixP
->tc_fix_data
.info
= info
;
1938 fixP
->tc_fix_data
.info
->sym
= fixup
->xtrasym
;
1939 fixP
->tc_fix_data
.info
->psym
= fixup
->procsym
;
1944 if ((int) fixup
->reloc
< 0)
1946 if (operand
->flags
& AXP_OPERAND_NOOVERFLOW
)
1947 fixP
->fx_no_overflow
= 1;
1954 /* Insert an operand value into an instruction. */
1957 insert_operand (unsigned insn
,
1958 const struct alpha_operand
*operand
,
1963 if (operand
->bits
!= 32 && !(operand
->flags
& AXP_OPERAND_NOOVERFLOW
))
1967 if (operand
->flags
& AXP_OPERAND_SIGNED
)
1969 max
= (1 << (operand
->bits
- 1)) - 1;
1970 min
= -(1 << (operand
->bits
- 1));
1974 max
= (1 << operand
->bits
) - 1;
1978 if (val
< min
|| val
> max
)
1979 as_warn_value_out_of_range (_("operand"), val
, min
, max
, file
, line
);
1982 if (operand
->insert
)
1984 const char *errmsg
= NULL
;
1986 insn
= (*operand
->insert
) (insn
, val
, &errmsg
);
1991 insn
|= ((val
& ((1 << operand
->bits
) - 1)) << operand
->shift
);
1996 /* Turn an opcode description and a set of arguments into
1997 an instruction and a fixup. */
2000 assemble_insn (const struct alpha_opcode
*opcode
,
2001 const expressionS
*tok
,
2003 struct alpha_insn
*insn
,
2004 bfd_reloc_code_real_type reloc
)
2006 const struct alpha_operand
*reloc_operand
= NULL
;
2007 const expressionS
*reloc_exp
= NULL
;
2008 const unsigned char *argidx
;
2012 memset (insn
, 0, sizeof (*insn
));
2013 image
= opcode
->opcode
;
2015 for (argidx
= opcode
->operands
; *argidx
; ++argidx
)
2017 const struct alpha_operand
*operand
= &alpha_operands
[*argidx
];
2018 const expressionS
*t
= (const expressionS
*) 0;
2020 if (operand
->flags
& AXP_OPERAND_FAKE
)
2022 /* Fake operands take no value and generate no fixup. */
2023 image
= insert_operand (image
, operand
, 0, NULL
, 0);
2029 switch (operand
->flags
& AXP_OPERAND_OPTIONAL_MASK
)
2031 case AXP_OPERAND_DEFAULT_FIRST
:
2034 case AXP_OPERAND_DEFAULT_SECOND
:
2037 case AXP_OPERAND_DEFAULT_ZERO
:
2039 static expressionS zero_exp
;
2041 zero_exp
.X_op
= O_constant
;
2042 zero_exp
.X_unsigned
= 1;
2057 image
= insert_operand (image
, operand
, regno (t
->X_add_number
),
2062 image
= insert_operand (image
, operand
, t
->X_add_number
, NULL
, 0);
2063 assert (reloc_operand
== NULL
);
2064 reloc_operand
= operand
;
2069 /* This is only 0 for fields that should contain registers,
2070 which means this pattern shouldn't have matched. */
2071 if (operand
->default_reloc
== 0)
2074 /* There is one special case for which an insn receives two
2075 relocations, and thus the user-supplied reloc does not
2076 override the operand reloc. */
2077 if (operand
->default_reloc
== BFD_RELOC_ALPHA_HINT
)
2079 struct alpha_fixup
*fixup
;
2081 if (insn
->nfixups
>= MAX_INSN_FIXUPS
)
2082 as_fatal (_("too many fixups"));
2084 fixup
= &insn
->fixups
[insn
->nfixups
++];
2086 fixup
->reloc
= BFD_RELOC_ALPHA_HINT
;
2090 if (reloc
== BFD_RELOC_UNUSED
)
2091 reloc
= operand
->default_reloc
;
2093 assert (reloc_operand
== NULL
);
2094 reloc_operand
= operand
;
2101 if (reloc
!= BFD_RELOC_UNUSED
)
2103 struct alpha_fixup
*fixup
;
2105 if (insn
->nfixups
>= MAX_INSN_FIXUPS
)
2106 as_fatal (_("too many fixups"));
2108 /* ??? My but this is hacky. But the OSF/1 assembler uses the same
2109 relocation tag for both ldah and lda with gpdisp. Choose the
2110 correct internal relocation based on the opcode. */
2111 if (reloc
== BFD_RELOC_ALPHA_GPDISP
)
2113 if (strcmp (opcode
->name
, "ldah") == 0)
2114 reloc
= BFD_RELOC_ALPHA_GPDISP_HI16
;
2115 else if (strcmp (opcode
->name
, "lda") == 0)
2116 reloc
= BFD_RELOC_ALPHA_GPDISP_LO16
;
2118 as_bad (_("invalid relocation for instruction"));
2121 /* If this is a real relocation (as opposed to a lituse hint), then
2122 the relocation width should match the operand width.
2123 Take care of -MDISP in operand table. */
2124 else if (reloc
< BFD_RELOC_UNUSED
&& reloc
> 0)
2126 reloc_howto_type
*reloc_howto
2127 = bfd_reloc_type_lookup (stdoutput
, reloc
);
2128 if (reloc_operand
== NULL
2129 || reloc_howto
->bitsize
!= reloc_operand
->bits
)
2131 as_bad (_("invalid relocation for field"));
2136 fixup
= &insn
->fixups
[insn
->nfixups
++];
2138 fixup
->exp
= *reloc_exp
;
2140 fixup
->exp
.X_op
= O_absent
;
2141 fixup
->reloc
= reloc
;
2147 /* Handle all "simple" integer register loads -- ldq, ldq_l, ldq_u,
2148 etc. They differ from the real instructions in that they do simple
2149 expressions like the lda macro. */
2152 emit_ir_load (const expressionS
*tok
,
2154 const void * opname
)
2158 expressionS newtok
[3];
2159 struct alpha_insn insn
;
2161 = tok
[1].X_add_symbol
? S_GET_NAME (tok
[1].X_add_symbol
): "";
2162 int symlen
= strlen (symname
);
2165 basereg
= (tok
[1].X_op
== O_constant
? AXP_REG_ZERO
: alpha_gp_register
);
2167 basereg
= tok
[2].X_add_number
;
2169 lituse
= load_expression (tok
[0].X_add_number
, &tok
[1],
2170 &basereg
, &newtok
[1], opname
);
2172 if (basereg
== alpha_gp_register
&&
2173 (symlen
> 4 && strcmp (&symname
[symlen
- 4], "..lk") == 0))
2177 set_tok_preg (newtok
[2], basereg
);
2179 assemble_tokens_to_insn ((const char *) opname
, newtok
, 3, &insn
);
2183 assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2184 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2185 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2187 insn
.sequence
= lituse
;
2193 /* Handle fp register loads, and both integer and fp register stores.
2194 Again, we handle simple expressions. */
2197 emit_loadstore (const expressionS
*tok
,
2199 const void * opname
)
2203 expressionS newtok
[3];
2204 struct alpha_insn insn
;
2207 basereg
= (tok
[1].X_op
== O_constant
? AXP_REG_ZERO
: alpha_gp_register
);
2209 basereg
= tok
[2].X_add_number
;
2211 if (tok
[1].X_op
!= O_constant
|| !range_signed_16 (tok
[1].X_add_number
))
2214 as_bad (_("macro requires $at register while noat in effect"));
2216 lituse
= load_expression (AXP_REG_AT
, &tok
[1],
2217 &basereg
, &newtok
[1], opname
);
2226 set_tok_preg (newtok
[2], basereg
);
2228 assemble_tokens_to_insn ((const char *) opname
, newtok
, 3, &insn
);
2232 assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2233 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2234 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2236 insn
.sequence
= lituse
;
2242 /* Load a half-word or byte as an unsigned value. */
2245 emit_ldXu (const expressionS
*tok
,
2247 const void * vlgsize
)
2249 if (alpha_target
& AXP_OPCODE_BWX
)
2250 emit_ir_load (tok
, ntok
, ldXu_op
[(long) vlgsize
]);
2253 expressionS newtok
[3];
2254 struct alpha_insn insn
;
2259 as_bad (_("macro requires $at register while noat in effect"));
2262 basereg
= (tok
[1].X_op
== O_constant
2263 ? AXP_REG_ZERO
: alpha_gp_register
);
2265 basereg
= tok
[2].X_add_number
;
2267 /* Emit "lda $at, exp". */
2268 lituse
= load_expression (AXP_REG_AT
, &tok
[1], &basereg
, NULL
, "lda");
2270 /* Emit "ldq_u targ, 0($at)". */
2272 set_tok_const (newtok
[1], 0);
2273 set_tok_preg (newtok
[2], basereg
);
2274 assemble_tokens_to_insn ("ldq_u", newtok
, 3, &insn
);
2278 assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2279 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2280 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2282 insn
.sequence
= lituse
;
2287 /* Emit "extXl targ, $at, targ". */
2288 set_tok_reg (newtok
[1], basereg
);
2289 newtok
[2] = newtok
[0];
2290 assemble_tokens_to_insn (extXl_op
[(long) vlgsize
], newtok
, 3, &insn
);
2294 assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2295 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BYTOFF
;
2296 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2298 insn
.sequence
= lituse
;
2305 /* Load a half-word or byte as a signed value. */
2308 emit_ldX (const expressionS
*tok
,
2310 const void * vlgsize
)
2312 emit_ldXu (tok
, ntok
, vlgsize
);
2313 assemble_tokens (sextX_op
[(long) vlgsize
], tok
, 1, 1);
2316 /* Load an integral value from an unaligned address as an unsigned
2320 emit_uldXu (const expressionS
*tok
,
2322 const void * vlgsize
)
2324 long lgsize
= (long) vlgsize
;
2325 expressionS newtok
[3];
2328 as_bad (_("macro requires $at register while noat in effect"));
2330 /* Emit "lda $at, exp". */
2331 memcpy (newtok
, tok
, sizeof (expressionS
) * ntok
);
2332 newtok
[0].X_add_number
= AXP_REG_AT
;
2333 assemble_tokens ("lda", newtok
, ntok
, 1);
2335 /* Emit "ldq_u $t9, 0($at)". */
2336 set_tok_reg (newtok
[0], AXP_REG_T9
);
2337 set_tok_const (newtok
[1], 0);
2338 set_tok_preg (newtok
[2], AXP_REG_AT
);
2339 assemble_tokens ("ldq_u", newtok
, 3, 1);
2341 /* Emit "ldq_u $t10, size-1($at)". */
2342 set_tok_reg (newtok
[0], AXP_REG_T10
);
2343 set_tok_const (newtok
[1], (1 << lgsize
) - 1);
2344 assemble_tokens ("ldq_u", newtok
, 3, 1);
2346 /* Emit "extXl $t9, $at, $t9". */
2347 set_tok_reg (newtok
[0], AXP_REG_T9
);
2348 set_tok_reg (newtok
[1], AXP_REG_AT
);
2349 set_tok_reg (newtok
[2], AXP_REG_T9
);
2350 assemble_tokens (extXl_op
[lgsize
], newtok
, 3, 1);
2352 /* Emit "extXh $t10, $at, $t10". */
2353 set_tok_reg (newtok
[0], AXP_REG_T10
);
2354 set_tok_reg (newtok
[2], AXP_REG_T10
);
2355 assemble_tokens (extXh_op
[lgsize
], newtok
, 3, 1);
2357 /* Emit "or $t9, $t10, targ". */
2358 set_tok_reg (newtok
[0], AXP_REG_T9
);
2359 set_tok_reg (newtok
[1], AXP_REG_T10
);
2361 assemble_tokens ("or", newtok
, 3, 1);
2364 /* Load an integral value from an unaligned address as a signed value.
2365 Note that quads should get funneled to the unsigned load since we
2366 don't have to do the sign extension. */
2369 emit_uldX (const expressionS
*tok
,
2371 const void * vlgsize
)
2373 emit_uldXu (tok
, ntok
, vlgsize
);
2374 assemble_tokens (sextX_op
[(long) vlgsize
], tok
, 1, 1);
2377 /* Implement the ldil macro. */
2380 emit_ldil (const expressionS
*tok
,
2382 const void * unused ATTRIBUTE_UNUSED
)
2384 expressionS newtok
[2];
2386 memcpy (newtok
, tok
, sizeof (newtok
));
2387 newtok
[1].X_add_number
= sign_extend_32 (tok
[1].X_add_number
);
2389 assemble_tokens ("lda", newtok
, ntok
, 1);
2392 /* Store a half-word or byte. */
2395 emit_stX (const expressionS
*tok
,
2397 const void * vlgsize
)
2399 int lgsize
= (int) (long) vlgsize
;
2401 if (alpha_target
& AXP_OPCODE_BWX
)
2402 emit_loadstore (tok
, ntok
, stX_op
[lgsize
]);
2405 expressionS newtok
[3];
2406 struct alpha_insn insn
;
2411 as_bad (_("macro requires $at register while noat in effect"));
2414 basereg
= (tok
[1].X_op
== O_constant
2415 ? AXP_REG_ZERO
: alpha_gp_register
);
2417 basereg
= tok
[2].X_add_number
;
2419 /* Emit "lda $at, exp". */
2420 lituse
= load_expression (AXP_REG_AT
, &tok
[1], &basereg
, NULL
, "lda");
2422 /* Emit "ldq_u $t9, 0($at)". */
2423 set_tok_reg (newtok
[0], AXP_REG_T9
);
2424 set_tok_const (newtok
[1], 0);
2425 set_tok_preg (newtok
[2], basereg
);
2426 assemble_tokens_to_insn ("ldq_u", newtok
, 3, &insn
);
2430 assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2431 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2432 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2434 insn
.sequence
= lituse
;
2439 /* Emit "insXl src, $at, $t10". */
2441 set_tok_reg (newtok
[1], basereg
);
2442 set_tok_reg (newtok
[2], AXP_REG_T10
);
2443 assemble_tokens_to_insn (insXl_op
[lgsize
], newtok
, 3, &insn
);
2447 assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2448 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BYTOFF
;
2449 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2451 insn
.sequence
= lituse
;
2456 /* Emit "mskXl $t9, $at, $t9". */
2457 set_tok_reg (newtok
[0], AXP_REG_T9
);
2458 newtok
[2] = newtok
[0];
2459 assemble_tokens_to_insn (mskXl_op
[lgsize
], newtok
, 3, &insn
);
2463 assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2464 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BYTOFF
;
2465 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2467 insn
.sequence
= lituse
;
2472 /* Emit "or $t9, $t10, $t9". */
2473 set_tok_reg (newtok
[1], AXP_REG_T10
);
2474 assemble_tokens ("or", newtok
, 3, 1);
2476 /* Emit "stq_u $t9, 0($at). */
2477 set_tok_const(newtok
[1], 0);
2478 set_tok_preg (newtok
[2], AXP_REG_AT
);
2479 assemble_tokens_to_insn ("stq_u", newtok
, 3, &insn
);
2483 assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2484 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_BASE
;
2485 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2487 insn
.sequence
= lituse
;
2494 /* Store an integer to an unaligned address. */
2497 emit_ustX (const expressionS
*tok
,
2499 const void * vlgsize
)
2501 int lgsize
= (int) (long) vlgsize
;
2502 expressionS newtok
[3];
2504 /* Emit "lda $at, exp". */
2505 memcpy (newtok
, tok
, sizeof (expressionS
) * ntok
);
2506 newtok
[0].X_add_number
= AXP_REG_AT
;
2507 assemble_tokens ("lda", newtok
, ntok
, 1);
2509 /* Emit "ldq_u $9, 0($at)". */
2510 set_tok_reg (newtok
[0], AXP_REG_T9
);
2511 set_tok_const (newtok
[1], 0);
2512 set_tok_preg (newtok
[2], AXP_REG_AT
);
2513 assemble_tokens ("ldq_u", newtok
, 3, 1);
2515 /* Emit "ldq_u $10, size-1($at)". */
2516 set_tok_reg (newtok
[0], AXP_REG_T10
);
2517 set_tok_const (newtok
[1], (1 << lgsize
) - 1);
2518 assemble_tokens ("ldq_u", newtok
, 3, 1);
2520 /* Emit "insXl src, $at, $t11". */
2522 set_tok_reg (newtok
[1], AXP_REG_AT
);
2523 set_tok_reg (newtok
[2], AXP_REG_T11
);
2524 assemble_tokens (insXl_op
[lgsize
], newtok
, 3, 1);
2526 /* Emit "insXh src, $at, $t12". */
2527 set_tok_reg (newtok
[2], AXP_REG_T12
);
2528 assemble_tokens (insXh_op
[lgsize
], newtok
, 3, 1);
2530 /* Emit "mskXl $t9, $at, $t9". */
2531 set_tok_reg (newtok
[0], AXP_REG_T9
);
2532 newtok
[2] = newtok
[0];
2533 assemble_tokens (mskXl_op
[lgsize
], newtok
, 3, 1);
2535 /* Emit "mskXh $t10, $at, $t10". */
2536 set_tok_reg (newtok
[0], AXP_REG_T10
);
2537 newtok
[2] = newtok
[0];
2538 assemble_tokens (mskXh_op
[lgsize
], newtok
, 3, 1);
2540 /* Emit "or $t9, $t11, $t9". */
2541 set_tok_reg (newtok
[0], AXP_REG_T9
);
2542 set_tok_reg (newtok
[1], AXP_REG_T11
);
2543 newtok
[2] = newtok
[0];
2544 assemble_tokens ("or", newtok
, 3, 1);
2546 /* Emit "or $t10, $t12, $t10". */
2547 set_tok_reg (newtok
[0], AXP_REG_T10
);
2548 set_tok_reg (newtok
[1], AXP_REG_T12
);
2549 newtok
[2] = newtok
[0];
2550 assemble_tokens ("or", newtok
, 3, 1);
2552 /* Emit "stq_u $t10, size-1($at)". */
2553 set_tok_reg (newtok
[0], AXP_REG_T10
);
2554 set_tok_const (newtok
[1], (1 << lgsize
) - 1);
2555 set_tok_preg (newtok
[2], AXP_REG_AT
);
2556 assemble_tokens ("stq_u", newtok
, 3, 1);
2558 /* Emit "stq_u $t9, 0($at)". */
2559 set_tok_reg (newtok
[0], AXP_REG_T9
);
2560 set_tok_const (newtok
[1], 0);
2561 assemble_tokens ("stq_u", newtok
, 3, 1);
2564 /* Sign extend a half-word or byte. The 32-bit sign extend is
2565 implemented as "addl $31, $r, $t" in the opcode table. */
2568 emit_sextX (const expressionS
*tok
,
2570 const void * vlgsize
)
2572 long lgsize
= (long) vlgsize
;
2574 if (alpha_target
& AXP_OPCODE_BWX
)
2575 assemble_tokens (sextX_op
[lgsize
], tok
, ntok
, 0);
2578 int bitshift
= 64 - 8 * (1 << lgsize
);
2579 expressionS newtok
[3];
2581 /* Emit "sll src,bits,dst". */
2583 set_tok_const (newtok
[1], bitshift
);
2584 newtok
[2] = tok
[ntok
- 1];
2585 assemble_tokens ("sll", newtok
, 3, 1);
2587 /* Emit "sra dst,bits,dst". */
2588 newtok
[0] = newtok
[2];
2589 assemble_tokens ("sra", newtok
, 3, 1);
2593 /* Implement the division and modulus macros. */
2597 /* Make register usage like in normal procedure call.
2598 Don't clobber PV and RA. */
2601 emit_division (const expressionS
*tok
,
2603 const void * symname
)
2605 /* DIVISION and MODULUS. Yech.
2610 mov x,R16 # if x != R16
2611 mov y,R17 # if y != R17
2616 with appropriate optimizations if R0,R16,R17 are the registers
2617 specified by the compiler. */
2621 expressionS newtok
[3];
2623 xr
= regno (tok
[0].X_add_number
);
2624 yr
= regno (tok
[1].X_add_number
);
2629 rr
= regno (tok
[2].X_add_number
);
2631 /* Move the operands into the right place. */
2632 if (yr
== AXP_REG_R16
&& xr
== AXP_REG_R17
)
2634 /* They are in exactly the wrong order -- swap through AT. */
2636 as_bad (_("macro requires $at register while noat in effect"));
2638 set_tok_reg (newtok
[0], AXP_REG_R16
);
2639 set_tok_reg (newtok
[1], AXP_REG_AT
);
2640 assemble_tokens ("mov", newtok
, 2, 1);
2642 set_tok_reg (newtok
[0], AXP_REG_R17
);
2643 set_tok_reg (newtok
[1], AXP_REG_R16
);
2644 assemble_tokens ("mov", newtok
, 2, 1);
2646 set_tok_reg (newtok
[0], AXP_REG_AT
);
2647 set_tok_reg (newtok
[1], AXP_REG_R17
);
2648 assemble_tokens ("mov", newtok
, 2, 1);
2652 if (yr
== AXP_REG_R16
)
2654 set_tok_reg (newtok
[0], AXP_REG_R16
);
2655 set_tok_reg (newtok
[1], AXP_REG_R17
);
2656 assemble_tokens ("mov", newtok
, 2, 1);
2659 if (xr
!= AXP_REG_R16
)
2661 set_tok_reg (newtok
[0], xr
);
2662 set_tok_reg (newtok
[1], AXP_REG_R16
);
2663 assemble_tokens ("mov", newtok
, 2, 1);
2666 if (yr
!= AXP_REG_R16
&& yr
!= AXP_REG_R17
)
2668 set_tok_reg (newtok
[0], yr
);
2669 set_tok_reg (newtok
[1], AXP_REG_R17
);
2670 assemble_tokens ("mov", newtok
, 2, 1);
2674 sym
= symbol_find_or_make ((const char *) symname
);
2676 set_tok_reg (newtok
[0], AXP_REG_AT
);
2677 set_tok_sym (newtok
[1], sym
, 0);
2678 assemble_tokens ("lda", newtok
, 2, 1);
2680 /* Call the division routine. */
2681 set_tok_reg (newtok
[0], AXP_REG_AT
);
2682 set_tok_cpreg (newtok
[1], AXP_REG_AT
);
2683 set_tok_const (newtok
[2], 0);
2684 assemble_tokens ("jsr", newtok
, 3, 1);
2686 /* Move the result to the right place. */
2687 if (rr
!= AXP_REG_R0
)
2689 set_tok_reg (newtok
[0], AXP_REG_R0
);
2690 set_tok_reg (newtok
[1], rr
);
2691 assemble_tokens ("mov", newtok
, 2, 1);
2695 #else /* !OBJ_EVAX */
2698 emit_division (const expressionS
*tok
,
2700 const void * symname
)
2702 /* DIVISION and MODULUS. Yech.
2712 with appropriate optimizations if t10,t11,t12 are the registers
2713 specified by the compiler. */
2717 expressionS newtok
[3];
2719 xr
= regno (tok
[0].X_add_number
);
2720 yr
= regno (tok
[1].X_add_number
);
2725 rr
= regno (tok
[2].X_add_number
);
2727 sym
= symbol_find_or_make ((const char *) symname
);
2729 /* Move the operands into the right place. */
2730 if (yr
== AXP_REG_T10
&& xr
== AXP_REG_T11
)
2732 /* They are in exactly the wrong order -- swap through AT. */
2734 as_bad (_("macro requires $at register while noat in effect"));
2736 set_tok_reg (newtok
[0], AXP_REG_T10
);
2737 set_tok_reg (newtok
[1], AXP_REG_AT
);
2738 assemble_tokens ("mov", newtok
, 2, 1);
2740 set_tok_reg (newtok
[0], AXP_REG_T11
);
2741 set_tok_reg (newtok
[1], AXP_REG_T10
);
2742 assemble_tokens ("mov", newtok
, 2, 1);
2744 set_tok_reg (newtok
[0], AXP_REG_AT
);
2745 set_tok_reg (newtok
[1], AXP_REG_T11
);
2746 assemble_tokens ("mov", newtok
, 2, 1);
2750 if (yr
== AXP_REG_T10
)
2752 set_tok_reg (newtok
[0], AXP_REG_T10
);
2753 set_tok_reg (newtok
[1], AXP_REG_T11
);
2754 assemble_tokens ("mov", newtok
, 2, 1);
2757 if (xr
!= AXP_REG_T10
)
2759 set_tok_reg (newtok
[0], xr
);
2760 set_tok_reg (newtok
[1], AXP_REG_T10
);
2761 assemble_tokens ("mov", newtok
, 2, 1);
2764 if (yr
!= AXP_REG_T10
&& yr
!= AXP_REG_T11
)
2766 set_tok_reg (newtok
[0], yr
);
2767 set_tok_reg (newtok
[1], AXP_REG_T11
);
2768 assemble_tokens ("mov", newtok
, 2, 1);
2772 /* Call the division routine. */
2773 set_tok_reg (newtok
[0], AXP_REG_T9
);
2774 set_tok_sym (newtok
[1], sym
, 0);
2775 assemble_tokens ("jsr", newtok
, 2, 1);
2777 /* Reload the GP register. */
2781 #if defined(OBJ_ECOFF) || defined(OBJ_ELF)
2782 set_tok_reg (newtok
[0], alpha_gp_register
);
2783 set_tok_const (newtok
[1], 0);
2784 set_tok_preg (newtok
[2], AXP_REG_T9
);
2785 assemble_tokens ("ldgp", newtok
, 3, 1);
2788 /* Move the result to the right place. */
2789 if (rr
!= AXP_REG_T12
)
2791 set_tok_reg (newtok
[0], AXP_REG_T12
);
2792 set_tok_reg (newtok
[1], rr
);
2793 assemble_tokens ("mov", newtok
, 2, 1);
2797 #endif /* !OBJ_EVAX */
2799 /* The jsr and jmp macros differ from their instruction counterparts
2800 in that they can load the target address and default most
2804 emit_jsrjmp (const expressionS
*tok
,
2806 const void * vopname
)
2808 const char *opname
= (const char *) vopname
;
2809 struct alpha_insn insn
;
2810 expressionS newtok
[3];
2814 if (tokidx
< ntok
&& tok
[tokidx
].X_op
== O_register
)
2815 r
= regno (tok
[tokidx
++].X_add_number
);
2817 r
= strcmp (opname
, "jmp") == 0 ? AXP_REG_ZERO
: AXP_REG_RA
;
2819 set_tok_reg (newtok
[0], r
);
2821 if (tokidx
< ntok
&&
2822 (tok
[tokidx
].X_op
== O_pregister
|| tok
[tokidx
].X_op
== O_cpregister
))
2823 r
= regno (tok
[tokidx
++].X_add_number
);
2825 /* Keep register if jsr $n.<sym>. */
2829 int basereg
= alpha_gp_register
;
2830 lituse
= load_expression (r
= AXP_REG_PV
, &tok
[tokidx
],
2831 &basereg
, NULL
, opname
);
2835 set_tok_cpreg (newtok
[1], r
);
2839 newtok
[2] = tok
[tokidx
];
2842 set_tok_const (newtok
[2], 0);
2844 assemble_tokens_to_insn (opname
, newtok
, 3, &insn
);
2848 assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2849 insn
.fixups
[insn
.nfixups
].reloc
= DUMMY_RELOC_LITUSE_JSR
;
2850 insn
.fixups
[insn
.nfixups
].exp
.X_op
= O_absent
;
2852 insn
.sequence
= lituse
;
2856 if (alpha_flag_replace
2858 && tok
[tokidx
].X_add_symbol
2859 && alpha_linkage_symbol
)
2861 const char *symname
= S_GET_NAME (tok
[tokidx
].X_add_symbol
);
2862 int symlen
= strlen (symname
);
2865 ensymname
= (char *) xmalloc (symlen
+ 5);
2866 memcpy (ensymname
, symname
, symlen
);
2867 memcpy (ensymname
+ symlen
, "..en", 5);
2869 assert (insn
.nfixups
< MAX_INSN_FIXUPS
);
2870 if (insn
.nfixups
> 0)
2872 memmove (&insn
.fixups
[1], &insn
.fixups
[0],
2873 sizeof(struct alpha_fixup
) * insn
.nfixups
);
2876 /* The fixup must be the same as the BFD_RELOC_ALPHA_NOP
2877 case in load_expression. See B.4.5.2 of the OpenVMS
2878 Linker Utility Manual. */
2879 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_BOH
;
2880 insn
.fixups
[0].exp
.X_op
= O_symbol
;
2881 insn
.fixups
[0].exp
.X_add_symbol
= symbol_find_or_make (ensymname
);
2882 insn
.fixups
[0].exp
.X_add_number
= 0;
2883 insn
.fixups
[0].xtrasym
= alpha_linkage_symbol
;
2884 insn
.fixups
[0].procsym
= alpha_evax_proc
->symbol
;
2886 alpha_linkage_symbol
= 0;
2893 /* The ret and jcr instructions differ from their instruction
2894 counterparts in that everything can be defaulted. */
2897 emit_retjcr (const expressionS
*tok
,
2899 const void * vopname
)
2901 const char *opname
= (const char *) vopname
;
2902 expressionS newtok
[3];
2905 if (tokidx
< ntok
&& tok
[tokidx
].X_op
== O_register
)
2906 r
= regno (tok
[tokidx
++].X_add_number
);
2910 set_tok_reg (newtok
[0], r
);
2912 if (tokidx
< ntok
&&
2913 (tok
[tokidx
].X_op
== O_pregister
|| tok
[tokidx
].X_op
== O_cpregister
))
2914 r
= regno (tok
[tokidx
++].X_add_number
);
2918 set_tok_cpreg (newtok
[1], r
);
2921 newtok
[2] = tok
[tokidx
];
2923 set_tok_const (newtok
[2], strcmp (opname
, "ret") == 0);
2925 assemble_tokens (opname
, newtok
, 3, 0);
2928 /* Implement the ldgp macro. */
2931 emit_ldgp (const expressionS
*tok
,
2932 int ntok ATTRIBUTE_UNUSED
,
2933 const void * unused ATTRIBUTE_UNUSED
)
2938 #if defined(OBJ_ECOFF) || defined(OBJ_ELF)
2939 /* from "ldgp r1,n(r2)", generate "ldah r1,X(R2); lda r1,Y(r1)"
2940 with appropriate constants and relocations. */
2941 struct alpha_insn insn
;
2942 expressionS newtok
[3];
2946 if (regno (tok
[2].X_add_number
) == AXP_REG_PV
)
2947 ecoff_set_gp_prolog_size (0);
2951 set_tok_const (newtok
[1], 0);
2954 assemble_tokens_to_insn ("ldah", newtok
, 3, &insn
);
2959 if (addend
.X_op
!= O_constant
)
2960 as_bad (_("can not resolve expression"));
2961 addend
.X_op
= O_symbol
;
2962 addend
.X_add_symbol
= alpha_gp_symbol
;
2966 insn
.fixups
[0].exp
= addend
;
2967 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_GPDISP_HI16
;
2968 insn
.sequence
= next_sequence_num
;
2972 set_tok_preg (newtok
[2], tok
[0].X_add_number
);
2974 assemble_tokens_to_insn ("lda", newtok
, 3, &insn
);
2977 addend
.X_add_number
+= 4;
2981 insn
.fixups
[0].exp
= addend
;
2982 insn
.fixups
[0].reloc
= BFD_RELOC_ALPHA_GPDISP_LO16
;
2983 insn
.sequence
= next_sequence_num
--;
2986 #else /* OBJ_ECOFF || OBJ_ELF */
2987 /* Avoid warning. */
2992 /* The macro table. */
2994 static const struct alpha_macro alpha_macros
[] =
2996 /* Load/Store macros. */
2997 { "lda", emit_lda
, NULL
,
2998 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
2999 { "ldah", emit_ldah
, NULL
,
3000 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
} },
3002 { "ldl", emit_ir_load
, "ldl",
3003 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3004 { "ldl_l", emit_ir_load
, "ldl_l",
3005 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3006 { "ldq", emit_ir_load
, "ldq",
3007 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3008 { "ldq_l", emit_ir_load
, "ldq_l",
3009 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3010 { "ldq_u", emit_ir_load
, "ldq_u",
3011 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3012 { "ldf", emit_loadstore
, "ldf",
3013 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3014 { "ldg", emit_loadstore
, "ldg",
3015 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3016 { "lds", emit_loadstore
, "lds",
3017 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3018 { "ldt", emit_loadstore
, "ldt",
3019 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3021 { "ldb", emit_ldX
, (void *) 0,
3022 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3023 { "ldbu", emit_ldXu
, (void *) 0,
3024 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3025 { "ldw", emit_ldX
, (void *) 1,
3026 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3027 { "ldwu", emit_ldXu
, (void *) 1,
3028 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3030 { "uldw", emit_uldX
, (void *) 1,
3031 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3032 { "uldwu", emit_uldXu
, (void *) 1,
3033 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3034 { "uldl", emit_uldX
, (void *) 2,
3035 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3036 { "uldlu", emit_uldXu
, (void *) 2,
3037 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3038 { "uldq", emit_uldXu
, (void *) 3,
3039 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3041 { "ldgp", emit_ldgp
, NULL
,
3042 { MACRO_IR
, MACRO_EXP
, MACRO_PIR
, MACRO_EOA
} },
3044 { "ldi", emit_lda
, NULL
,
3045 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
} },
3046 { "ldil", emit_ldil
, NULL
,
3047 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
} },
3048 { "ldiq", emit_lda
, NULL
,
3049 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
} },
3051 { "stl", emit_loadstore
, "stl",
3052 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3053 { "stl_c", emit_loadstore
, "stl_c",
3054 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3055 { "stq", emit_loadstore
, "stq",
3056 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3057 { "stq_c", emit_loadstore
, "stq_c",
3058 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3059 { "stq_u", emit_loadstore
, "stq_u",
3060 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3061 { "stf", emit_loadstore
, "stf",
3062 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3063 { "stg", emit_loadstore
, "stg",
3064 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3065 { "sts", emit_loadstore
, "sts",
3066 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3067 { "stt", emit_loadstore
, "stt",
3068 { MACRO_FPR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3070 { "stb", emit_stX
, (void *) 0,
3071 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3072 { "stw", emit_stX
, (void *) 1,
3073 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3074 { "ustw", emit_ustX
, (void *) 1,
3075 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3076 { "ustl", emit_ustX
, (void *) 2,
3077 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3078 { "ustq", emit_ustX
, (void *) 3,
3079 { MACRO_IR
, MACRO_EXP
, MACRO_OPIR
, MACRO_EOA
} },
3081 /* Arithmetic macros. */
3083 { "sextb", emit_sextX
, (void *) 0,
3084 { MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3085 MACRO_IR
, MACRO_EOA
,
3086 /* MACRO_EXP, MACRO_IR, MACRO_EOA */ } },
3087 { "sextw", emit_sextX
, (void *) 1,
3088 { MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3089 MACRO_IR
, MACRO_EOA
,
3090 /* MACRO_EXP, MACRO_IR, MACRO_EOA */ } },
3092 { "divl", emit_division
, "__divl",
3093 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3094 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3095 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3096 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3097 { "divlu", emit_division
, "__divlu",
3098 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3099 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3100 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3101 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3102 { "divq", emit_division
, "__divq",
3103 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3104 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3105 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3106 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3107 { "divqu", emit_division
, "__divqu",
3108 { MACRO_IR
, MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3109 MACRO_IR
, MACRO_IR
, MACRO_EOA
,
3110 /* MACRO_IR, MACRO_EXP, MACRO_IR, MACRO_EOA,
3111 MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
3112 { "reml", emit_division
, "__reml",
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 { "remlu", emit_division
, "__remlu",
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 { "remq", emit_division
, "__remq",
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 { "remqu", emit_division
, "__remqu",
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 */ } },
3133 { "jsr", emit_jsrjmp
, "jsr",
3134 { MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3135 MACRO_PIR
, MACRO_EOA
,
3136 MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3137 MACRO_EXP
, MACRO_EOA
} },
3138 { "jmp", emit_jsrjmp
, "jmp",
3139 { MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3140 MACRO_PIR
, MACRO_EOA
,
3141 MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3142 MACRO_EXP
, MACRO_EOA
} },
3143 { "ret", emit_retjcr
, "ret",
3144 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3145 MACRO_IR
, MACRO_EOA
,
3146 MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3147 MACRO_PIR
, MACRO_EOA
,
3148 MACRO_EXP
, MACRO_EOA
,
3150 { "jcr", emit_retjcr
, "jcr",
3151 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3152 MACRO_IR
, MACRO_EOA
,
3153 MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3154 MACRO_PIR
, MACRO_EOA
,
3155 MACRO_EXP
, MACRO_EOA
,
3157 { "jsr_coroutine", emit_retjcr
, "jcr",
3158 { MACRO_IR
, MACRO_EXP
, MACRO_EOA
,
3159 MACRO_IR
, MACRO_EOA
,
3160 MACRO_PIR
, MACRO_EXP
, MACRO_EOA
,
3161 MACRO_PIR
, MACRO_EOA
,
3162 MACRO_EXP
, MACRO_EOA
,
3166 static const unsigned int alpha_num_macros
3167 = sizeof (alpha_macros
) / sizeof (*alpha_macros
);
3169 /* Search forward through all variants of a macro looking for a syntax
3172 static const struct alpha_macro
*
3173 find_macro_match (const struct alpha_macro
*first_macro
,
3174 const expressionS
*tok
,
3178 const struct alpha_macro
*macro
= first_macro
;
3183 const enum alpha_macro_arg
*arg
= macro
->argsets
;
3197 /* Index register. */
3199 if (tokidx
>= ntok
|| tok
[tokidx
].X_op
!= O_register
3200 || !is_ir_num (tok
[tokidx
].X_add_number
))
3205 /* Parenthesized index register. */
3207 if (tokidx
>= ntok
|| tok
[tokidx
].X_op
!= O_pregister
3208 || !is_ir_num (tok
[tokidx
].X_add_number
))
3213 /* Optional parenthesized index register. */
3215 if (tokidx
< ntok
&& tok
[tokidx
].X_op
== O_pregister
3216 && is_ir_num (tok
[tokidx
].X_add_number
))
3220 /* Leading comma with a parenthesized index register. */
3222 if (tokidx
>= ntok
|| tok
[tokidx
].X_op
!= O_cpregister
3223 || !is_ir_num (tok
[tokidx
].X_add_number
))
3228 /* Floating point register. */
3230 if (tokidx
>= ntok
|| tok
[tokidx
].X_op
!= O_register
3231 || !is_fpr_num (tok
[tokidx
].X_add_number
))
3236 /* Normal expression. */
3240 switch (tok
[tokidx
].X_op
)
3249 case O_lituse_bytoff
:
3265 while (*arg
!= MACRO_EOA
)
3273 while (++macro
- alpha_macros
< (int) alpha_num_macros
3274 && !strcmp (macro
->name
, first_macro
->name
));
3279 /* Given an opcode name and a pre-tokenized set of arguments, take the
3280 opcode all the way through emission. */
3283 assemble_tokens (const char *opname
,
3284 const expressionS
*tok
,
3286 int local_macros_on
)
3288 int found_something
= 0;
3289 const struct alpha_opcode
*opcode
;
3290 const struct alpha_macro
*macro
;
3292 bfd_reloc_code_real_type reloc
= BFD_RELOC_UNUSED
;
3295 /* If a user-specified relocation is present, this is not a macro. */
3296 if (ntok
&& USER_RELOC_P (tok
[ntok
- 1].X_op
))
3298 reloc
= ALPHA_RELOC_TABLE (tok
[ntok
- 1].X_op
)->reloc
;
3303 if (local_macros_on
)
3305 macro
= ((const struct alpha_macro
*)
3306 hash_find (alpha_macro_hash
, opname
));
3309 found_something
= 1;
3310 macro
= find_macro_match (macro
, tok
, &ntok
);
3313 (*macro
->emit
) (tok
, ntok
, macro
->arg
);
3319 /* Search opcodes. */
3320 opcode
= (const struct alpha_opcode
*) hash_find (alpha_opcode_hash
, opname
);
3323 found_something
= 1;
3324 opcode
= find_opcode_match (opcode
, tok
, &ntok
, &cpumatch
);
3327 struct alpha_insn insn
;
3328 assemble_insn (opcode
, tok
, ntok
, &insn
, reloc
);
3330 /* Copy the sequence number for the reloc from the reloc token. */
3331 if (reloc
!= BFD_RELOC_UNUSED
)
3332 insn
.sequence
= tok
[ntok
].X_add_number
;
3339 if (found_something
)
3342 as_bad (_("inappropriate arguments for opcode `%s'"), opname
);
3344 as_bad (_("opcode `%s' not supported for target %s"), opname
,
3348 as_bad (_("unknown opcode `%s'"), opname
);
3353 /* Add symbol+addend to link pool.
3354 Return offset from basesym to entry in link pool.
3356 Add new fixup only if offset isn't 16bit. */
3359 add_to_link_pool (symbolS
*basesym
,
3363 segT current_section
= now_seg
;
3364 int current_subsec
= now_subseg
;
3367 segment_info_type
*seginfo
= seg_info (alpha_link_section
);
3369 symbolS
*linksym
, *expsym
;
3372 offset
= 0; /* ??? DBR */
3374 /* @@ This assumes all entries in a given section will be of the same
3375 size... Probably correct, but unwise to rely on. */
3376 /* This must always be called with the same subsegment. */
3378 if (seginfo
->frchainP
)
3379 for (fixp
= seginfo
->frchainP
->fix_root
;
3380 fixp
!= (fixS
*) NULL
;
3381 fixp
= fixp
->fx_next
)
3383 if (fixp
->tc_fix_data
.info
3384 && fixp
->tc_fix_data
.info
->sym
3385 && fixp
->tc_fix_data
.info
->sym
->sy_value
.X_op_symbol
== basesym
)
3388 if (fixp
->fx_addsy
== sym
3389 && fixp
->fx_offset
== (valueT
)addend
3390 && fixp
->tc_fix_data
.info
3391 && fixp
->tc_fix_data
.info
->sym
3392 && fixp
->tc_fix_data
.info
->sym
->sy_value
.X_op_symbol
== basesym
)
3393 return fixp
->tc_fix_data
.info
->sym
;
3396 /* Not found in 16bit signed range. */
3398 subseg_set (alpha_link_section
, 0);
3399 linksym
= symbol_new
3400 (FAKE_LABEL_NAME
, now_seg
, (valueT
) frag_now_fix (), frag_now
);
3404 e
.X_op
= O_subtract
;
3405 e
.X_add_symbol
= linksym
;
3406 e
.X_op_symbol
= basesym
;
3408 expsym
= make_expr_symbol (&e
);
3411 (frag_now
, p
-frag_now
->fr_literal
, 8, sym
, addend
, 0, BFD_RELOC_64
);
3412 fixp
->tc_fix_data
.info
= get_alpha_reloc_tag (next_sequence_num
--);
3413 fixp
->tc_fix_data
.info
->sym
= expsym
;
3415 subseg_set (current_section
, current_subsec
);
3416 seginfo
->literal_pool_size
+= 8;
3419 #endif /* OBJ_EVAX */
3421 /* Assembler directives. */
3423 /* Handle the .text pseudo-op. This is like the usual one, but it
3424 clears alpha_insn_label and restores auto alignment. */
3427 s_alpha_text (int i
)
3438 symbolP
= symbol_find (".text");
3439 if (symbolP
== NULL
)
3441 symbolP
= symbol_make (".text");
3442 S_SET_SEGMENT (symbolP
, text_section
);
3443 symbol_table_insert (symbolP
);
3447 alpha_insn_label
= NULL
;
3448 alpha_auto_align_on
= 1;
3449 alpha_current_align
= 0;
3452 /* Handle the .data pseudo-op. This is like the usual one, but it
3453 clears alpha_insn_label and restores auto alignment. */
3456 s_alpha_data (int i
)
3463 alpha_insn_label
= NULL
;
3464 alpha_auto_align_on
= 1;
3465 alpha_current_align
= 0;
3468 #if defined (OBJ_ECOFF) || defined (OBJ_EVAX)
3470 /* Handle the OSF/1 and openVMS .comm pseudo quirks. */
3473 s_alpha_comm (int ignore ATTRIBUTE_UNUSED
)
3485 name
= input_line_pointer
;
3486 c
= get_symbol_end ();
3488 /* Just after name is now '\0'. */
3489 p
= input_line_pointer
;
3494 /* Alpha OSF/1 compiler doesn't provide the comma, gcc does. */
3495 if (*input_line_pointer
== ',')
3497 input_line_pointer
++;
3500 if ((size
= get_absolute_expression ()) < 0)
3502 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size
);
3503 ignore_rest_of_line ();
3508 symbolP
= symbol_find_or_make (name
);
3511 if (S_IS_DEFINED (symbolP
) && ! S_IS_COMMON (symbolP
))
3513 as_bad (_("Ignoring attempt to re-define symbol"));
3514 ignore_rest_of_line ();
3519 if (*input_line_pointer
!= ',')
3520 temp
= 8; /* Default alignment. */
3523 input_line_pointer
++;
3525 temp
= get_absolute_expression ();
3528 /* ??? Unlike on OSF/1, the alignment factor is not in log units. */
3529 while ((temp
>>= 1) != 0)
3532 if (*input_line_pointer
== ',')
3534 /* Extended form of the directive
3536 .comm symbol, size, alignment, section
3538 where the "common" semantics is transferred to the section.
3539 The symbol is effectively an alias for the section name. */
3543 symbolS
*sec_symbol
;
3544 segT current_seg
= now_seg
;
3545 subsegT current_subseg
= now_subseg
;
3548 input_line_pointer
++;
3550 sec_name
= s_alpha_section_name ();
3551 sec_symbol
= symbol_find_or_make (sec_name
);
3552 sec
= subseg_new (sec_name
, 0);
3553 S_SET_SEGMENT (sec_symbol
, sec
);
3554 symbol_get_bfdsym (sec_symbol
)->flags
|= BSF_SECTION_SYM
;
3555 bfd_vms_set_section_flags (stdoutput
, sec
,
3556 EGPS_S_V_OVR
| EGPS_S_V_GBL
| EGPS_S_V_NOMOD
);
3557 record_alignment (sec
, log_align
);
3559 /* Reuse stab_string_size to store the size of the section. */
3560 cur_size
= seg_info (sec
)->stabu
.stab_string_size
;
3561 if ((int) size
> cur_size
)
3564 = frag_var (rs_fill
, 1, 1, (relax_substateT
)0, NULL
,
3565 (valueT
)size
- (valueT
)cur_size
, NULL
);
3567 seg_info (sec
)->stabu
.stab_string_size
= (int)size
;
3570 S_SET_SEGMENT (symbolP
, sec
);
3572 subseg_set (current_seg
, current_subseg
);
3576 /* Regular form of the directive
3578 .comm symbol, size, alignment
3580 where the "common" semantics in on the symbol.
3581 These symbols are assembled in the .bss section. */
3584 segT current_seg
= now_seg
;
3585 subsegT current_subseg
= now_subseg
;
3587 subseg_set (bss_section
, 1);
3588 frag_align (log_align
, 0, 0);
3589 record_alignment (bss_section
, log_align
);
3591 symbolP
->sy_frag
= frag_now
;
3592 pfrag
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
3596 S_SET_SEGMENT (symbolP
, bss_section
);
3598 subseg_set (current_seg
, current_subseg
);
3602 if (S_GET_VALUE (symbolP
))
3604 if (S_GET_VALUE (symbolP
) != (valueT
) size
)
3605 as_bad ("Length of .comm \"%s\" is already %ld. Not changed to %ld.",
3606 S_GET_NAME (symbolP
),
3607 (long) S_GET_VALUE (symbolP
),
3613 S_SET_VALUE (symbolP
, (valueT
) size
);
3615 S_SET_EXTERNAL (symbolP
);
3619 know (symbolP
->sy_frag
== &zero_address_frag
);
3621 demand_empty_rest_of_line ();
3624 #endif /* ! OBJ_ELF */
3628 /* Handle the .rdata pseudo-op. This is like the usual one, but it
3629 clears alpha_insn_label and restores auto alignment. */
3632 s_alpha_rdata (int ignore ATTRIBUTE_UNUSED
)
3636 temp
= get_absolute_expression ();
3637 subseg_new (".rdata", 0);
3638 demand_empty_rest_of_line ();
3639 alpha_insn_label
= NULL
;
3640 alpha_auto_align_on
= 1;
3641 alpha_current_align
= 0;
3648 /* Handle the .sdata pseudo-op. This is like the usual one, but it
3649 clears alpha_insn_label and restores auto alignment. */
3652 s_alpha_sdata (int ignore ATTRIBUTE_UNUSED
)
3656 temp
= get_absolute_expression ();
3657 subseg_new (".sdata", 0);
3658 demand_empty_rest_of_line ();
3659 alpha_insn_label
= NULL
;
3660 alpha_auto_align_on
= 1;
3661 alpha_current_align
= 0;
3666 struct alpha_elf_frame_data
3669 symbolS
*func_end_sym
;
3670 symbolS
*prologue_sym
;
3676 offsetT mask_offset
;
3677 offsetT fmask_offset
;
3679 struct alpha_elf_frame_data
*next
;
3682 static struct alpha_elf_frame_data
*all_frame_data
;
3683 static struct alpha_elf_frame_data
**plast_frame_data
= &all_frame_data
;
3684 static struct alpha_elf_frame_data
*cur_frame_data
;
3686 /* Handle the .section pseudo-op. This is like the usual one, but it
3687 clears alpha_insn_label and restores auto alignment. */
3690 s_alpha_section (int ignore ATTRIBUTE_UNUSED
)
3692 obj_elf_section (ignore
);
3694 alpha_insn_label
= NULL
;
3695 alpha_auto_align_on
= 1;
3696 alpha_current_align
= 0;
3700 s_alpha_ent (int dummy ATTRIBUTE_UNUSED
)
3702 if (ECOFF_DEBUGGING
)
3703 ecoff_directive_ent (0);
3706 char *name
, name_end
;
3707 name
= input_line_pointer
;
3708 name_end
= get_symbol_end ();
3710 if (! is_name_beginner (*name
))
3712 as_warn (_(".ent directive has no name"));
3713 *input_line_pointer
= name_end
;
3720 as_warn (_("nested .ent directives"));
3722 sym
= symbol_find_or_make (name
);
3723 symbol_get_bfdsym (sym
)->flags
|= BSF_FUNCTION
;
3725 cur_frame_data
= calloc (1, sizeof (*cur_frame_data
));
3726 cur_frame_data
->func_sym
= sym
;
3728 /* Provide sensible defaults. */
3729 cur_frame_data
->fp_regno
= 30; /* sp */
3730 cur_frame_data
->ra_regno
= 26; /* ra */
3732 *plast_frame_data
= cur_frame_data
;
3733 plast_frame_data
= &cur_frame_data
->next
;
3735 /* The .ent directive is sometimes followed by a number. Not sure
3736 what it really means, but ignore it. */
3737 *input_line_pointer
= name_end
;
3739 if (*input_line_pointer
== ',')
3741 input_line_pointer
++;
3744 if (ISDIGIT (*input_line_pointer
) || *input_line_pointer
== '-')
3745 (void) get_absolute_expression ();
3747 demand_empty_rest_of_line ();
3752 s_alpha_end (int dummy ATTRIBUTE_UNUSED
)
3754 if (ECOFF_DEBUGGING
)
3755 ecoff_directive_end (0);
3758 char *name
, name_end
;
3759 name
= input_line_pointer
;
3760 name_end
= get_symbol_end ();
3762 if (! is_name_beginner (*name
))
3764 as_warn (_(".end directive has no name"));
3765 *input_line_pointer
= name_end
;
3771 sym
= symbol_find (name
);
3772 if (!cur_frame_data
)
3773 as_warn (_(".end directive without matching .ent"));
3774 else if (sym
!= cur_frame_data
->func_sym
)
3775 as_warn (_(".end directive names different symbol than .ent"));
3777 /* Create an expression to calculate the size of the function. */
3778 if (sym
&& cur_frame_data
)
3780 OBJ_SYMFIELD_TYPE
*obj
= symbol_get_obj (sym
);
3781 expressionS
*exp
= xmalloc (sizeof (expressionS
));
3784 exp
->X_op
= O_subtract
;
3785 exp
->X_add_symbol
= symbol_temp_new_now ();
3786 exp
->X_op_symbol
= sym
;
3787 exp
->X_add_number
= 0;
3789 cur_frame_data
->func_end_sym
= exp
->X_add_symbol
;
3792 cur_frame_data
= NULL
;
3794 *input_line_pointer
= name_end
;
3796 demand_empty_rest_of_line ();
3801 s_alpha_mask (int fp
)
3803 if (ECOFF_DEBUGGING
)
3806 ecoff_directive_fmask (0);
3808 ecoff_directive_mask (0);
3815 if (!cur_frame_data
)
3818 as_warn (_(".fmask outside of .ent"));
3820 as_warn (_(".mask outside of .ent"));
3821 discard_rest_of_line ();
3825 if (get_absolute_expression_and_terminator (&val
) != ',')
3828 as_warn (_("bad .fmask directive"));
3830 as_warn (_("bad .mask directive"));
3831 --input_line_pointer
;
3832 discard_rest_of_line ();
3836 offset
= get_absolute_expression ();
3837 demand_empty_rest_of_line ();
3841 cur_frame_data
->fmask
= val
;
3842 cur_frame_data
->fmask_offset
= offset
;
3846 cur_frame_data
->mask
= val
;
3847 cur_frame_data
->mask_offset
= offset
;
3853 s_alpha_frame (int dummy ATTRIBUTE_UNUSED
)
3855 if (ECOFF_DEBUGGING
)
3856 ecoff_directive_frame (0);
3861 if (!cur_frame_data
)
3863 as_warn (_(".frame outside of .ent"));
3864 discard_rest_of_line ();
3868 cur_frame_data
->fp_regno
= tc_get_register (1);
3871 if (*input_line_pointer
++ != ','
3872 || get_absolute_expression_and_terminator (&val
) != ',')
3874 as_warn (_("bad .frame directive"));
3875 --input_line_pointer
;
3876 discard_rest_of_line ();
3879 cur_frame_data
->frame_size
= val
;
3881 cur_frame_data
->ra_regno
= tc_get_register (0);
3883 /* Next comes the "offset of saved $a0 from $sp". In gcc terms
3884 this is current_function_pretend_args_size. There's no place
3885 to put this value, so ignore it. */
3891 s_alpha_prologue (int ignore ATTRIBUTE_UNUSED
)
3896 arg
= get_absolute_expression ();
3897 demand_empty_rest_of_line ();
3898 alpha_prologue_label
= symbol_new
3899 (FAKE_LABEL_NAME
, now_seg
, (valueT
) frag_now_fix (), frag_now
);
3901 if (ECOFF_DEBUGGING
)
3902 sym
= ecoff_get_cur_proc_sym ();
3904 sym
= cur_frame_data
? cur_frame_data
->func_sym
: NULL
;
3908 as_bad (_(".prologue directive without a preceding .ent directive"));
3914 case 0: /* No PV required. */
3915 S_SET_OTHER (sym
, STO_ALPHA_NOPV
3916 | (S_GET_OTHER (sym
) & ~STO_ALPHA_STD_GPLOAD
));
3918 case 1: /* Std GP load. */
3919 S_SET_OTHER (sym
, STO_ALPHA_STD_GPLOAD
3920 | (S_GET_OTHER (sym
) & ~STO_ALPHA_STD_GPLOAD
));
3922 case 2: /* Non-std use of PV. */
3926 as_bad (_("Invalid argument %d to .prologue."), arg
);
3931 cur_frame_data
->prologue_sym
= symbol_temp_new_now ();
3934 static char *first_file_directive
;
3937 s_alpha_file (int ignore ATTRIBUTE_UNUSED
)
3939 /* Save the first .file directive we see, so that we can change our
3940 minds about whether ecoff debugging should or shouldn't be enabled. */
3941 if (alpha_flag_mdebug
< 0 && ! first_file_directive
)
3943 char *start
= input_line_pointer
;
3946 discard_rest_of_line ();
3948 len
= input_line_pointer
- start
;
3949 first_file_directive
= xmalloc (len
+ 1);
3950 memcpy (first_file_directive
, start
, len
);
3951 first_file_directive
[len
] = '\0';
3953 input_line_pointer
= start
;
3956 if (ECOFF_DEBUGGING
)
3957 ecoff_directive_file (0);
3959 dwarf2_directive_file (0);
3963 s_alpha_loc (int ignore ATTRIBUTE_UNUSED
)
3965 if (ECOFF_DEBUGGING
)
3966 ecoff_directive_loc (0);
3968 dwarf2_directive_loc (0);
3972 s_alpha_stab (int n
)
3974 /* If we've been undecided about mdebug, make up our minds in favour. */
3975 if (alpha_flag_mdebug
< 0)
3977 segT sec
= subseg_new (".mdebug", 0);
3978 bfd_set_section_flags (stdoutput
, sec
, SEC_HAS_CONTENTS
| SEC_READONLY
);
3979 bfd_set_section_alignment (stdoutput
, sec
, 3);
3981 ecoff_read_begin_hook ();
3983 if (first_file_directive
)
3985 char *save_ilp
= input_line_pointer
;
3986 input_line_pointer
= first_file_directive
;
3987 ecoff_directive_file (0);
3988 input_line_pointer
= save_ilp
;
3989 free (first_file_directive
);
3992 alpha_flag_mdebug
= 1;
3998 s_alpha_coff_wrapper (int which
)
4000 static void (* const fns
[]) (int) = {
4001 ecoff_directive_begin
,
4002 ecoff_directive_bend
,
4003 ecoff_directive_def
,
4004 ecoff_directive_dim
,
4005 ecoff_directive_endef
,
4006 ecoff_directive_scl
,
4007 ecoff_directive_tag
,
4008 ecoff_directive_val
,
4011 assert (which
>= 0 && which
< (int) (sizeof (fns
)/sizeof (*fns
)));
4013 if (ECOFF_DEBUGGING
)
4017 as_bad (_("ECOFF debugging is disabled."));
4018 ignore_rest_of_line ();
4022 /* Called at the end of assembly. Here we emit unwind info for frames
4023 unless the compiler has done it for us. */
4026 alpha_elf_md_end (void)
4028 struct alpha_elf_frame_data
*p
;
4031 as_warn (_(".ent directive without matching .end"));
4033 /* If someone has generated the unwind info themselves, great. */
4034 if (bfd_get_section_by_name (stdoutput
, ".eh_frame") != NULL
)
4037 /* Generate .eh_frame data for the unwind directives specified. */
4038 for (p
= all_frame_data
; p
; p
= p
->next
)
4039 if (p
->prologue_sym
)
4041 /* Create a temporary symbol at the same location as our
4042 function symbol. This prevents problems with globals. */
4043 cfi_new_fde (symbol_temp_new (S_GET_SEGMENT (p
->func_sym
),
4044 S_GET_VALUE (p
->func_sym
),
4045 symbol_get_frag (p
->func_sym
)));
4047 cfi_set_return_column (p
->ra_regno
);
4048 cfi_add_CFA_def_cfa_register (30);
4049 if (p
->fp_regno
!= 30 || p
->mask
|| p
->fmask
|| p
->frame_size
)
4054 cfi_add_advance_loc (p
->prologue_sym
);
4056 if (p
->fp_regno
!= 30)
4057 if (p
->frame_size
!= 0)
4058 cfi_add_CFA_def_cfa (p
->fp_regno
, p
->frame_size
);
4060 cfi_add_CFA_def_cfa_register (p
->fp_regno
);
4061 else if (p
->frame_size
!= 0)
4062 cfi_add_CFA_def_cfa_offset (p
->frame_size
);
4065 offset
= p
->mask_offset
;
4067 /* Recall that $26 is special-cased and stored first. */
4068 if ((mask
>> 26) & 1)
4070 cfi_add_CFA_offset (26, offset
);
4081 cfi_add_CFA_offset (i
, offset
);
4086 offset
= p
->fmask_offset
;
4094 cfi_add_CFA_offset (i
+ 32, offset
);
4099 cfi_end_fde (p
->func_end_sym
);
4104 s_alpha_usepv (int unused ATTRIBUTE_UNUSED
)
4106 char *name
, name_end
;
4107 char *which
, which_end
;
4111 name
= input_line_pointer
;
4112 name_end
= get_symbol_end ();
4114 if (! is_name_beginner (*name
))
4116 as_bad (_(".usepv directive has no name"));
4117 *input_line_pointer
= name_end
;
4118 ignore_rest_of_line ();
4122 sym
= symbol_find_or_make (name
);
4123 *input_line_pointer
++ = name_end
;
4125 if (name_end
!= ',')
4127 as_bad (_(".usepv directive has no type"));
4128 ignore_rest_of_line ();
4133 which
= input_line_pointer
;
4134 which_end
= get_symbol_end ();
4136 if (strcmp (which
, "no") == 0)
4137 other
= STO_ALPHA_NOPV
;
4138 else if (strcmp (which
, "std") == 0)
4139 other
= STO_ALPHA_STD_GPLOAD
;
4142 as_bad (_("unknown argument for .usepv"));
4146 *input_line_pointer
= which_end
;
4147 demand_empty_rest_of_line ();
4149 S_SET_OTHER (sym
, other
| (S_GET_OTHER (sym
) & ~STO_ALPHA_STD_GPLOAD
));
4151 #endif /* OBJ_ELF */
4153 /* Standard calling conventions leaves the CFA at $30 on entry. */
4156 alpha_cfi_frame_initial_instructions (void)
4158 cfi_add_CFA_def_cfa_register (30);
4163 /* Get name of section. */
4165 s_alpha_section_name (void)
4170 if (*input_line_pointer
== '"')
4174 name
= demand_copy_C_string (&dummy
);
4177 ignore_rest_of_line ();
4183 char *end
= input_line_pointer
;
4185 while (0 == strchr ("\n\t,; ", *end
))
4187 if (end
== input_line_pointer
)
4189 as_warn (_("missing name"));
4190 ignore_rest_of_line ();
4194 name
= xmalloc (end
- input_line_pointer
+ 1);
4195 memcpy (name
, input_line_pointer
, end
- input_line_pointer
);
4196 name
[end
- input_line_pointer
] = '\0';
4197 input_line_pointer
= end
;
4204 s_alpha_section_word (char *str
, size_t len
)
4209 if (len
== 5 && strncmp (str
, "NO", 2) == 0)
4218 if (strncmp (str
, "PIC", 3) == 0)
4219 flag
= EGPS_S_V_PIC
;
4220 else if (strncmp (str
, "LIB", 3) == 0)
4221 flag
= EGPS_S_V_LIB
;
4222 else if (strncmp (str
, "OVR", 3) == 0)
4223 flag
= EGPS_S_V_OVR
;
4224 else if (strncmp (str
, "REL", 3) == 0)
4225 flag
= EGPS_S_V_REL
;
4226 else if (strncmp (str
, "GBL", 3) == 0)
4227 flag
= EGPS_S_V_GBL
;
4228 else if (strncmp (str
, "SHR", 3) == 0)
4229 flag
= EGPS_S_V_SHR
;
4230 else if (strncmp (str
, "EXE", 3) == 0)
4231 flag
= EGPS_S_V_EXE
;
4232 else if (strncmp (str
, "WRT", 3) == 0)
4233 flag
= EGPS_S_V_WRT
;
4234 else if (strncmp (str
, "VEC", 3) == 0)
4235 flag
= EGPS_S_V_VEC
;
4236 else if (strncmp (str
, "MOD", 3) == 0)
4238 flag
= no
? EGPS_S_V_NOMOD
: EGPS_S_V_NOMOD
<< EGPS_S_V_NO_SHIFT
;
4241 else if (strncmp (str
, "COM", 3) == 0)
4242 flag
= EGPS_S_V_COM
;
4249 as_warn (_("unknown section attribute %s"), str
);
4255 return flag
<< EGPS_S_V_NO_SHIFT
;
4260 /* Handle the section specific pseudo-op. */
4262 #define EVAX_SECTION_COUNT 5
4264 static char *section_name
[EVAX_SECTION_COUNT
+ 1] =
4265 { "NULL", ".rdata", ".comm", ".link", ".ctors", ".dtors" };
4268 s_alpha_section (int secid
)
4273 flagword vms_flags
= 0;
4278 name
= s_alpha_section_name ();
4281 sec
= subseg_new (name
, 0);
4282 if (*input_line_pointer
== ',')
4284 /* Skip the comma. */
4285 ++input_line_pointer
;
4293 beg
= input_line_pointer
;
4294 c
= get_symbol_end ();
4295 *input_line_pointer
= c
;
4297 vms_flags
|= s_alpha_section_word (beg
, input_line_pointer
- beg
);
4301 while (*input_line_pointer
++ == ',');
4302 --input_line_pointer
;
4305 symbol
= symbol_find_or_make (name
);
4306 S_SET_SEGMENT (symbol
, sec
);
4307 symbol_get_bfdsym (symbol
)->flags
|= BSF_SECTION_SYM
;
4308 bfd_vms_set_section_flags (stdoutput
, sec
, vms_flags
);
4312 temp
= get_absolute_expression ();
4313 subseg_new (section_name
[secid
], 0);
4316 demand_empty_rest_of_line ();
4317 alpha_insn_label
= NULL
;
4318 alpha_auto_align_on
= 1;
4319 alpha_current_align
= 0;
4323 s_alpha_literals (int ignore ATTRIBUTE_UNUSED
)
4325 subseg_new (".literals", 0);
4326 demand_empty_rest_of_line ();
4327 alpha_insn_label
= NULL
;
4328 alpha_auto_align_on
= 1;
4329 alpha_current_align
= 0;
4332 /* Parse .ent directives. */
4335 s_alpha_ent (int ignore ATTRIBUTE_UNUSED
)
4338 expressionS symexpr
;
4341 = (struct alpha_evax_procs
*) xmalloc (sizeof (struct alpha_evax_procs
));
4343 alpha_evax_proc
->pdsckind
= 0;
4344 alpha_evax_proc
->framereg
= -1;
4345 alpha_evax_proc
->framesize
= 0;
4346 alpha_evax_proc
->rsa_offset
= 0;
4347 alpha_evax_proc
->ra_save
= AXP_REG_RA
;
4348 alpha_evax_proc
->fp_save
= -1;
4349 alpha_evax_proc
->imask
= 0;
4350 alpha_evax_proc
->fmask
= 0;
4351 alpha_evax_proc
->prologue
= 0;
4352 alpha_evax_proc
->type
= 0;
4353 alpha_evax_proc
->handler
= 0;
4354 alpha_evax_proc
->handler_data
= 0;
4356 expression (&symexpr
);
4358 if (symexpr
.X_op
!= O_symbol
)
4360 as_fatal (_(".ent directive has no symbol"));
4361 demand_empty_rest_of_line ();
4365 symbol
= make_expr_symbol (&symexpr
);
4366 symbol_get_bfdsym (symbol
)->flags
|= BSF_FUNCTION
;
4367 alpha_evax_proc
->symbol
= symbol
;
4370 (alpha_evax_proc_hash
,
4371 symbol_get_bfdsym (alpha_evax_proc
->symbol
)->name
, (PTR
)alpha_evax_proc
);
4373 demand_empty_rest_of_line ();
4377 s_alpha_handler (int is_data
)
4380 alpha_evax_proc
->handler_data
= get_absolute_expression ();
4383 char *name
, name_end
;
4384 name
= input_line_pointer
;
4385 name_end
= get_symbol_end ();
4387 if (! is_name_beginner (*name
))
4389 as_warn (_(".handler directive has no name"));
4390 *input_line_pointer
= name_end
;
4396 sym
= symbol_find_or_make (name
);
4397 symbol_get_bfdsym (sym
)->flags
|= BSF_FUNCTION
;
4398 alpha_evax_proc
->handler
= sym
;
4399 *input_line_pointer
= name_end
;
4402 demand_empty_rest_of_line ();
4405 /* Parse .frame <framreg>,<framesize>,RA,<rsa_offset> directives. */
4408 s_alpha_frame (int ignore ATTRIBUTE_UNUSED
)
4412 alpha_evax_proc
->framereg
= tc_get_register (1);
4415 if (*input_line_pointer
++ != ','
4416 || get_absolute_expression_and_terminator (&val
) != ',')
4418 as_warn (_("Bad .frame directive 1./2. param"));
4419 --input_line_pointer
;
4420 demand_empty_rest_of_line ();
4424 alpha_evax_proc
->framesize
= val
;
4426 (void) tc_get_register (1);
4428 if (*input_line_pointer
++ != ',')
4430 as_warn (_("Bad .frame directive 3./4. param"));
4431 --input_line_pointer
;
4432 demand_empty_rest_of_line ();
4435 alpha_evax_proc
->rsa_offset
= get_absolute_expression ();
4439 s_alpha_prologue (int ignore ATTRIBUTE_UNUSED
)
4443 arg
= get_absolute_expression ();
4444 demand_empty_rest_of_line ();
4445 alpha_prologue_label
= symbol_new
4446 (FAKE_LABEL_NAME
, now_seg
, (valueT
) frag_now_fix (), frag_now
);
4450 s_alpha_pdesc (int ignore ATTRIBUTE_UNUSED
)
4458 segment_info_type
*seginfo
= seg_info (alpha_link_section
);
4459 const char *entry_sym_name
;
4463 if (now_seg
!= alpha_link_section
)
4465 as_bad (_(".pdesc directive not in link (.link) section"));
4466 demand_empty_rest_of_line ();
4471 if (exp
.X_op
!= O_symbol
)
4473 as_warn (_(".pdesc directive has no entry symbol"));
4474 demand_empty_rest_of_line ();
4478 entry_sym
= make_expr_symbol (&exp
);
4479 entry_sym_name
= symbol_get_bfdsym (entry_sym
)->name
;
4481 len
= strlen (entry_sym_name
);
4482 sym_name
= (char *) xmalloc (len
- 4 + 1);
4483 strncpy (sym_name
, entry_sym_name
, len
- 4);
4484 sym_name
[len
- 4] = 0;
4486 alpha_evax_proc
= (struct alpha_evax_procs
*)
4487 hash_find (alpha_evax_proc_hash
, sym_name
);
4489 if (!alpha_evax_proc
|| !S_IS_DEFINED (alpha_evax_proc
->symbol
))
4491 as_fatal (_(".pdesc has no matching .ent"));
4492 demand_empty_rest_of_line ();
4496 *symbol_get_obj (alpha_evax_proc
->symbol
) =
4497 (valueT
) seginfo
->literal_pool_size
;
4499 alpha_evax_proc
->symbol
->sy_obj
= (valueT
)seginfo
->literal_pool_size
;
4501 /* Save bfd symbol of proc entry in function symbol. */
4502 ((struct evax_private_udata_struct
*)
4503 symbol_get_bfdsym (alpha_evax_proc
->symbol
)->udata
.p
)->enbsym
4504 = symbol_get_bfdsym (entry_sym
);
4507 if (*input_line_pointer
++ != ',')
4509 as_warn (_("No comma after .pdesc <entryname>"));
4510 demand_empty_rest_of_line ();
4515 name
= input_line_pointer
;
4516 name_end
= get_symbol_end ();
4518 if (strncmp (name
, "stack", 5) == 0)
4519 alpha_evax_proc
->pdsckind
= PDSC_S_K_KIND_FP_STACK
;
4521 else if (strncmp (name
, "reg", 3) == 0)
4522 alpha_evax_proc
->pdsckind
= PDSC_S_K_KIND_FP_REGISTER
;
4524 else if (strncmp (name
, "null", 4) == 0)
4525 alpha_evax_proc
->pdsckind
= PDSC_S_K_KIND_NULL
;
4529 as_fatal (_("unknown procedure kind"));
4530 demand_empty_rest_of_line ();
4534 *input_line_pointer
= name_end
;
4535 demand_empty_rest_of_line ();
4537 #ifdef md_flush_pending_output
4538 md_flush_pending_output ();
4541 frag_align (3, 0, 0);
4543 fixp
= fix_new (frag_now
, p
- frag_now
->fr_literal
, 8, 0, 0, 0, 0);
4545 seginfo
->literal_pool_size
+= 16;
4547 *p
= alpha_evax_proc
->pdsckind
4548 | ((alpha_evax_proc
->framereg
== 29) ? PDSC_S_M_BASE_REG_IS_FP
: 0)
4549 | ((alpha_evax_proc
->handler
) ? PDSC_S_M_HANDLER_VALID
: 0)
4550 | ((alpha_evax_proc
->handler_data
) ? PDSC_S_M_HANDLER_DATA_VALID
: 0);
4551 *(p
+ 1) = PDSC_S_M_NATIVE
| PDSC_S_M_NO_JACKET
;
4553 switch (alpha_evax_proc
->pdsckind
)
4555 case PDSC_S_K_KIND_NULL
:
4559 case PDSC_S_K_KIND_FP_REGISTER
:
4560 *(p
+ 2) = alpha_evax_proc
->fp_save
;
4561 *(p
+ 3) = alpha_evax_proc
->ra_save
;
4563 case PDSC_S_K_KIND_FP_STACK
:
4564 md_number_to_chars (p
+ 2, (valueT
) alpha_evax_proc
->rsa_offset
, 2);
4566 default: /* impossible */
4571 *(p
+ 5) = alpha_evax_proc
->type
& 0x0f;
4573 /* Signature offset. */
4574 md_number_to_chars (p
+ 6, (valueT
) 0, 2);
4576 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
+8, 8, &exp
, 0, BFD_RELOC_64
);
4578 if (alpha_evax_proc
->pdsckind
== PDSC_S_K_KIND_NULL
)
4581 /* Add dummy fix to make add_to_link_pool work. */
4583 fixp
= fix_new (frag_now
, p
- frag_now
->fr_literal
, 6, 0, 0, 0, 0);
4585 seginfo
->literal_pool_size
+= 6;
4587 /* pdesc+16: Size. */
4588 md_number_to_chars (p
, (valueT
) alpha_evax_proc
->framesize
, 4);
4590 md_number_to_chars (p
+ 4, (valueT
) 0, 2);
4593 exp
.X_op
= O_subtract
;
4594 exp
.X_add_symbol
= alpha_prologue_label
;
4595 exp
.X_op_symbol
= entry_sym
;
4596 emit_expr (&exp
, 2);
4598 if (alpha_evax_proc
->pdsckind
== PDSC_S_K_KIND_FP_REGISTER
)
4601 /* Add dummy fix to make add_to_link_pool work. */
4603 fixp
= fix_new (frag_now
, p
- frag_now
->fr_literal
, 8, 0, 0, 0, 0);
4605 seginfo
->literal_pool_size
+= 8;
4607 /* pdesc+24: register masks. */
4609 md_number_to_chars (p
, alpha_evax_proc
->imask
, 4);
4610 md_number_to_chars (p
+ 4, alpha_evax_proc
->fmask
, 4);
4612 if (alpha_evax_proc
->handler
)
4615 fixp
= fix_new (frag_now
, p
- frag_now
->fr_literal
, 8,
4616 alpha_evax_proc
->handler
, 0, 0, BFD_RELOC_64
);
4619 if (alpha_evax_proc
->handler_data
)
4621 /* Add dummy fix to make add_to_link_pool work. */
4623 fixp
= fix_new (frag_now
, p
- frag_now
->fr_literal
, 8, 0, 0, 0, 0);
4625 seginfo
->literal_pool_size
+= 8;
4626 md_number_to_chars (p
, alpha_evax_proc
->handler_data
, 8);
4630 /* Support for crash debug on vms. */
4633 s_alpha_name (int ignore ATTRIBUTE_UNUSED
)
4637 segment_info_type
*seginfo
= seg_info (alpha_link_section
);
4639 if (now_seg
!= alpha_link_section
)
4641 as_bad (_(".name directive not in link (.link) section"));
4642 demand_empty_rest_of_line ();
4647 if (exp
.X_op
!= O_symbol
)
4649 as_warn (_(".name directive has no symbol"));
4650 demand_empty_rest_of_line ();
4654 demand_empty_rest_of_line ();
4656 #ifdef md_flush_pending_output
4657 md_flush_pending_output ();
4660 frag_align (3, 0, 0);
4662 seginfo
->literal_pool_size
+= 8;
4664 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 8, &exp
, 0, BFD_RELOC_64
);
4668 s_alpha_linkage (int ignore ATTRIBUTE_UNUSED
)
4674 #ifdef md_flush_pending_output
4675 md_flush_pending_output ();
4679 if (exp
.X_op
!= O_symbol
)
4681 as_fatal (_("No symbol after .linkage"));
4685 struct alpha_linkage_fixups
*linkage_fixup
;
4687 p
= frag_more (LKP_S_K_SIZE
);
4688 memset (p
, 0, LKP_S_K_SIZE
);
4690 (frag_now
, p
- frag_now
->fr_literal
, LKP_S_K_SIZE
, &exp
, 0,\
4691 BFD_RELOC_ALPHA_LINKAGE
);
4693 linkage_fixup
= (struct alpha_linkage_fixups
*)
4694 xmalloc (sizeof (struct alpha_linkage_fixups
));
4696 linkage_fixup
->fixp
= fixp
;
4697 linkage_fixup
->next
= 0;
4699 if (alpha_insn_label
== 0)
4700 alpha_insn_label
= symbol_new
4701 (FAKE_LABEL_NAME
, now_seg
, (valueT
) frag_now_fix (), frag_now
);
4702 linkage_fixup
->label
= alpha_insn_label
;
4704 if (alpha_linkage_fixup_root
== 0)
4706 alpha_linkage_fixup_root
= alpha_linkage_fixup_tail
= linkage_fixup
;
4707 alpha_linkage_fixup_tail
->next
= 0;
4711 alpha_linkage_fixup_tail
->next
= linkage_fixup
;
4712 alpha_linkage_fixup_tail
= linkage_fixup
;
4713 alpha_linkage_fixup_tail
->next
= 0;
4716 demand_empty_rest_of_line ();
4720 s_alpha_code_address (int ignore ATTRIBUTE_UNUSED
)
4725 #ifdef md_flush_pending_output
4726 md_flush_pending_output ();
4730 if (exp
.X_op
!= O_symbol
)
4731 as_fatal (_("No symbol after .code_address"));
4736 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 8, &exp
, 0,\
4737 BFD_RELOC_ALPHA_CODEADDR
);
4739 demand_empty_rest_of_line ();
4743 s_alpha_fp_save (int ignore ATTRIBUTE_UNUSED
)
4746 alpha_evax_proc
->fp_save
= tc_get_register (1);
4748 demand_empty_rest_of_line ();
4752 s_alpha_mask (int ignore ATTRIBUTE_UNUSED
)
4756 if (get_absolute_expression_and_terminator (&val
) != ',')
4758 as_warn (_("Bad .mask directive"));
4759 --input_line_pointer
;
4763 alpha_evax_proc
->imask
= val
;
4764 (void) get_absolute_expression ();
4766 demand_empty_rest_of_line ();
4770 s_alpha_fmask (int ignore ATTRIBUTE_UNUSED
)
4774 if (get_absolute_expression_and_terminator (&val
) != ',')
4776 as_warn (_("Bad .fmask directive"));
4777 --input_line_pointer
;
4781 alpha_evax_proc
->fmask
= val
;
4782 (void) get_absolute_expression ();
4784 demand_empty_rest_of_line ();
4788 s_alpha_end (int ignore ATTRIBUTE_UNUSED
)
4792 c
= get_symbol_end ();
4793 *input_line_pointer
= c
;
4794 demand_empty_rest_of_line ();
4795 alpha_evax_proc
= 0;
4799 s_alpha_file (int ignore ATTRIBUTE_UNUSED
)
4803 static char case_hack
[32];
4805 sprintf (case_hack
, "<CASE:%01d%01d>",
4806 alpha_flag_hash_long_names
, alpha_flag_show_after_trunc
);
4808 s
= symbol_find_or_make (case_hack
);
4809 symbol_get_bfdsym (s
)->flags
|= BSF_FILE
;
4811 get_absolute_expression ();
4812 s
= symbol_find_or_make (demand_copy_string (&length
));
4813 symbol_get_bfdsym (s
)->flags
|= BSF_FILE
;
4814 demand_empty_rest_of_line ();
4816 #endif /* OBJ_EVAX */
4818 /* Handle the .gprel32 pseudo op. */
4821 s_alpha_gprel32 (int ignore ATTRIBUTE_UNUSED
)
4833 e
.X_add_symbol
= section_symbol (absolute_section
);
4846 e
.X_add_symbol
= section_symbol (absolute_section
);
4849 e
.X_op
= O_subtract
;
4850 e
.X_op_symbol
= alpha_gp_symbol
;
4858 if (alpha_auto_align_on
&& alpha_current_align
< 2)
4859 alpha_align (2, (char *) NULL
, alpha_insn_label
, 0);
4860 if (alpha_current_align
> 2)
4861 alpha_current_align
= 2;
4862 alpha_insn_label
= NULL
;
4866 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 4,
4867 &e
, 0, BFD_RELOC_GPREL32
);
4870 /* Handle floating point allocation pseudo-ops. This is like the
4871 generic vresion, but it makes sure the current label, if any, is
4872 correctly aligned. */
4875 s_alpha_float_cons (int type
)
4901 if (alpha_auto_align_on
&& alpha_current_align
< log_size
)
4902 alpha_align (log_size
, (char *) NULL
, alpha_insn_label
, 0);
4903 if (alpha_current_align
> log_size
)
4904 alpha_current_align
= log_size
;
4905 alpha_insn_label
= NULL
;
4910 /* Handle the .proc pseudo op. We don't really do much with it except
4914 s_alpha_proc (int is_static ATTRIBUTE_UNUSED
)
4922 /* Takes ".proc name,nargs". */
4924 name
= input_line_pointer
;
4925 c
= get_symbol_end ();
4926 p
= input_line_pointer
;
4927 symbolP
= symbol_find_or_make (name
);
4930 if (*input_line_pointer
!= ',')
4933 as_warn (_("Expected comma after name \"%s\""), name
);
4936 ignore_rest_of_line ();
4940 input_line_pointer
++;
4941 temp
= get_absolute_expression ();
4943 /* *symbol_get_obj (symbolP) = (signed char) temp; */
4944 as_warn (_("unhandled: .proc %s,%d"), name
, temp
);
4945 demand_empty_rest_of_line ();
4948 /* Handle the .set pseudo op. This is used to turn on and off most of
4949 the assembler features. */
4952 s_alpha_set (int x ATTRIBUTE_UNUSED
)
4958 name
= input_line_pointer
;
4959 ch
= get_symbol_end ();
4962 if (s
[0] == 'n' && s
[1] == 'o')
4967 if (!strcmp ("reorder", s
))
4969 else if (!strcmp ("at", s
))
4970 alpha_noat_on
= !yesno
;
4971 else if (!strcmp ("macro", s
))
4972 alpha_macros_on
= yesno
;
4973 else if (!strcmp ("move", s
))
4975 else if (!strcmp ("volatile", s
))
4978 as_warn (_("Tried to .set unrecognized mode `%s'"), name
);
4980 *input_line_pointer
= ch
;
4981 demand_empty_rest_of_line ();
4984 /* Handle the .base pseudo op. This changes the assembler's notion of
4985 the $gp register. */
4988 s_alpha_base (int ignore ATTRIBUTE_UNUSED
)
4992 if (*input_line_pointer
== '$')
4995 input_line_pointer
++;
4996 if (*input_line_pointer
== 'r')
4997 input_line_pointer
++;
5000 alpha_gp_register
= get_absolute_expression ();
5001 if (alpha_gp_register
< 0 || alpha_gp_register
> 31)
5003 alpha_gp_register
= AXP_REG_GP
;
5004 as_warn (_("Bad base register, using $%d."), alpha_gp_register
);
5007 demand_empty_rest_of_line ();
5010 /* Handle the .align pseudo-op. This aligns to a power of two. It
5011 also adjusts any current instruction label. We treat this the same
5012 way the MIPS port does: .align 0 turns off auto alignment. */
5015 s_alpha_align (int ignore ATTRIBUTE_UNUSED
)
5019 long max_alignment
= 16;
5021 align
= get_absolute_expression ();
5022 if (align
> max_alignment
)
5024 align
= max_alignment
;
5025 as_bad (_("Alignment too large: %d. assumed"), align
);
5029 as_warn (_("Alignment negative: 0 assumed"));
5033 if (*input_line_pointer
== ',')
5035 input_line_pointer
++;
5036 fill
= get_absolute_expression ();
5044 alpha_auto_align_on
= 1;
5045 alpha_align (align
, pfill
, alpha_insn_label
, 1);
5049 alpha_auto_align_on
= 0;
5052 demand_empty_rest_of_line ();
5055 /* Hook the normal string processor to reset known alignment. */
5058 s_alpha_stringer (int terminate
)
5060 alpha_current_align
= 0;
5061 alpha_insn_label
= NULL
;
5062 stringer (8 + terminate
);
5065 /* Hook the normal space processing to reset known alignment. */
5068 s_alpha_space (int ignore
)
5070 alpha_current_align
= 0;
5071 alpha_insn_label
= NULL
;
5075 /* Hook into cons for auto-alignment. */
5078 alpha_cons_align (int size
)
5083 while ((size
>>= 1) != 0)
5086 if (alpha_auto_align_on
&& alpha_current_align
< log_size
)
5087 alpha_align (log_size
, (char *) NULL
, alpha_insn_label
, 0);
5088 if (alpha_current_align
> log_size
)
5089 alpha_current_align
= log_size
;
5090 alpha_insn_label
= NULL
;
5093 /* Here come the .uword, .ulong, and .uquad explicitly unaligned
5094 pseudos. We just turn off auto-alignment and call down to cons. */
5097 s_alpha_ucons (int bytes
)
5099 int hold
= alpha_auto_align_on
;
5100 alpha_auto_align_on
= 0;
5102 alpha_auto_align_on
= hold
;
5105 /* Switch the working cpu type. */
5108 s_alpha_arch (int ignored ATTRIBUTE_UNUSED
)
5111 const struct cpu_type
*p
;
5114 name
= input_line_pointer
;
5115 ch
= get_symbol_end ();
5117 for (p
= cpu_types
; p
->name
; ++p
)
5118 if (strcmp (name
, p
->name
) == 0)
5120 alpha_target_name
= p
->name
, alpha_target
= p
->flags
;
5123 as_warn ("Unknown CPU identifier `%s'", name
);
5126 *input_line_pointer
= ch
;
5127 demand_empty_rest_of_line ();
5131 /* print token expression with alpha specific extension. */
5134 alpha_print_token (FILE *f
, const expressionS
*exp
)
5144 expressionS nexp
= *exp
;
5145 nexp
.X_op
= O_register
;
5146 print_expr_1 (f
, &nexp
);
5151 print_expr_1 (f
, exp
);
5157 /* The target specific pseudo-ops which we support. */
5159 const pseudo_typeS md_pseudo_table
[] =
5162 {"comm", s_alpha_comm
, 0}, /* OSF1 compiler does this. */
5163 {"rdata", s_alpha_rdata
, 0},
5165 {"text", s_alpha_text
, 0},
5166 {"data", s_alpha_data
, 0},
5168 {"sdata", s_alpha_sdata
, 0},
5171 {"section", s_alpha_section
, 0},
5172 {"section.s", s_alpha_section
, 0},
5173 {"sect", s_alpha_section
, 0},
5174 {"sect.s", s_alpha_section
, 0},
5177 {"section", s_alpha_section
, 0},
5178 {"literals", s_alpha_literals
, 0},
5179 {"pdesc", s_alpha_pdesc
, 0},
5180 {"name", s_alpha_name
, 0},
5181 {"linkage", s_alpha_linkage
, 0},
5182 {"code_address", s_alpha_code_address
, 0},
5183 {"ent", s_alpha_ent
, 0},
5184 {"frame", s_alpha_frame
, 0},
5185 {"fp_save", s_alpha_fp_save
, 0},
5186 {"mask", s_alpha_mask
, 0},
5187 {"fmask", s_alpha_fmask
, 0},
5188 {"end", s_alpha_end
, 0},
5189 {"file", s_alpha_file
, 0},
5190 {"rdata", s_alpha_section
, 1},
5191 {"comm", s_alpha_comm
, 0},
5192 {"link", s_alpha_section
, 3},
5193 {"ctors", s_alpha_section
, 4},
5194 {"dtors", s_alpha_section
, 5},
5195 {"handler", s_alpha_handler
, 0},
5196 {"handler_data", s_alpha_handler
, 1},
5199 /* Frame related pseudos. */
5200 {"ent", s_alpha_ent
, 0},
5201 {"end", s_alpha_end
, 0},
5202 {"mask", s_alpha_mask
, 0},
5203 {"fmask", s_alpha_mask
, 1},
5204 {"frame", s_alpha_frame
, 0},
5205 {"prologue", s_alpha_prologue
, 0},
5206 {"file", s_alpha_file
, 5},
5207 {"loc", s_alpha_loc
, 9},
5208 {"stabs", s_alpha_stab
, 's'},
5209 {"stabn", s_alpha_stab
, 'n'},
5210 {"usepv", s_alpha_usepv
, 0},
5211 /* COFF debugging related pseudos. */
5212 {"begin", s_alpha_coff_wrapper
, 0},
5213 {"bend", s_alpha_coff_wrapper
, 1},
5214 {"def", s_alpha_coff_wrapper
, 2},
5215 {"dim", s_alpha_coff_wrapper
, 3},
5216 {"endef", s_alpha_coff_wrapper
, 4},
5217 {"scl", s_alpha_coff_wrapper
, 5},
5218 {"tag", s_alpha_coff_wrapper
, 6},
5219 {"val", s_alpha_coff_wrapper
, 7},
5222 {"prologue", s_alpha_prologue
, 0},
5224 {"prologue", s_ignore
, 0},
5227 {"gprel32", s_alpha_gprel32
, 0},
5228 {"t_floating", s_alpha_float_cons
, 'd'},
5229 {"s_floating", s_alpha_float_cons
, 'f'},
5230 {"f_floating", s_alpha_float_cons
, 'F'},
5231 {"g_floating", s_alpha_float_cons
, 'G'},
5232 {"d_floating", s_alpha_float_cons
, 'D'},
5234 {"proc", s_alpha_proc
, 0},
5235 {"aproc", s_alpha_proc
, 1},
5236 {"set", s_alpha_set
, 0},
5237 {"reguse", s_ignore
, 0},
5238 {"livereg", s_ignore
, 0},
5239 {"base", s_alpha_base
, 0}, /*??*/
5240 {"option", s_ignore
, 0},
5241 {"aent", s_ignore
, 0},
5242 {"ugen", s_ignore
, 0},
5243 {"eflag", s_ignore
, 0},
5245 {"align", s_alpha_align
, 0},
5246 {"double", s_alpha_float_cons
, 'd'},
5247 {"float", s_alpha_float_cons
, 'f'},
5248 {"single", s_alpha_float_cons
, 'f'},
5249 {"ascii", s_alpha_stringer
, 0},
5250 {"asciz", s_alpha_stringer
, 1},
5251 {"string", s_alpha_stringer
, 1},
5252 {"space", s_alpha_space
, 0},
5253 {"skip", s_alpha_space
, 0},
5254 {"zero", s_alpha_space
, 0},
5256 /* Unaligned data pseudos. */
5257 {"uword", s_alpha_ucons
, 2},
5258 {"ulong", s_alpha_ucons
, 4},
5259 {"uquad", s_alpha_ucons
, 8},
5262 /* Dwarf wants these versions of unaligned. */
5263 {"2byte", s_alpha_ucons
, 2},
5264 {"4byte", s_alpha_ucons
, 4},
5265 {"8byte", s_alpha_ucons
, 8},
5268 /* We don't do any optimizing, so we can safely ignore these. */
5269 {"noalias", s_ignore
, 0},
5270 {"alias", s_ignore
, 0},
5272 {"arch", s_alpha_arch
, 0},
5279 /* @@@ GP selection voodoo. All of this seems overly complicated and
5280 unnecessary; which is the primary reason it's for ECOFF only. */
5283 maybe_set_gp (asection
*sec
)
5289 vma
= bfd_get_section_vma (foo
, sec
);
5290 if (vma
&& vma
< alpha_gp_value
)
5291 alpha_gp_value
= vma
;
5295 select_gp_value (void)
5297 assert (alpha_gp_value
== 0);
5299 /* Get minus-one in whatever width... */
5303 /* Select the smallest VMA of these existing sections. */
5304 maybe_set_gp (alpha_lita_section
);
5306 /* @@ Will a simple 0x8000 work here? If not, why not? */
5307 #define GP_ADJUSTMENT (0x8000 - 0x10)
5309 alpha_gp_value
+= GP_ADJUSTMENT
;
5311 S_SET_VALUE (alpha_gp_symbol
, alpha_gp_value
);
5314 printf (_("Chose GP value of %lx\n"), alpha_gp_value
);
5317 #endif /* OBJ_ECOFF */
5320 /* Map 's' to SHF_ALPHA_GPREL. */
5323 alpha_elf_section_letter (int letter
, char **ptr_msg
)
5326 return SHF_ALPHA_GPREL
;
5328 *ptr_msg
= _("Bad .section directive: want a,s,w,x,M,S,G,T in string");
5332 /* Map SHF_ALPHA_GPREL to SEC_SMALL_DATA. */
5335 alpha_elf_section_flags (flagword flags
, bfd_vma attr
, int type ATTRIBUTE_UNUSED
)
5337 if (attr
& SHF_ALPHA_GPREL
)
5338 flags
|= SEC_SMALL_DATA
;
5341 #endif /* OBJ_ELF */
5343 /* This is called from HANDLE_ALIGN in write.c. Fill in the contents
5344 of an rs_align_code fragment. */
5347 alpha_handle_align (fragS
*fragp
)
5349 static char const unop
[4] = { 0x00, 0x00, 0xfe, 0x2f };
5350 static char const nopunop
[8] =
5352 0x1f, 0x04, 0xff, 0x47,
5353 0x00, 0x00, 0xfe, 0x2f
5359 if (fragp
->fr_type
!= rs_align_code
)
5362 bytes
= fragp
->fr_next
->fr_address
- fragp
->fr_address
- fragp
->fr_fix
;
5363 p
= fragp
->fr_literal
+ fragp
->fr_fix
;
5376 memcpy (p
, unop
, 4);
5382 memcpy (p
, nopunop
, 8);
5384 fragp
->fr_fix
+= fix
;
5388 /* Public interface functions. */
5390 /* This function is called once, at assembler startup time. It sets
5391 up all the tables, etc. that the MD part of the assembler will
5392 need, that can be determined before arguments are parsed. */
5399 /* Verify that X_op field is wide enough. */
5404 assert (e
.X_op
== O_max
);
5407 /* Create the opcode hash table. */
5408 alpha_opcode_hash
= hash_new ();
5410 for (i
= 0; i
< alpha_num_opcodes
;)
5412 const char *name
, *retval
, *slash
;
5414 name
= alpha_opcodes
[i
].name
;
5415 retval
= hash_insert (alpha_opcode_hash
, name
, (void *) &alpha_opcodes
[i
]);
5417 as_fatal (_("internal error: can't hash opcode `%s': %s"),
5420 /* Some opcodes include modifiers of various sorts with a "/mod"
5421 syntax, like the architecture manual suggests. However, for
5422 use with gcc at least, we also need access to those same opcodes
5425 if ((slash
= strchr (name
, '/')) != NULL
)
5427 char *p
= xmalloc (strlen (name
));
5429 memcpy (p
, name
, slash
- name
);
5430 strcpy (p
+ (slash
- name
), slash
+ 1);
5432 (void) hash_insert (alpha_opcode_hash
, p
, (void *) &alpha_opcodes
[i
]);
5433 /* Ignore failures -- the opcode table does duplicate some
5434 variants in different forms, like "hw_stq" and "hw_st/q". */
5437 while (++i
< alpha_num_opcodes
5438 && (alpha_opcodes
[i
].name
== name
5439 || !strcmp (alpha_opcodes
[i
].name
, name
)))
5443 /* Create the macro hash table. */
5444 alpha_macro_hash
= hash_new ();
5446 for (i
= 0; i
< alpha_num_macros
;)
5448 const char *name
, *retval
;
5450 name
= alpha_macros
[i
].name
;
5451 retval
= hash_insert (alpha_macro_hash
, name
, (void *) &alpha_macros
[i
]);
5453 as_fatal (_("internal error: can't hash macro `%s': %s"),
5456 while (++i
< alpha_num_macros
5457 && (alpha_macros
[i
].name
== name
5458 || !strcmp (alpha_macros
[i
].name
, name
)))
5462 /* Construct symbols for each of the registers. */
5463 for (i
= 0; i
< 32; ++i
)
5467 sprintf (name
, "$%d", i
);
5468 alpha_register_table
[i
] = symbol_create (name
, reg_section
, i
,
5469 &zero_address_frag
);
5476 sprintf (name
, "$f%d", i
- 32);
5477 alpha_register_table
[i
] = symbol_create (name
, reg_section
, i
,
5478 &zero_address_frag
);
5481 /* Create the special symbols and sections we'll be using. */
5483 /* So .sbss will get used for tiny objects. */
5484 bfd_set_gp_size (stdoutput
, g_switch_value
);
5487 create_literal_section (".lita", &alpha_lita_section
, &alpha_lita_symbol
);
5489 /* For handling the GP, create a symbol that won't be output in the
5490 symbol table. We'll edit it out of relocs later. */
5491 alpha_gp_symbol
= symbol_create ("<GP value>", alpha_lita_section
, 0x8000,
5492 &zero_address_frag
);
5496 create_literal_section (".link", &alpha_link_section
, &alpha_link_symbol
);
5497 alpha_evax_proc_hash
= hash_new ();
5501 if (ECOFF_DEBUGGING
)
5503 segT sec
= subseg_new (".mdebug", (subsegT
) 0);
5504 bfd_set_section_flags (stdoutput
, sec
, SEC_HAS_CONTENTS
| SEC_READONLY
);
5505 bfd_set_section_alignment (stdoutput
, sec
, 3);
5509 /* Create literal lookup hash table. */
5510 alpha_literal_hash
= hash_new ();
5512 subseg_set (text_section
, 0);
5515 /* The public interface to the instruction assembler. */
5518 md_assemble (char *str
)
5520 /* Current maximum is 13. */
5522 expressionS tok
[MAX_INSN_ARGS
];
5526 /* Split off the opcode. */
5527 opnamelen
= strspn (str
, "abcdefghijklmnopqrstuvwxyz_/46819");
5528 trunclen
= (opnamelen
< sizeof (opname
) - 1
5530 : sizeof (opname
) - 1);
5531 memcpy (opname
, str
, trunclen
);
5532 opname
[trunclen
] = '\0';
5534 /* Tokenize the rest of the line. */
5535 if ((ntok
= tokenize_arguments (str
+ opnamelen
, tok
, MAX_INSN_ARGS
)) < 0)
5537 if (ntok
!= TOKENIZE_ERROR_REPORT
)
5538 as_bad (_("syntax error"));
5543 /* Finish it off. */
5544 assemble_tokens (opname
, tok
, ntok
, alpha_macros_on
);
5547 /* Round up a section's size to the appropriate boundary. */
5550 md_section_align (segT seg
, valueT size
)
5552 int align
= bfd_get_section_alignment (stdoutput
, seg
);
5553 valueT mask
= ((valueT
) 1 << align
) - 1;
5555 return (size
+ mask
) & ~mask
;
5558 /* Turn a string in input_line_pointer into a floating point constant
5559 of type TYPE, and store the appropriate bytes in *LITP. The number
5560 of LITTLENUMS emitted is stored in *SIZEP. An error message is
5561 returned, or NULL on OK. */
5564 md_atof (int type
, char *litP
, int *sizeP
)
5566 extern char *vax_md_atof (int, char *, int *);
5572 /* vax_md_atof() doesn't like "G" for some reason. */
5576 return vax_md_atof (type
, litP
, sizeP
);
5579 return ieee_md_atof (type
, litP
, sizeP
, FALSE
);
5583 /* Take care of the target-specific command-line options. */
5586 md_parse_option (int c
, char *arg
)
5591 alpha_nofloats_on
= 1;
5595 alpha_addr32_on
= 1;
5603 g_switch_value
= atoi (arg
);
5608 const struct cpu_type
*p
;
5610 for (p
= cpu_types
; p
->name
; ++p
)
5611 if (strcmp (arg
, p
->name
) == 0)
5613 alpha_target_name
= p
->name
, alpha_target
= p
->flags
;
5616 as_warn (_("Unknown CPU identifier `%s'"), arg
);
5622 case '+': /* For g++. Hash any name > 63 chars long. */
5623 alpha_flag_hash_long_names
= 1;
5626 case 'H': /* Show new symbol after hash truncation. */
5627 alpha_flag_show_after_trunc
= 1;
5630 case 'h': /* For gnu-c/vax compatibility. */
5633 case OPTION_REPLACE
:
5634 alpha_flag_replace
= 1;
5637 case OPTION_NOREPLACE
:
5638 alpha_flag_replace
= 0;
5643 alpha_flag_relax
= 1;
5648 alpha_flag_mdebug
= 1;
5650 case OPTION_NO_MDEBUG
:
5651 alpha_flag_mdebug
= 0;
5662 /* Print a description of the command-line options that we accept. */
5665 md_show_usage (FILE *stream
)
5669 -32addr treat addresses as 32-bit values\n\
5670 -F lack floating point instructions support\n\
5671 -mev4 | -mev45 | -mev5 | -mev56 | -mpca56 | -mev6 | -mev67 | -mev68 | -mall\n\
5672 specify variant of Alpha architecture\n\
5673 -m21064 | -m21066 | -m21164 | -m21164a | -m21164pc | -m21264 | -m21264a | -m21264b\n\
5674 these variants include PALcode opcodes\n"),
5679 -+ encode (don't truncate) names longer than 64 characters\n\
5680 -H show new symbol after hash truncation\n\
5681 -replace/-noreplace enable or disable the optimization of procedure calls\n"),
5686 /* Decide from what point a pc-relative relocation is relative to,
5687 relative to the pc-relative fixup. Er, relatively speaking. */
5690 md_pcrel_from (fixS
*fixP
)
5692 valueT addr
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
5694 switch (fixP
->fx_r_type
)
5696 case BFD_RELOC_23_PCREL_S2
:
5697 case BFD_RELOC_ALPHA_HINT
:
5698 case BFD_RELOC_ALPHA_BRSGP
:
5705 /* Attempt to simplify or even eliminate a fixup. The return value is
5706 ignored; perhaps it was once meaningful, but now it is historical.
5707 To indicate that a fixup has been eliminated, set fixP->fx_done.
5709 For ELF, here it is that we transform the GPDISP_HI16 reloc we used
5710 internally into the GPDISP reloc used externally. We had to do
5711 this so that we'd have the GPDISP_LO16 reloc as a tag to compute
5712 the distance to the "lda" instruction for setting the addend to
5716 md_apply_fix (fixS
*fixP
, valueT
* valP
, segT seg
)
5718 char * const fixpos
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
5719 valueT value
= * valP
;
5720 unsigned image
, size
;
5722 switch (fixP
->fx_r_type
)
5724 /* The GPDISP relocations are processed internally with a symbol
5725 referring to the current function's section; we need to drop
5726 in a value which, when added to the address of the start of
5727 the function, gives the desired GP. */
5728 case BFD_RELOC_ALPHA_GPDISP_HI16
:
5730 fixS
*next
= fixP
->fx_next
;
5732 /* With user-specified !gpdisp relocations, we can be missing
5733 the matching LO16 reloc. We will have already issued an
5736 fixP
->fx_offset
= (next
->fx_frag
->fr_address
+ next
->fx_where
5737 - fixP
->fx_frag
->fr_address
- fixP
->fx_where
);
5739 value
= (value
- sign_extend_16 (value
)) >> 16;
5742 fixP
->fx_r_type
= BFD_RELOC_ALPHA_GPDISP
;
5746 case BFD_RELOC_ALPHA_GPDISP_LO16
:
5747 value
= sign_extend_16 (value
);
5748 fixP
->fx_offset
= 0;
5754 fixP
->fx_addsy
= section_symbol (seg
);
5755 md_number_to_chars (fixpos
, value
, 2);
5760 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
5766 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
5772 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
5776 if (fixP
->fx_pcrel
== 0 && fixP
->fx_addsy
== 0)
5778 md_number_to_chars (fixpos
, value
, size
);
5784 case BFD_RELOC_GPREL32
:
5785 assert (fixP
->fx_subsy
== alpha_gp_symbol
);
5787 /* FIXME: inherited this obliviousness of `value' -- why? */
5788 md_number_to_chars (fixpos
, -alpha_gp_value
, 4);
5791 case BFD_RELOC_GPREL32
:
5793 case BFD_RELOC_GPREL16
:
5794 case BFD_RELOC_ALPHA_GPREL_HI16
:
5795 case BFD_RELOC_ALPHA_GPREL_LO16
:
5798 case BFD_RELOC_23_PCREL_S2
:
5799 if (fixP
->fx_pcrel
== 0 && fixP
->fx_addsy
== 0)
5801 image
= bfd_getl32 (fixpos
);
5802 image
= (image
& ~0x1FFFFF) | ((value
>> 2) & 0x1FFFFF);
5807 case BFD_RELOC_ALPHA_HINT
:
5808 if (fixP
->fx_pcrel
== 0 && fixP
->fx_addsy
== 0)
5810 image
= bfd_getl32 (fixpos
);
5811 image
= (image
& ~0x3FFF) | ((value
>> 2) & 0x3FFF);
5817 case BFD_RELOC_ALPHA_BRSGP
:
5820 case BFD_RELOC_ALPHA_TLSGD
:
5821 case BFD_RELOC_ALPHA_TLSLDM
:
5822 case BFD_RELOC_ALPHA_GOTDTPREL16
:
5823 case BFD_RELOC_ALPHA_DTPREL_HI16
:
5824 case BFD_RELOC_ALPHA_DTPREL_LO16
:
5825 case BFD_RELOC_ALPHA_DTPREL16
:
5826 case BFD_RELOC_ALPHA_GOTTPREL16
:
5827 case BFD_RELOC_ALPHA_TPREL_HI16
:
5828 case BFD_RELOC_ALPHA_TPREL_LO16
:
5829 case BFD_RELOC_ALPHA_TPREL16
:
5831 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
5836 case BFD_RELOC_ALPHA_LITERAL
:
5837 md_number_to_chars (fixpos
, value
, 2);
5840 case BFD_RELOC_ALPHA_ELF_LITERAL
:
5841 case BFD_RELOC_ALPHA_LITUSE
:
5842 case BFD_RELOC_ALPHA_LINKAGE
:
5843 case BFD_RELOC_ALPHA_CODEADDR
:
5847 case BFD_RELOC_ALPHA_NOP
:
5848 value
-= (8 + 4); /* PC-relative, base is jsr+4. */
5850 /* From B.4.5.2 of the OpenVMS Linker Utility Manual:
5851 "Finally, the ETIR$C_STC_BSR command passes the same address
5852 as ETIR$C_STC_NOP (so that they will fail or succeed together),
5853 and the same test is done again." */
5854 if (S_GET_SEGMENT (fixP
->fx_addsy
) == undefined_section
)
5856 fixP
->fx_addnumber
= -value
;
5860 if ((abs (value
) >> 2) & ~0xfffff)
5864 /* Change to a nop. */
5869 case BFD_RELOC_ALPHA_LDA
:
5870 /* fixup_segment sets fixP->fx_addsy to NULL when it can pre-compute
5871 the value for an O_subtract. */
5873 && S_GET_SEGMENT (fixP
->fx_addsy
) == undefined_section
)
5875 fixP
->fx_addnumber
= symbol_get_bfdsym (fixP
->fx_subsy
)->value
;
5879 if ((abs (value
)) & ~0x7fff)
5883 /* Change to an lda. */
5884 image
= 0x237B0000 | (value
& 0xFFFF);
5888 case BFD_RELOC_ALPHA_BSR
:
5889 case BFD_RELOC_ALPHA_BOH
:
5890 value
-= 4; /* PC-relative, base is jsr+4. */
5892 /* See comment in the BFD_RELOC_ALPHA_NOP case above. */
5893 if (S_GET_SEGMENT (fixP
->fx_addsy
) == undefined_section
)
5895 fixP
->fx_addnumber
= -value
;
5899 if ((abs (value
) >> 2) & ~0xfffff)
5902 if (fixP
->fx_r_type
== BFD_RELOC_ALPHA_BOH
)
5905 image
= bfd_getl32(fixpos
);
5906 image
= (image
& ~0x3FFF) | ((value
>> 2) & 0x3FFF);
5913 /* Change to a branch. */
5914 image
= 0xD3400000 | ((value
>> 2) & 0x1FFFFF);
5919 case BFD_RELOC_VTABLE_INHERIT
:
5920 case BFD_RELOC_VTABLE_ENTRY
:
5925 const struct alpha_operand
*operand
;
5927 if ((int) fixP
->fx_r_type
>= 0)
5928 as_fatal (_("unhandled relocation type %s"),
5929 bfd_get_reloc_code_name (fixP
->fx_r_type
));
5931 assert (-(int) fixP
->fx_r_type
< (int) alpha_num_operands
);
5932 operand
= &alpha_operands
[-(int) fixP
->fx_r_type
];
5934 /* The rest of these fixups only exist internally during symbol
5935 resolution and have no representation in the object file.
5936 Therefore they must be completely resolved as constants. */
5938 if (fixP
->fx_addsy
!= 0
5939 && S_GET_SEGMENT (fixP
->fx_addsy
) != absolute_section
)
5940 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
5941 _("non-absolute expression in constant field"));
5943 image
= bfd_getl32 (fixpos
);
5944 image
= insert_operand (image
, operand
, (offsetT
) value
,
5945 fixP
->fx_file
, fixP
->fx_line
);
5950 if (fixP
->fx_addsy
!= 0 || fixP
->fx_pcrel
!= 0)
5954 as_warn_where (fixP
->fx_file
, fixP
->fx_line
,
5955 _("type %d reloc done?\n"), (int) fixP
->fx_r_type
);
5960 md_number_to_chars (fixpos
, image
, 4);
5966 /* Look for a register name in the given symbol. */
5969 md_undefined_symbol (char *name
)
5973 int is_float
= 0, num
;
5978 if (name
[1] == 'p' && name
[2] == '\0')
5979 return alpha_register_table
[AXP_REG_FP
];
5984 if (!ISDIGIT (*++name
))
5988 case '0': case '1': case '2': case '3': case '4':
5989 case '5': case '6': case '7': case '8': case '9':
5990 if (name
[1] == '\0')
5991 num
= name
[0] - '0';
5992 else if (name
[0] != '0' && ISDIGIT (name
[1]) && name
[2] == '\0')
5994 num
= (name
[0] - '0') * 10 + name
[1] - '0';
6001 if (!alpha_noat_on
&& (num
+ is_float
) == AXP_REG_AT
)
6002 as_warn (_("Used $at without \".set noat\""));
6003 return alpha_register_table
[num
+ is_float
];
6006 if (name
[1] == 't' && name
[2] == '\0')
6009 as_warn (_("Used $at without \".set noat\""));
6010 return alpha_register_table
[AXP_REG_AT
];
6015 if (name
[1] == 'p' && name
[2] == '\0')
6016 return alpha_register_table
[alpha_gp_register
];
6020 if (name
[1] == 'p' && name
[2] == '\0')
6021 return alpha_register_table
[AXP_REG_SP
];
6029 /* @@@ Magic ECOFF bits. */
6032 alpha_frob_ecoff_data (void)
6035 /* $zero and $f31 are read-only. */
6036 alpha_gprmask
&= ~1;
6037 alpha_fprmask
&= ~1;
6041 /* Hook to remember a recently defined label so that the auto-align
6042 code can adjust the symbol after we know what alignment will be
6046 alpha_define_label (symbolS
*sym
)
6048 alpha_insn_label
= sym
;
6050 dwarf2_emit_label (sym
);
6054 /* Return true if we must always emit a reloc for a type and false if
6055 there is some hope of resolving it at assembly time. */
6058 alpha_force_relocation (fixS
*f
)
6060 if (alpha_flag_relax
)
6063 switch (f
->fx_r_type
)
6065 case BFD_RELOC_ALPHA_GPDISP_HI16
:
6066 case BFD_RELOC_ALPHA_GPDISP_LO16
:
6067 case BFD_RELOC_ALPHA_GPDISP
:
6068 case BFD_RELOC_ALPHA_LITERAL
:
6069 case BFD_RELOC_ALPHA_ELF_LITERAL
:
6070 case BFD_RELOC_ALPHA_LITUSE
:
6071 case BFD_RELOC_GPREL16
:
6072 case BFD_RELOC_GPREL32
:
6073 case BFD_RELOC_ALPHA_GPREL_HI16
:
6074 case BFD_RELOC_ALPHA_GPREL_LO16
:
6075 case BFD_RELOC_ALPHA_LINKAGE
:
6076 case BFD_RELOC_ALPHA_CODEADDR
:
6077 case BFD_RELOC_ALPHA_BRSGP
:
6078 case BFD_RELOC_ALPHA_TLSGD
:
6079 case BFD_RELOC_ALPHA_TLSLDM
:
6080 case BFD_RELOC_ALPHA_GOTDTPREL16
:
6081 case BFD_RELOC_ALPHA_DTPREL_HI16
:
6082 case BFD_RELOC_ALPHA_DTPREL_LO16
:
6083 case BFD_RELOC_ALPHA_DTPREL16
:
6084 case BFD_RELOC_ALPHA_GOTTPREL16
:
6085 case BFD_RELOC_ALPHA_TPREL_HI16
:
6086 case BFD_RELOC_ALPHA_TPREL_LO16
:
6087 case BFD_RELOC_ALPHA_TPREL16
:
6089 case BFD_RELOC_ALPHA_NOP
:
6090 case BFD_RELOC_ALPHA_BSR
:
6091 case BFD_RELOC_ALPHA_LDA
:
6092 case BFD_RELOC_ALPHA_BOH
:
6100 return generic_force_reloc (f
);
6103 /* Return true if we can partially resolve a relocation now. */
6106 alpha_fix_adjustable (fixS
*f
)
6108 /* Are there any relocation types for which we must generate a
6109 reloc but we can adjust the values contained within it? */
6110 switch (f
->fx_r_type
)
6112 case BFD_RELOC_ALPHA_GPDISP_HI16
:
6113 case BFD_RELOC_ALPHA_GPDISP_LO16
:
6114 case BFD_RELOC_ALPHA_GPDISP
:
6117 case BFD_RELOC_ALPHA_LITERAL
:
6118 case BFD_RELOC_ALPHA_ELF_LITERAL
:
6119 case BFD_RELOC_ALPHA_LITUSE
:
6120 case BFD_RELOC_ALPHA_LINKAGE
:
6121 case BFD_RELOC_ALPHA_CODEADDR
:
6124 case BFD_RELOC_VTABLE_ENTRY
:
6125 case BFD_RELOC_VTABLE_INHERIT
:
6128 case BFD_RELOC_GPREL16
:
6129 case BFD_RELOC_GPREL32
:
6130 case BFD_RELOC_ALPHA_GPREL_HI16
:
6131 case BFD_RELOC_ALPHA_GPREL_LO16
:
6132 case BFD_RELOC_23_PCREL_S2
:
6136 case BFD_RELOC_ALPHA_HINT
:
6139 case BFD_RELOC_ALPHA_TLSGD
:
6140 case BFD_RELOC_ALPHA_TLSLDM
:
6141 case BFD_RELOC_ALPHA_GOTDTPREL16
:
6142 case BFD_RELOC_ALPHA_DTPREL_HI16
:
6143 case BFD_RELOC_ALPHA_DTPREL_LO16
:
6144 case BFD_RELOC_ALPHA_DTPREL16
:
6145 case BFD_RELOC_ALPHA_GOTTPREL16
:
6146 case BFD_RELOC_ALPHA_TPREL_HI16
:
6147 case BFD_RELOC_ALPHA_TPREL_LO16
:
6148 case BFD_RELOC_ALPHA_TPREL16
:
6149 /* ??? No idea why we can't return a reference to .tbss+10, but
6150 we're preventing this in the other assemblers. Follow for now. */
6154 case BFD_RELOC_ALPHA_BRSGP
:
6155 /* If we have a BRSGP reloc to a local symbol, adjust it to BRADDR and
6156 let it get resolved at assembly time. */
6158 symbolS
*sym
= f
->fx_addsy
;
6162 if (generic_force_reloc (f
))
6165 switch (S_GET_OTHER (sym
) & STO_ALPHA_STD_GPLOAD
)
6167 case STO_ALPHA_NOPV
:
6169 case STO_ALPHA_STD_GPLOAD
:
6173 if (S_IS_LOCAL (sym
))
6176 name
= S_GET_NAME (sym
);
6177 as_bad_where (f
->fx_file
, f
->fx_line
,
6178 _("!samegp reloc against symbol without .prologue: %s"),
6182 f
->fx_r_type
= BFD_RELOC_23_PCREL_S2
;
6183 f
->fx_offset
+= offset
;
6188 case BFD_RELOC_ALPHA_NOP
:
6189 case BFD_RELOC_ALPHA_BSR
:
6190 case BFD_RELOC_ALPHA_LDA
:
6191 case BFD_RELOC_ALPHA_BOH
:
6200 /* Generate the BFD reloc to be stuck in the object file from the
6201 fixup used internally in the assembler. */
6204 tc_gen_reloc (asection
*sec ATTRIBUTE_UNUSED
,
6209 reloc
= xmalloc (sizeof (* reloc
));
6210 reloc
->sym_ptr_ptr
= xmalloc (sizeof (asymbol
*));
6211 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
6212 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
6214 /* Make sure none of our internal relocations make it this far.
6215 They'd better have been fully resolved by this point. */
6216 assert ((int) fixp
->fx_r_type
> 0);
6218 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, fixp
->fx_r_type
);
6219 if (reloc
->howto
== NULL
)
6221 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
6222 _("cannot represent `%s' relocation in object file"),
6223 bfd_get_reloc_code_name (fixp
->fx_r_type
));
6227 if (!fixp
->fx_pcrel
!= !reloc
->howto
->pc_relative
)
6228 as_fatal (_("internal error? cannot generate `%s' relocation"),
6229 bfd_get_reloc_code_name (fixp
->fx_r_type
));
6231 assert (!fixp
->fx_pcrel
== !reloc
->howto
->pc_relative
);
6234 if (fixp
->fx_r_type
== BFD_RELOC_ALPHA_LITERAL
)
6235 /* Fake out bfd_perform_relocation. sigh. */
6236 reloc
->addend
= -alpha_gp_value
;
6240 reloc
->addend
= fixp
->fx_offset
;
6242 /* Ohhh, this is ugly. The problem is that if this is a local global
6243 symbol, the relocation will entirely be performed at link time, not
6244 at assembly time. bfd_perform_reloc doesn't know about this sort
6245 of thing, and as a result we need to fake it out here. */
6246 if ((S_IS_EXTERNAL (fixp
->fx_addsy
) || S_IS_WEAK (fixp
->fx_addsy
)
6247 || (S_GET_SEGMENT (fixp
->fx_addsy
)->flags
& SEC_MERGE
)
6248 || (S_GET_SEGMENT (fixp
->fx_addsy
)->flags
& SEC_THREAD_LOCAL
))
6249 && !S_IS_COMMON (fixp
->fx_addsy
))
6250 reloc
->addend
-= symbol_get_bfdsym (fixp
->fx_addsy
)->value
;
6255 switch (fixp
->fx_r_type
)
6257 struct evax_private_udata_struct
*udata
;
6261 case BFD_RELOC_ALPHA_LINKAGE
:
6262 reloc
->addend
= fixp
->fx_addnumber
;
6265 case BFD_RELOC_ALPHA_NOP
:
6266 case BFD_RELOC_ALPHA_BSR
:
6267 case BFD_RELOC_ALPHA_LDA
:
6268 case BFD_RELOC_ALPHA_BOH
:
6269 pname
= symbol_get_bfdsym (fixp
->fx_addsy
)->name
;
6271 /* We need the non-suffixed name of the procedure. Beware that
6272 the main symbol might be equated so look it up and take its name. */
6273 pname_len
= strlen (pname
);
6274 if (pname_len
> 4 && strcmp (pname
+ pname_len
- 4, "..en") == 0)
6277 char *my_pname
= xstrdup (pname
);
6278 my_pname
[pname_len
- 4] = 0;
6279 sym
= symbol_find (my_pname
);
6282 while (symbol_equated_reloc_p (sym
))
6284 symbolS
*n
= symbol_get_value_expression (sym
)->X_add_symbol
;
6286 /* We must avoid looping, as that can occur with a badly
6292 pname
= symbol_get_bfdsym (sym
)->name
;
6295 udata
= (struct evax_private_udata_struct
*)
6296 xmalloc (sizeof (struct evax_private_udata_struct
));
6297 udata
->enbsym
= symbol_get_bfdsym (fixp
->fx_addsy
);
6298 udata
->bsym
= symbol_get_bfdsym (fixp
->tc_fix_data
.info
->psym
);
6299 udata
->origname
= (char *)pname
;
6300 udata
->lkindex
= ((struct evax_private_udata_struct
*)
6301 symbol_get_bfdsym (fixp
->tc_fix_data
.info
->sym
)->udata
.p
)->lkindex
;
6302 reloc
->sym_ptr_ptr
= (void *)udata
;
6303 reloc
->addend
= fixp
->fx_addnumber
;
6313 /* Parse a register name off of the input_line and return a register
6314 number. Gets md_undefined_symbol above to do the register name
6317 Only called as a part of processing the ECOFF .frame directive. */
6320 tc_get_register (int frame ATTRIBUTE_UNUSED
)
6322 int framereg
= AXP_REG_SP
;
6325 if (*input_line_pointer
== '$')
6327 char *s
= input_line_pointer
;
6328 char c
= get_symbol_end ();
6329 symbolS
*sym
= md_undefined_symbol (s
);
6331 *strchr (s
, '\0') = c
;
6332 if (sym
&& (framereg
= S_GET_VALUE (sym
)) <= 31)
6335 as_warn (_("frame reg expected, using $%d."), framereg
);
6338 note_gpreg (framereg
);
6342 /* This is called before the symbol table is processed. In order to
6343 work with gcc when using mips-tfile, we must keep all local labels.
6344 However, in other cases, we want to discard them. If we were
6345 called with -g, but we didn't see any debugging information, it may
6346 mean that gcc is smuggling debugging information through to
6347 mips-tfile, in which case we must generate all local labels. */
6352 alpha_frob_file_before_adjust (void)
6354 if (alpha_debug
!= 0
6355 && ! ecoff_debugging_seen
)
6356 flag_keep_locals
= 1;
6359 #endif /* OBJ_ECOFF */
6361 /* The Alpha has support for some VAX floating point types, as well as for
6362 IEEE floating point. We consider IEEE to be the primary floating point
6363 format, and sneak in the VAX floating point support here. */
6364 #include "config/atof-vax.c"