1 /* tc-s390.c -- Assemble for the S390
2 Copyright (C) 2000-2021 Free Software Foundation, Inc.
3 Contributed by Martin Schwidefsky (schwidefsky@de.ibm.com).
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 #include "safe-ctype.h"
25 #include "dwarf2dbg.h"
26 #include "dw2gencfi.h"
28 #include "opcode/s390.h"
31 /* The default architecture. */
33 #define DEFAULT_ARCH "s390"
35 static const char *default_arch
= DEFAULT_ARCH
;
36 /* Either 32 or 64, selects file format. */
37 static int s390_arch_size
= 0;
39 /* If no -march option was given default to the highest available CPU.
40 Since with S/390 a newer CPU always supports everything from its
41 predecessors this will accept every valid asm input. */
42 static unsigned int current_cpu
= S390_OPCODE_MAXCPU
- 1;
43 /* All facilities are enabled by default. */
44 static unsigned int current_flags
= S390_INSTR_FLAG_FACILITY_MASK
;
45 /* The mode mask default is picked in init_default_arch depending on
47 static unsigned int current_mode_mask
= 0;
49 /* Set to TRUE if the highgprs flag in the ELF header needs to be set
50 for the output file. */
51 static bfd_boolean set_highgprs_p
= FALSE
;
53 /* Whether to use user friendly register names. Default is TRUE. */
54 #ifndef TARGET_REG_NAMES_P
55 #define TARGET_REG_NAMES_P TRUE
58 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
60 /* Set to TRUE if we want to warn about zero base/index registers. */
61 static bfd_boolean warn_areg_zero
= FALSE
;
63 /* Generic assembler global variables which must be defined by all
66 const char comment_chars
[] = "#";
68 /* Characters which start a comment at the beginning of a line. */
69 const char line_comment_chars
[] = "#";
71 /* Characters which may be used to separate multiple commands on a
73 const char line_separator_chars
[] = ";";
75 /* Characters which are used to indicate an exponent in a floating
77 const char EXP_CHARS
[] = "eE";
79 /* Characters which mean that a number is a floating point constant,
81 const char FLT_CHARS
[] = "dD";
83 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
84 int s390_cie_data_alignment
;
86 /* The target specific pseudo-ops which we support. */
88 /* Define the prototypes for the pseudo-ops */
89 static void s390_byte (int);
90 static void s390_elf_cons (int);
91 static void s390_bss (int);
92 static void s390_insn (int);
93 static void s390_literals (int);
94 static void s390_machine (int);
95 static void s390_machinemode (int);
97 const pseudo_typeS md_pseudo_table
[] =
99 { "align", s_align_bytes
, 0 },
100 /* Pseudo-ops which must be defined. */
101 { "bss", s390_bss
, 0 },
102 { "insn", s390_insn
, 0 },
103 /* Pseudo-ops which must be overridden. */
104 { "byte", s390_byte
, 0 },
105 { "short", s390_elf_cons
, 2 },
106 { "long", s390_elf_cons
, 4 },
107 { "quad", s390_elf_cons
, 8 },
108 { "ltorg", s390_literals
, 0 },
109 { "string", stringer
, 8 + 1 },
110 { "machine", s390_machine
, 0 },
111 { "machinemode", s390_machinemode
, 0 },
115 /* Given NAME, find the register number associated with that name, return
116 the integer value associated with the given name or -1 on failure. */
119 reg_name_search (const char *name
)
123 if (strcasecmp (name
, "lit") == 0)
126 if (strcasecmp (name
, "sp") == 0)
129 if (name
[0] != 'a' && name
[0] != 'c' && name
[0] != 'f'
130 && name
[0] != 'r' && name
[0] != 'v')
133 if (ISDIGIT (name
[1]))
136 if (ISDIGIT (name
[2]))
137 val
= val
* 10 + name
[2] - '0';
140 if ((name
[0] != 'v' && val
> 15) || val
> 31)
148 * Summary of register_name().
150 * in: Input_line_pointer points to 1st char of operand.
152 * out: A expressionS.
153 * The operand may have been a register: in this case, X_op == O_register,
154 * X_add_number is set to the register number, and truth is returned.
155 * Input_line_pointer->(next non-blank) char after operand, or is in its
160 register_name (expressionS
*expressionP
)
167 /* Find the spelling of the operand. */
168 start
= name
= input_line_pointer
;
169 if (name
[0] == '%' && ISALPHA (name
[1]))
170 name
= ++input_line_pointer
;
174 c
= get_symbol_name (&name
);
175 reg_number
= reg_name_search (name
);
177 /* Put back the delimiting char. */
178 (void) restore_line_pointer (c
);
180 /* Look to see if it's in the register table. */
183 expressionP
->X_op
= O_register
;
184 expressionP
->X_add_number
= reg_number
;
186 /* Make the rest nice. */
187 expressionP
->X_add_symbol
= NULL
;
188 expressionP
->X_op_symbol
= NULL
;
192 /* Reset the line as if we had not done anything. */
193 input_line_pointer
= start
;
197 /* Local variables. */
199 /* Opformat hash table. */
200 static htab_t s390_opformat_hash
;
202 /* Opcode hash table. */
203 static htab_t s390_opcode_hash
= NULL
;
205 /* Flags to set in the elf header */
206 static flagword s390_flags
= 0;
208 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
210 #ifndef WORKING_DOT_WORD
211 int md_short_jump_size
= 4;
212 int md_long_jump_size
= 4;
215 const char *md_shortopts
= "A:m:kVQ:";
216 struct option md_longopts
[] = {
217 {NULL
, no_argument
, NULL
, 0}
219 size_t md_longopts_size
= sizeof (md_longopts
);
221 /* Initialize the default opcode arch and word size from the default
222 architecture name if not specified by an option. */
224 init_default_arch (void)
226 if (strcmp (default_arch
, "s390") == 0)
228 if (s390_arch_size
== 0)
231 else if (strcmp (default_arch
, "s390x") == 0)
233 if (s390_arch_size
== 0)
237 as_fatal (_("Invalid default architecture, broken assembler."));
239 if (current_mode_mask
== 0)
241 /* Default to z/Architecture mode if the CPU supports it. */
242 if (current_cpu
< S390_OPCODE_Z900
)
243 current_mode_mask
= 1 << S390_OPCODE_ESA
;
245 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
249 /* Called by TARGET_FORMAT. */
251 s390_target_format (void)
253 /* We don't get a chance to initialize anything before we're called,
254 so handle that now. */
255 init_default_arch ();
257 return s390_arch_size
== 64 ? "elf64-s390" : "elf32-s390";
260 /* Map a cpu string ARG as given with -march= or .machine to the respective
261 enum s390_opcode_cpu_val value. If ALLOW_EXTENSIONS is TRUE, the cpu name
262 can be followed by a list of cpu facility flags each beginning with the
263 character '+'. The active cpu flags are returned through *RET_FLAGS.
264 In case of an error, S390_OPCODE_MAXCPU is returned. */
267 s390_parse_cpu (const char * arg
,
268 unsigned int * ret_flags
,
269 bfd_boolean allow_extensions
)
274 unsigned int name_len
;
275 const char * alt_name
;
276 unsigned int alt_name_len
;
278 } cpu_table
[S390_OPCODE_MAXCPU
] =
280 { STRING_COMMA_LEN ("g5"), STRING_COMMA_LEN ("arch3"), 0 },
281 { STRING_COMMA_LEN ("g6"), STRING_COMMA_LEN (""), 0 },
282 { STRING_COMMA_LEN ("z900"), STRING_COMMA_LEN ("arch5"), 0 },
283 { STRING_COMMA_LEN ("z990"), STRING_COMMA_LEN ("arch6"), 0 },
284 { STRING_COMMA_LEN ("z9-109"), STRING_COMMA_LEN (""), 0 },
285 { STRING_COMMA_LEN ("z9-ec"), STRING_COMMA_LEN ("arch7"), 0 },
286 { STRING_COMMA_LEN ("z10"), STRING_COMMA_LEN ("arch8"), 0 },
287 { STRING_COMMA_LEN ("z196"), STRING_COMMA_LEN ("arch9"), 0 },
288 { STRING_COMMA_LEN ("zEC12"), STRING_COMMA_LEN ("arch10"),
289 S390_INSTR_FLAG_HTM
},
290 { STRING_COMMA_LEN ("z13"), STRING_COMMA_LEN ("arch11"),
291 S390_INSTR_FLAG_HTM
| S390_INSTR_FLAG_VX
},
292 { STRING_COMMA_LEN ("z14"), STRING_COMMA_LEN ("arch12"),
293 S390_INSTR_FLAG_HTM
| S390_INSTR_FLAG_VX
},
294 { STRING_COMMA_LEN ("z15"), STRING_COMMA_LEN ("arch13"),
295 S390_INSTR_FLAG_HTM
| S390_INSTR_FLAG_VX
}
304 { "htm", S390_INSTR_FLAG_HTM
, TRUE
},
305 { "nohtm", S390_INSTR_FLAG_HTM
, FALSE
},
306 { "vx", S390_INSTR_FLAG_VX
, TRUE
},
307 { "novx", S390_INSTR_FLAG_VX
, FALSE
}
312 icpu
= S390_OPCODE_MAXCPU
;
313 if (strncmp (arg
, "all", 3) == 0 && (arg
[3] == 0 || arg
[3] == '+'))
315 icpu
= S390_OPCODE_MAXCPU
- 1;
320 for (icpu
= 0; icpu
< S390_OPCODE_MAXCPU
; icpu
++)
322 unsigned int l
, l_alt
;
324 l
= cpu_table
[icpu
].name_len
;
326 if (strncmp (arg
, cpu_table
[icpu
].name
, l
) == 0
327 && (arg
[l
] == 0 || arg
[l
] == '+'))
333 l_alt
= cpu_table
[icpu
].alt_name_len
;
336 && strncmp (arg
, cpu_table
[icpu
].alt_name
, l_alt
) == 0
337 && (arg
[l_alt
] == 0 || arg
[l_alt
] == '+'))
345 if (icpu
== S390_OPCODE_MAXCPU
)
346 return S390_OPCODE_MAXCPU
;
348 ilp_bak
= input_line_pointer
;
349 if (icpu
!= S390_OPCODE_MAXCPU
)
351 input_line_pointer
= (char *) arg
;
352 *ret_flags
= (cpu_table
[icpu
].flags
& S390_INSTR_FLAG_FACILITY_MASK
);
354 while (*input_line_pointer
== '+' && allow_extensions
)
360 input_line_pointer
++;
361 c
= get_symbol_name (&sym
);
362 for (iflag
= 0; iflag
< ARRAY_SIZE (cpu_flags
); iflag
++)
364 if (strcmp (sym
, cpu_flags
[iflag
].name
) == 0)
366 if (cpu_flags
[iflag
].on
)
367 *ret_flags
|= cpu_flags
[iflag
].mask
;
369 *ret_flags
&= ~cpu_flags
[iflag
].mask
;
373 if (iflag
== ARRAY_SIZE (cpu_flags
))
374 as_bad (_("no such machine extension `%s'"), sym
- 1);
375 *input_line_pointer
= c
;
376 if (iflag
== ARRAY_SIZE (cpu_flags
))
383 if (*input_line_pointer
!= 0 && *input_line_pointer
!= '\n')
385 as_bad (_("junk at end of machine string, first unrecognized character"
386 " is `%c'"), *input_line_pointer
);
387 icpu
= S390_OPCODE_MAXCPU
;
389 input_line_pointer
= ilp_bak
;
395 md_parse_option (int c
, const char *arg
)
399 /* -k: Ignore for FreeBSD compatibility. */
403 if (arg
!= NULL
&& strcmp (arg
, "regnames") == 0)
406 else if (arg
!= NULL
&& strcmp (arg
, "no-regnames") == 0)
409 else if (arg
!= NULL
&& strcmp (arg
, "warn-areg-zero") == 0)
410 warn_areg_zero
= TRUE
;
412 else if (arg
!= NULL
&& strcmp (arg
, "31") == 0)
415 else if (arg
!= NULL
&& strcmp (arg
, "64") == 0)
418 else if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
419 current_mode_mask
= 1 << S390_OPCODE_ESA
;
421 else if (arg
!= NULL
&& strcmp (arg
, "zarch") == 0)
423 if (s390_arch_size
== 32)
424 set_highgprs_p
= TRUE
;
425 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
428 else if (arg
!= NULL
&& strncmp (arg
, "arch=", 5) == 0)
430 current_cpu
= s390_parse_cpu (arg
+ 5, ¤t_flags
, FALSE
);
431 if (current_cpu
== S390_OPCODE_MAXCPU
)
433 as_bad (_("invalid switch -m%s"), arg
);
440 as_bad (_("invalid switch -m%s"), arg
);
446 /* Option -A is deprecated. Still available for compatibility. */
447 if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
448 current_cpu
= S390_OPCODE_G5
;
449 else if (arg
!= NULL
&& strcmp (arg
, "esame") == 0)
450 current_cpu
= S390_OPCODE_Z900
;
452 as_bad (_("invalid architecture -A%s"), arg
);
455 /* -V: SVR4 argument to print version ID. */
460 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
461 should be emitted or not. FIXME: Not implemented. */
473 md_show_usage (FILE *stream
)
475 fprintf (stream
, _("\
477 -mregnames Allow symbolic names for registers\n\
478 -mwarn-areg-zero Warn about zero base/index registers\n\
479 -mno-regnames Do not allow symbolic names for registers\n\
480 -m31 Set file format to 31 bit format\n\
481 -m64 Set file format to 64 bit format\n"));
482 fprintf (stream
, _("\
483 -V print assembler version number\n\
484 -Qy, -Qn ignored\n"));
487 /* Generate the hash table mapping mnemonics to struct s390_opcode.
488 This table is built at startup and whenever the CPU level is
489 changed using .machine. */
492 s390_setup_opcodes (void)
494 const struct s390_opcode
*op
;
495 const struct s390_opcode
*op_end
;
496 bfd_boolean dup_insn
= FALSE
;
498 if (s390_opcode_hash
!= NULL
)
499 htab_delete (s390_opcode_hash
);
501 /* Insert the opcodes into a hash table. */
502 s390_opcode_hash
= str_htab_create ();
504 op_end
= s390_opcodes
+ s390_num_opcodes
;
505 for (op
= s390_opcodes
; op
< op_end
; op
++)
509 while (op
< op_end
- 1 && strcmp(op
->name
, op
[1].name
) == 0)
511 if (op
->min_cpu
<= current_cpu
&& (op
->modes
& current_mode_mask
))
516 if ((op
->modes
& current_mode_mask
) == 0)
518 else if ((op
->flags
& S390_INSTR_FLAG_FACILITY_MASK
) == 0)
520 /* Opcodes that do not belong to a specific facility are enabled if
521 present in the selected cpu. */
522 use_opcode
= (op
->min_cpu
<= current_cpu
);
528 /* Opcodes of a specific facility are enabled if the facility is
529 enabled. Note: only some facilities are represented as flags. */
530 f
= (op
->flags
& S390_INSTR_FLAG_FACILITY_MASK
);
531 use_opcode
= ((f
& current_flags
) == f
);
534 && str_hash_insert (s390_opcode_hash
, op
->name
, op
, 0) != NULL
)
536 as_bad (_("duplicate %s"), op
->name
);
540 while (op
< op_end
- 1 && strcmp (op
->name
, op
[1].name
) == 0)
548 /* This function is called when the assembler starts up. It is called
549 after the options have been parsed and the output file has been
555 const struct s390_opcode
*op
;
556 const struct s390_opcode
*op_end
;
558 /* Give a warning if the combination -m64-bit and -Aesa is used. */
559 if (s390_arch_size
== 64 && current_cpu
< S390_OPCODE_Z900
)
560 as_warn (_("The 64 bit file format is used without esame instructions."));
562 s390_cie_data_alignment
= -s390_arch_size
/ 8;
564 /* Set the ELF flags if desired. */
566 bfd_set_private_flags (stdoutput
, s390_flags
);
568 /* Insert the opcode formats into a hash table. */
569 s390_opformat_hash
= str_htab_create ();
571 op_end
= s390_opformats
+ s390_num_opformats
;
572 for (op
= s390_opformats
; op
< op_end
; op
++)
573 if (str_hash_insert (s390_opformat_hash
, op
->name
, op
, 0) != NULL
)
574 as_fatal (_("duplicate %s"), op
->name
);
576 s390_setup_opcodes ();
578 record_alignment (text_section
, 2);
579 record_alignment (data_section
, 2);
580 record_alignment (bss_section
, 2);
583 /* Called after all assembly has been done. */
587 if (s390_arch_size
== 64)
588 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_64
);
590 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_31
);
593 /* Insert an operand value into an instruction. */
596 s390_insert_operand (unsigned char *insn
,
597 const struct s390_operand
*operand
,
605 if (operand
->flags
& (S390_OPERAND_SIGNED
|S390_OPERAND_PCREL
))
609 max
= ((offsetT
) 1 << (operand
->bits
- 1)) - 1;
610 min
= - ((offsetT
) 1 << (operand
->bits
- 1));
611 /* Halve PCREL operands. */
612 if (operand
->flags
& S390_OPERAND_PCREL
)
614 /* Check for underflow / overflow. */
615 if (val
< min
|| val
> max
)
618 _("operand out of range (%s not between %ld and %ld)");
621 if (operand
->flags
& S390_OPERAND_PCREL
)
627 sprint_value (buf
, val
);
628 if (file
== (char *) NULL
)
629 as_bad (err
, buf
, (int) min
, (int) max
);
631 as_bad_where (file
, line
, err
, buf
, (int) min
, (int) max
);
634 /* val is ok, now restrict it to operand->bits bits. */
635 uval
= (addressT
) val
& ((((addressT
) 1 << (operand
->bits
-1)) << 1) - 1);
636 /* val is restrict, now check for special case. */
637 if (operand
->bits
== 20 && operand
->shift
== 20)
638 uval
= (uval
>> 12) | ((uval
& 0xfff) << 8);
644 max
= (((addressT
) 1 << (operand
->bits
- 1)) << 1) - 1;
646 uval
= (addressT
) val
;
648 /* Vector register operands have an additional bit in the RXB
650 if (operand
->flags
& S390_OPERAND_VR
)
651 max
= (max
<< 1) | 1;
653 /* Length x in an instructions has real length x+1. */
654 if (operand
->flags
& S390_OPERAND_LENGTH
)
656 /* Check for underflow / overflow. */
657 if (uval
< min
|| uval
> max
)
659 if (operand
->flags
& S390_OPERAND_LENGTH
)
666 as_bad_value_out_of_range (_("operand"), uval
, (offsetT
) min
, (offsetT
) max
, file
, line
);
672 if (operand
->flags
& S390_OPERAND_VR
)
674 /* Insert the extra bit into the RXB field. */
675 switch (operand
->shift
)
678 insn
[4] |= (uval
& 0x10) >> 1;
681 insn
[4] |= (uval
& 0x10) >> 2;
684 insn
[4] |= (uval
& 0x10) >> 3;
687 insn
[4] |= (uval
& 0x10) >> 4;
693 if (operand
->flags
& S390_OPERAND_OR1
)
695 if (operand
->flags
& S390_OPERAND_OR2
)
697 if (operand
->flags
& S390_OPERAND_OR8
)
700 /* Duplicate the operand at bit pos 12 to 16. */
701 if (operand
->flags
& S390_OPERAND_CP16
)
703 /* Copy VR operand at bit pos 12 to bit pos 16. */
704 insn
[2] |= uval
<< 4;
705 /* Copy the flag in the RXB field. */
706 insn
[4] |= (insn
[4] & 4) >> 1;
709 /* Insert fragments of the operand byte for byte. */
710 offset
= operand
->shift
+ operand
->bits
;
711 uval
<<= (-offset
) & 7;
712 insn
+= (offset
- 1) / 8;
724 bfd_reloc_code_real_type reloc
;
727 /* Parse tls marker and return the desired relocation. */
728 static bfd_reloc_code_real_type
729 s390_tls_suffix (char **str_p
, expressionS
*exp_p
)
731 static struct map_tls mapping
[] =
733 { "tls_load", 8, BFD_RELOC_390_TLS_LOAD
},
734 { "tls_gdcall", 10, BFD_RELOC_390_TLS_GDCALL
},
735 { "tls_ldcall", 10, BFD_RELOC_390_TLS_LDCALL
},
736 { NULL
, 0, BFD_RELOC_UNUSED
}
746 return BFD_RELOC_UNUSED
;
749 while (ISIDNUM (*str
))
753 return BFD_RELOC_UNUSED
;
755 orig_line
= input_line_pointer
;
756 input_line_pointer
= str
;
758 str
= input_line_pointer
;
759 if (&input_line_pointer
!= str_p
)
760 input_line_pointer
= orig_line
;
762 if (exp_p
->X_op
!= O_symbol
)
763 return BFD_RELOC_UNUSED
;
765 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
766 if (len
== ptr
->length
767 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
769 /* Found a matching tls suffix. */
773 return BFD_RELOC_UNUSED
;
776 /* Structure used to hold suffixes. */
787 ELF_SUFFIX_TLS_GOTIE
,
799 elf_suffix_type suffix
;
803 /* Parse @got/@plt/@gotoff. and return the desired relocation. */
804 static elf_suffix_type
805 s390_elf_suffix (char **str_p
, expressionS
*exp_p
)
807 static struct map_bfd mapping
[] =
809 { "got", 3, ELF_SUFFIX_GOT
},
810 { "got12", 5, ELF_SUFFIX_GOT
},
811 { "plt", 3, ELF_SUFFIX_PLT
},
812 { "gotent", 6, ELF_SUFFIX_GOTENT
},
813 { "gotoff", 6, ELF_SUFFIX_GOTOFF
},
814 { "gotplt", 6, ELF_SUFFIX_GOTPLT
},
815 { "pltoff", 6, ELF_SUFFIX_PLTOFF
},
816 { "tlsgd", 5, ELF_SUFFIX_TLS_GD
},
817 { "gotntpoff", 9, ELF_SUFFIX_TLS_GOTIE
},
818 { "indntpoff", 9, ELF_SUFFIX_TLS_IE
},
819 { "tlsldm", 6, ELF_SUFFIX_TLS_LDM
},
820 { "dtpoff", 6, ELF_SUFFIX_TLS_LDO
},
821 { "ntpoff", 6, ELF_SUFFIX_TLS_LE
},
822 { NULL
, 0, ELF_SUFFIX_NONE
}
831 return ELF_SUFFIX_NONE
;
834 while (ISALNUM (*str
))
838 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
839 if (len
== ptr
->length
840 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
842 if (exp_p
->X_add_number
!= 0)
843 as_warn (_("identifier+constant@%s means identifier@%s+constant"),
844 ptr
->string
, ptr
->string
);
845 /* Now check for identifier@suffix+constant. */
846 if (*str
== '-' || *str
== '+')
848 char *orig_line
= input_line_pointer
;
851 input_line_pointer
= str
;
852 expression (&new_exp
);
854 switch (new_exp
.X_op
)
856 case O_constant
: /* X_add_number (a constant expression). */
857 exp_p
->X_add_number
+= new_exp
.X_add_number
;
858 str
= input_line_pointer
;
860 case O_symbol
: /* X_add_symbol + X_add_number. */
861 /* this case is used for e.g. xyz@PLT+.Label. */
862 exp_p
->X_add_number
+= new_exp
.X_add_number
;
863 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
865 str
= input_line_pointer
;
867 case O_uminus
: /* (- X_add_symbol) + X_add_number. */
868 /* this case is used for e.g. xyz@PLT-.Label. */
869 exp_p
->X_add_number
+= new_exp
.X_add_number
;
870 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
871 exp_p
->X_op
= O_subtract
;
872 str
= input_line_pointer
;
878 /* If s390_elf_suffix has not been called with
879 &input_line_pointer as first parameter, we have
880 clobbered the input_line_pointer. We have to
882 if (&input_line_pointer
!= str_p
)
883 input_line_pointer
= orig_line
;
889 return ELF_SUFFIX_NONE
;
892 /* Structure used to hold a literal pool entry. */
895 struct s390_lpe
*next
;
897 FLONUM_TYPE floatnum
; /* used if X_op == O_big && X_add_number <= 0 */
898 LITTLENUM_TYPE bignum
[4]; /* used if X_op == O_big && X_add_number > 0 */
900 bfd_reloc_code_real_type reloc
;
904 static struct s390_lpe
*lpe_free_list
= NULL
;
905 static struct s390_lpe
*lpe_list
= NULL
;
906 static struct s390_lpe
*lpe_list_tail
= NULL
;
907 static symbolS
*lp_sym
= NULL
;
908 static int lp_count
= 0;
909 static int lpe_count
= 0;
912 s390_exp_compare (expressionS
*exp1
, expressionS
*exp2
)
914 if (exp1
->X_op
!= exp2
->X_op
)
919 case O_constant
: /* X_add_number must be equal. */
921 return exp1
->X_add_number
== exp2
->X_add_number
;
924 as_bad (_("Can't handle O_big in s390_exp_compare"));
927 case O_symbol
: /* X_add_symbol & X_add_number must be equal. */
932 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
933 && (exp1
->X_add_number
== exp2
->X_add_number
);
935 case O_multiply
: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
940 case O_bit_inclusive_or
:
942 case O_bit_exclusive_or
:
954 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
955 && (exp1
->X_op_symbol
== exp2
->X_op_symbol
)
956 && (exp1
->X_add_number
== exp2
->X_add_number
);
962 /* Test for @lit and if it's present make an entry in the literal pool and
963 modify the current expression to be an offset into the literal pool. */
964 static elf_suffix_type
965 s390_lit_suffix (char **str_p
, expressionS
*exp_p
, elf_suffix_type suffix
)
967 bfd_reloc_code_real_type reloc
;
971 struct s390_lpe
*lpe
;
975 return suffix
; /* No modification. */
977 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
979 while (ISALNUM (*str
))
982 if (len
!= 4 || strncasecmp (ident
, "lit", 3) != 0
983 || (ident
[3]!='1' && ident
[3]!='2' && ident
[3]!='4' && ident
[3]!='8'))
984 return suffix
; /* no modification */
985 nbytes
= ident
[3] - '0';
987 reloc
= BFD_RELOC_UNUSED
;
988 if (suffix
== ELF_SUFFIX_GOT
)
991 reloc
= BFD_RELOC_390_GOT16
;
992 else if (nbytes
== 4)
993 reloc
= BFD_RELOC_32_GOT_PCREL
;
994 else if (nbytes
== 8)
995 reloc
= BFD_RELOC_390_GOT64
;
997 else if (suffix
== ELF_SUFFIX_PLT
)
1000 reloc
= BFD_RELOC_390_PLT32
;
1001 else if (nbytes
== 8)
1002 reloc
= BFD_RELOC_390_PLT64
;
1005 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
1006 as_bad (_("Invalid suffix for literal pool entry"));
1008 /* Search the pool if the new entry is a duplicate. */
1009 if (exp_p
->X_op
== O_big
)
1011 /* Special processing for big numbers. */
1012 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
1014 if (lpe
->ex
.X_op
== O_big
)
1016 if (exp_p
->X_add_number
<= 0 && lpe
->ex
.X_add_number
<= 0)
1018 if (memcmp (&generic_floating_point_number
, &lpe
->floatnum
,
1019 sizeof (FLONUM_TYPE
)) == 0)
1022 else if (exp_p
->X_add_number
== lpe
->ex
.X_add_number
)
1024 if (memcmp (generic_bignum
, lpe
->bignum
,
1025 sizeof (LITTLENUM_TYPE
)*exp_p
->X_add_number
) == 0)
1033 /* Processing for 'normal' data types. */
1034 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
1035 if (lpe
->nbytes
== nbytes
&& lpe
->reloc
== reloc
1036 && s390_exp_compare (exp_p
, &lpe
->ex
) != 0)
1042 /* A new literal. */
1043 if (lpe_free_list
!= NULL
)
1045 lpe
= lpe_free_list
;
1046 lpe_free_list
= lpe_free_list
->next
;
1050 lpe
= XNEW (struct s390_lpe
);
1055 if (exp_p
->X_op
== O_big
)
1057 if (exp_p
->X_add_number
<= 0)
1058 lpe
->floatnum
= generic_floating_point_number
;
1059 else if (exp_p
->X_add_number
<= 4)
1060 memcpy (lpe
->bignum
, generic_bignum
,
1061 exp_p
->X_add_number
* sizeof (LITTLENUM_TYPE
));
1063 as_bad (_("Big number is too big"));
1066 lpe
->nbytes
= nbytes
;
1068 /* Literal pool name defined ? */
1071 sprintf (tmp_name
, ".L\001%i", lp_count
);
1072 lp_sym
= symbol_make (tmp_name
);
1075 /* Make name for literal pool entry. */
1076 sprintf (tmp_name
, ".L\001%i\002%i", lp_count
, lpe_count
);
1078 lpe
->sym
= symbol_make (tmp_name
);
1080 /* Add to literal pool list. */
1082 if (lpe_list_tail
!= NULL
)
1084 lpe_list_tail
->next
= lpe
;
1085 lpe_list_tail
= lpe
;
1088 lpe_list
= lpe_list_tail
= lpe
;
1091 /* Now change exp_p to the offset into the literal pool.
1092 That's the expression: .L^Ax^By-.L^Ax */
1093 exp_p
->X_add_symbol
= lpe
->sym
;
1094 exp_p
->X_op_symbol
= lp_sym
;
1095 exp_p
->X_op
= O_subtract
;
1096 exp_p
->X_add_number
= 0;
1100 /* We change the suffix type to ELF_SUFFIX_NONE, because
1101 the difference of two local labels is just a number. */
1102 return ELF_SUFFIX_NONE
;
1105 /* Like normal .long/.short/.word, except support @got, etc.
1106 clobbers input_line_pointer, checks end-of-line. */
1108 s390_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long */)
1111 elf_suffix_type suffix
;
1113 if (is_it_end_of_statement ())
1115 demand_empty_rest_of_line ();
1123 if (exp
.X_op
== O_symbol
1124 && *input_line_pointer
== '@'
1125 && (suffix
= s390_elf_suffix (&input_line_pointer
, &exp
)) != ELF_SUFFIX_NONE
)
1127 bfd_reloc_code_real_type reloc
;
1128 reloc_howto_type
*reloc_howto
;
1134 static bfd_reloc_code_real_type tab2
[] =
1136 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1137 BFD_RELOC_390_GOT16
, /* ELF_SUFFIX_GOT */
1138 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_PLT */
1139 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1140 BFD_RELOC_16_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1141 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTPLT */
1142 BFD_RELOC_390_PLTOFF16
, /* ELF_SUFFIX_PLTOFF */
1143 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GD */
1144 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GOTIE */
1145 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_IE */
1146 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDM */
1147 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDO */
1148 BFD_RELOC_UNUSED
/* ELF_SUFFIX_TLS_LE */
1150 reloc
= tab2
[suffix
];
1152 else if (nbytes
== 4)
1154 static bfd_reloc_code_real_type tab4
[] =
1156 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1157 BFD_RELOC_32_GOT_PCREL
, /* ELF_SUFFIX_GOT */
1158 BFD_RELOC_390_PLT32
, /* ELF_SUFFIX_PLT */
1159 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1160 BFD_RELOC_32_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1161 BFD_RELOC_390_GOTPLT32
, /* ELF_SUFFIX_GOTPLT */
1162 BFD_RELOC_390_PLTOFF32
, /* ELF_SUFFIX_PLTOFF */
1163 BFD_RELOC_390_TLS_GD32
, /* ELF_SUFFIX_TLS_GD */
1164 BFD_RELOC_390_TLS_GOTIE32
, /* ELF_SUFFIX_TLS_GOTIE */
1165 BFD_RELOC_390_TLS_IE32
, /* ELF_SUFFIX_TLS_IE */
1166 BFD_RELOC_390_TLS_LDM32
, /* ELF_SUFFIX_TLS_LDM */
1167 BFD_RELOC_390_TLS_LDO32
, /* ELF_SUFFIX_TLS_LDO */
1168 BFD_RELOC_390_TLS_LE32
/* ELF_SUFFIX_TLS_LE */
1170 reloc
= tab4
[suffix
];
1172 else if (nbytes
== 8)
1174 static bfd_reloc_code_real_type tab8
[] =
1176 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1177 BFD_RELOC_390_GOT64
, /* ELF_SUFFIX_GOT */
1178 BFD_RELOC_390_PLT64
, /* ELF_SUFFIX_PLT */
1179 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1180 BFD_RELOC_390_GOTOFF64
, /* ELF_SUFFIX_GOTOFF */
1181 BFD_RELOC_390_GOTPLT64
, /* ELF_SUFFIX_GOTPLT */
1182 BFD_RELOC_390_PLTOFF64
, /* ELF_SUFFIX_PLTOFF */
1183 BFD_RELOC_390_TLS_GD64
, /* ELF_SUFFIX_TLS_GD */
1184 BFD_RELOC_390_TLS_GOTIE64
, /* ELF_SUFFIX_TLS_GOTIE */
1185 BFD_RELOC_390_TLS_IE64
, /* ELF_SUFFIX_TLS_IE */
1186 BFD_RELOC_390_TLS_LDM64
, /* ELF_SUFFIX_TLS_LDM */
1187 BFD_RELOC_390_TLS_LDO64
, /* ELF_SUFFIX_TLS_LDO */
1188 BFD_RELOC_390_TLS_LE64
/* ELF_SUFFIX_TLS_LE */
1190 reloc
= tab8
[suffix
];
1193 reloc
= BFD_RELOC_UNUSED
;
1195 if (reloc
!= BFD_RELOC_UNUSED
1196 && (reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
)))
1198 size
= bfd_get_reloc_size (reloc_howto
);
1200 as_bad (ngettext ("%s relocations do not fit in %d byte",
1201 "%s relocations do not fit in %d bytes",
1203 reloc_howto
->name
, nbytes
);
1204 where
= frag_more (nbytes
);
1205 md_number_to_chars (where
, 0, size
);
1206 /* To make fixup_segment do the pc relative conversion the
1207 pcrel parameter on the fix_new_exp call needs to be FALSE. */
1208 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1209 size
, &exp
, FALSE
, reloc
);
1212 as_bad (_("relocation not applicable"));
1215 emit_expr (&exp
, (unsigned int) nbytes
);
1217 while (*input_line_pointer
++ == ',');
1219 input_line_pointer
--; /* Put terminator back into stream. */
1220 demand_empty_rest_of_line ();
1223 /* Return true if all remaining operands in the opcode with
1224 OPCODE_FLAGS can be skipped. */
1226 skip_optargs_p (unsigned int opcode_flags
, const unsigned char *opindex_ptr
)
1228 if ((opcode_flags
& (S390_INSTR_FLAG_OPTPARM
| S390_INSTR_FLAG_OPTPARM2
))
1229 && opindex_ptr
[0] != '\0'
1230 && opindex_ptr
[1] == '\0')
1233 if ((opcode_flags
& S390_INSTR_FLAG_OPTPARM2
)
1234 && opindex_ptr
[0] != '\0'
1235 && opindex_ptr
[1] != '\0'
1236 && opindex_ptr
[2] == '\0')
1241 /* We need to keep a list of fixups. We can't simply generate them as
1242 we go, because that would require us to first create the frag, and
1243 that would screw up references to ``.''. */
1249 bfd_reloc_code_real_type reloc
;
1252 #define MAX_INSN_FIXUPS (4)
1254 /* This routine is called for each instruction to be assembled. */
1257 md_gather_operands (char *str
,
1258 unsigned char *insn
,
1259 const struct s390_opcode
*opcode
)
1261 struct s390_fixup fixups
[MAX_INSN_FIXUPS
];
1262 const struct s390_operand
*operand
;
1263 const unsigned char *opindex_ptr
;
1265 elf_suffix_type suffix
;
1266 bfd_reloc_code_real_type reloc
;
1271 while (ISSPACE (*str
))
1276 /* Gather the operands. */
1278 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1282 operand
= s390_operands
+ *opindex_ptr
;
1284 if ((opcode
->flags
& (S390_INSTR_FLAG_OPTPARM
| S390_INSTR_FLAG_OPTPARM2
))
1287 /* Optional parameters might need to be ORed with a
1288 value so calling s390_insert_operand is needed. */
1289 s390_insert_operand (insn
, operand
, 0, NULL
, 0);
1293 if (skip_optional
&& (operand
->flags
& S390_OPERAND_INDEX
))
1295 /* We do an early skip. For D(X,B) constructions the index
1296 register is skipped (X is optional). For D(L,B) the base
1297 register will be the skipped operand, because L is NOT
1303 /* Gather the operand. */
1304 hold
= input_line_pointer
;
1305 input_line_pointer
= str
;
1307 /* Parse the operand. */
1308 if (! register_name (&ex
))
1311 str
= input_line_pointer
;
1312 input_line_pointer
= hold
;
1314 /* Write the operand to the insn. */
1315 if (ex
.X_op
== O_illegal
)
1316 as_bad (_("illegal operand"));
1317 else if (ex
.X_op
== O_absent
)
1319 if (opindex_ptr
[0] == '\0')
1321 as_bad (_("missing operand"));
1323 else if (ex
.X_op
== O_register
|| ex
.X_op
== O_constant
)
1325 s390_lit_suffix (&str
, &ex
, ELF_SUFFIX_NONE
);
1327 if (ex
.X_op
!= O_register
&& ex
.X_op
!= O_constant
)
1329 /* We need to generate a fixup for the
1330 expression returned by s390_lit_suffix. */
1331 if (fc
>= MAX_INSN_FIXUPS
)
1332 as_fatal (_("too many fixups"));
1333 fixups
[fc
].exp
= ex
;
1334 fixups
[fc
].opindex
= *opindex_ptr
;
1335 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
1340 if ((operand
->flags
& S390_OPERAND_LENGTH
)
1341 && ex
.X_op
!= O_constant
)
1342 as_fatal (_("invalid length field specified"));
1343 if ((operand
->flags
& S390_OPERAND_INDEX
)
1344 && ex
.X_add_number
== 0
1346 as_warn (_("index register specified but zero"));
1347 if ((operand
->flags
& S390_OPERAND_BASE
)
1348 && ex
.X_add_number
== 0
1350 as_warn (_("base register specified but zero"));
1351 if ((operand
->flags
& S390_OPERAND_GPR
)
1352 && (operand
->flags
& S390_OPERAND_REG_PAIR
)
1353 && (ex
.X_add_number
& 1))
1354 as_fatal (_("odd numbered general purpose register specified as "
1356 if ((operand
->flags
& S390_OPERAND_FPR
)
1357 && (operand
->flags
& S390_OPERAND_REG_PAIR
)
1358 && ex
.X_add_number
!= 0 && ex
.X_add_number
!= 1
1359 && ex
.X_add_number
!= 4 && ex
.X_add_number
!= 5
1360 && ex
.X_add_number
!= 8 && ex
.X_add_number
!= 9
1361 && ex
.X_add_number
!= 12 && ex
.X_add_number
!= 13)
1362 as_fatal (_("invalid floating point register pair. Valid fp "
1363 "register pair operands are 0, 1, 4, 5, 8, 9, "
1365 s390_insert_operand (insn
, operand
, ex
.X_add_number
, NULL
, 0);
1370 suffix
= s390_elf_suffix (&str
, &ex
);
1371 suffix
= s390_lit_suffix (&str
, &ex
, suffix
);
1372 reloc
= BFD_RELOC_UNUSED
;
1374 if (suffix
== ELF_SUFFIX_GOT
)
1376 if ((operand
->flags
& S390_OPERAND_DISP
) &&
1377 (operand
->bits
== 12))
1378 reloc
= BFD_RELOC_390_GOT12
;
1379 else if ((operand
->flags
& S390_OPERAND_DISP
) &&
1380 (operand
->bits
== 20))
1381 reloc
= BFD_RELOC_390_GOT20
;
1382 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1383 && (operand
->bits
== 16))
1384 reloc
= BFD_RELOC_390_GOT16
;
1385 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1386 && (operand
->bits
== 32))
1387 reloc
= BFD_RELOC_390_GOTENT
;
1389 else if (suffix
== ELF_SUFFIX_PLT
)
1391 if ((operand
->flags
& S390_OPERAND_PCREL
)
1392 && (operand
->bits
== 12))
1393 reloc
= BFD_RELOC_390_PLT12DBL
;
1394 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1395 && (operand
->bits
== 16))
1396 reloc
= BFD_RELOC_390_PLT16DBL
;
1397 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1398 && (operand
->bits
== 24))
1399 reloc
= BFD_RELOC_390_PLT24DBL
;
1400 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1401 && (operand
->bits
== 32))
1402 reloc
= BFD_RELOC_390_PLT32DBL
;
1404 else if (suffix
== ELF_SUFFIX_GOTENT
)
1406 if ((operand
->flags
& S390_OPERAND_PCREL
)
1407 && (operand
->bits
== 32))
1408 reloc
= BFD_RELOC_390_GOTENT
;
1410 else if (suffix
== ELF_SUFFIX_GOTOFF
)
1412 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1413 && (operand
->bits
== 16))
1414 reloc
= BFD_RELOC_16_GOTOFF
;
1416 else if (suffix
== ELF_SUFFIX_PLTOFF
)
1418 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1419 && (operand
->bits
== 16))
1420 reloc
= BFD_RELOC_390_PLTOFF16
;
1422 else if (suffix
== ELF_SUFFIX_GOTPLT
)
1424 if ((operand
->flags
& S390_OPERAND_DISP
)
1425 && (operand
->bits
== 12))
1426 reloc
= BFD_RELOC_390_GOTPLT12
;
1427 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1428 && (operand
->bits
== 16))
1429 reloc
= BFD_RELOC_390_GOTPLT16
;
1430 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1431 && (operand
->bits
== 32))
1432 reloc
= BFD_RELOC_390_GOTPLTENT
;
1434 else if (suffix
== ELF_SUFFIX_TLS_GOTIE
)
1436 if ((operand
->flags
& S390_OPERAND_DISP
)
1437 && (operand
->bits
== 12))
1438 reloc
= BFD_RELOC_390_TLS_GOTIE12
;
1439 else if ((operand
->flags
& S390_OPERAND_DISP
)
1440 && (operand
->bits
== 20))
1441 reloc
= BFD_RELOC_390_TLS_GOTIE20
;
1443 else if (suffix
== ELF_SUFFIX_TLS_IE
)
1445 if ((operand
->flags
& S390_OPERAND_PCREL
)
1446 && (operand
->bits
== 32))
1447 reloc
= BFD_RELOC_390_TLS_IEENT
;
1450 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
1451 as_bad (_("invalid operand suffix"));
1452 /* We need to generate a fixup of type 'reloc' for this
1454 if (fc
>= MAX_INSN_FIXUPS
)
1455 as_fatal (_("too many fixups"));
1456 fixups
[fc
].exp
= ex
;
1457 fixups
[fc
].opindex
= *opindex_ptr
;
1458 fixups
[fc
].reloc
= reloc
;
1462 /* Check the next character. The call to expression has advanced
1463 str past any whitespace. */
1464 if (operand
->flags
& S390_OPERAND_DISP
)
1466 /* After a displacement a block in parentheses can start. */
1469 /* Check if parenthesized block can be skipped. If the next
1470 operand is neither an optional operand nor a base register
1471 then we have a syntax error. */
1472 operand
= s390_operands
+ *(++opindex_ptr
);
1473 if (!(operand
->flags
& (S390_OPERAND_INDEX
|S390_OPERAND_BASE
)))
1474 as_bad (_("syntax error; missing '(' after displacement"));
1476 /* Ok, skip all operands until S390_OPERAND_BASE. */
1477 while (!(operand
->flags
& S390_OPERAND_BASE
))
1478 operand
= s390_operands
+ *(++opindex_ptr
);
1480 if (*str
== '\0' && skip_optargs_p (opcode
->flags
, &opindex_ptr
[1]))
1483 /* If there is a next operand it must be separated by a comma. */
1484 if (opindex_ptr
[1] != '\0')
1488 while (opindex_ptr
[1] != '\0')
1490 operand
= s390_operands
+ *(++opindex_ptr
);
1491 as_bad (_("syntax error; expected ','"));
1501 /* We found an opening parentheses. */
1503 for (f
= str
; *f
!= '\0'; f
++)
1504 if (*f
== ',' || *f
== ')')
1506 /* If there is no comma until the closing parentheses OR
1507 there is a comma right after the opening parentheses,
1508 we have to skip optional operands. */
1509 if (*f
== ',' && f
== str
)
1511 /* comma directly after '(' ? */
1516 skip_optional
= (*f
!= ',');
1519 else if (operand
->flags
& S390_OPERAND_BASE
)
1521 /* After the base register the parenthesised block ends. */
1523 as_bad (_("syntax error; missing ')' after base register"));
1526 if (*str
== '\0' && skip_optargs_p (opcode
->flags
, &opindex_ptr
[1]))
1529 /* If there is a next operand it must be separated by a comma. */
1530 if (opindex_ptr
[1] != '\0')
1534 while (opindex_ptr
[1] != '\0')
1536 operand
= s390_operands
+ *(++opindex_ptr
);
1537 as_bad (_("syntax error; expected ','"));
1547 /* We can find an 'early' closing parentheses in e.g. D(L) instead
1548 of D(L,B). In this case the base register has to be skipped. */
1551 operand
= s390_operands
+ *(++opindex_ptr
);
1553 if (!(operand
->flags
& S390_OPERAND_BASE
))
1554 as_bad (_("syntax error; ')' not allowed here"));
1558 if (*str
== '\0' && skip_optargs_p (opcode
->flags
, &opindex_ptr
[1]))
1561 /* If there is a next operand it must be separated by a comma. */
1562 if (opindex_ptr
[1] != '\0')
1566 while (opindex_ptr
[1] != '\0')
1568 operand
= s390_operands
+ *(++opindex_ptr
);
1569 as_bad (_("syntax error; expected ','"));
1579 while (ISSPACE (*str
))
1582 /* Check for tls instruction marker. */
1583 reloc
= s390_tls_suffix (&str
, &ex
);
1584 if (reloc
!= BFD_RELOC_UNUSED
)
1586 /* We need to generate a fixup of type 'reloc' for this
1588 if (fc
>= MAX_INSN_FIXUPS
)
1589 as_fatal (_("too many fixups"));
1590 fixups
[fc
].exp
= ex
;
1591 fixups
[fc
].opindex
= -1;
1592 fixups
[fc
].reloc
= reloc
;
1600 if ((linefeed
= strchr (str
, '\n')) != NULL
)
1602 as_bad (_("junk at end of line: `%s'"), str
);
1603 if (linefeed
!= NULL
)
1607 /* Write out the instruction. */
1608 f
= frag_more (opcode
->oplen
);
1609 memcpy (f
, insn
, opcode
->oplen
);
1610 dwarf2_emit_insn (opcode
->oplen
);
1612 /* Create any fixups. At this point we do not use a
1613 bfd_reloc_code_real_type, but instead just use the
1614 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1615 handle fixups for any operand type, although that is admittedly
1616 not a very exciting feature. We pick a BFD reloc type in
1618 for (i
= 0; i
< fc
; i
++)
1621 if (fixups
[i
].opindex
< 0)
1623 /* Create tls instruction marker relocation. */
1624 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, opcode
->oplen
,
1625 &fixups
[i
].exp
, 0, fixups
[i
].reloc
);
1629 operand
= s390_operands
+ fixups
[i
].opindex
;
1631 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
1633 reloc_howto_type
*reloc_howto
;
1637 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
1641 size
= ((reloc_howto
->bitsize
- 1) / 8) + 1;
1643 if (size
< 1 || size
> 4)
1646 fixP
= fix_new_exp (frag_now
,
1647 f
- frag_now
->fr_literal
+ (operand
->shift
/8),
1648 size
, &fixups
[i
].exp
, reloc_howto
->pc_relative
,
1650 /* Turn off overflow checking in fixup_segment. This is necessary
1651 because fixup_segment will signal an overflow for large 4 byte
1652 quantities for GOT12 relocations. */
1653 if ( fixups
[i
].reloc
== BFD_RELOC_390_GOT12
1654 || fixups
[i
].reloc
== BFD_RELOC_390_GOT20
1655 || fixups
[i
].reloc
== BFD_RELOC_390_GOT16
)
1656 fixP
->fx_no_overflow
= 1;
1658 if (operand
->flags
& S390_OPERAND_PCREL
)
1659 fixP
->fx_pcrel_adjust
= operand
->shift
/ 8;
1662 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4, &fixups
[i
].exp
,
1663 (operand
->flags
& S390_OPERAND_PCREL
) != 0,
1664 ((bfd_reloc_code_real_type
)
1665 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
1670 /* This routine is called for each instruction to be assembled. */
1673 md_assemble (char *str
)
1675 const struct s390_opcode
*opcode
;
1676 unsigned char insn
[6];
1679 /* Get the opcode. */
1680 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1685 /* Look up the opcode in the hash table. */
1686 opcode
= (struct s390_opcode
*) str_hash_find (s390_opcode_hash
, str
);
1687 if (opcode
== (const struct s390_opcode
*) NULL
)
1689 as_bad (_("Unrecognized opcode: `%s'"), str
);
1692 else if (!(opcode
->modes
& current_mode_mask
))
1694 as_bad (_("Opcode %s not available in this mode"), str
);
1697 memcpy (insn
, opcode
->opcode
, sizeof (insn
));
1698 md_gather_operands (s
, insn
, opcode
);
1701 #ifndef WORKING_DOT_WORD
1702 /* Handle long and short jumps. We don't support these */
1704 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1706 addressT from_addr
, to_addr
;
1714 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1716 addressT from_addr
, to_addr
;
1725 s390_bss (int ignore ATTRIBUTE_UNUSED
)
1727 /* We don't support putting frags in the BSS segment, we fake it
1728 by marking in_bss, then looking at s_skip for clues. */
1730 subseg_set (bss_section
, 0);
1731 demand_empty_rest_of_line ();
1734 /* Pseudo-op handling. */
1737 s390_insn (int ignore ATTRIBUTE_UNUSED
)
1740 const struct s390_opcode
*opformat
;
1741 unsigned char insn
[6];
1744 /* Get the opcode format. */
1745 s
= input_line_pointer
;
1746 while (*s
!= '\0' && *s
!= ',' && ! ISSPACE (*s
))
1749 as_bad (_("Invalid .insn format\n"));
1752 /* Look up the opcode in the hash table. */
1753 opformat
= (struct s390_opcode
*)
1754 str_hash_find (s390_opformat_hash
, input_line_pointer
);
1755 if (opformat
== (const struct s390_opcode
*) NULL
)
1757 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer
);
1760 input_line_pointer
= s
;
1762 if (exp
.X_op
== O_constant
)
1764 if ( ( opformat
->oplen
== 6
1765 && (addressT
) exp
.X_add_number
< (1ULL << 48))
1766 || ( opformat
->oplen
== 4
1767 && (addressT
) exp
.X_add_number
< (1ULL << 32))
1768 || ( opformat
->oplen
== 2
1769 && (addressT
) exp
.X_add_number
< (1ULL << 16)))
1770 md_number_to_chars ((char *) insn
, exp
.X_add_number
, opformat
->oplen
);
1772 as_bad (_("Invalid .insn format\n"));
1774 else if (exp
.X_op
== O_big
)
1776 if (exp
.X_add_number
> 0
1777 && opformat
->oplen
== 6
1778 && generic_bignum
[3] == 0)
1780 md_number_to_chars ((char *) insn
, generic_bignum
[2], 2);
1781 md_number_to_chars ((char *) &insn
[2], generic_bignum
[1], 2);
1782 md_number_to_chars ((char *) &insn
[4], generic_bignum
[0], 2);
1785 as_bad (_("Invalid .insn format\n"));
1788 as_bad (_("second operand of .insn not a constant\n"));
1790 if (strcmp (opformat
->name
, "e") != 0 && *input_line_pointer
++ != ',')
1791 as_bad (_("missing comma after insn constant\n"));
1793 if ((s
= strchr (input_line_pointer
, '\n')) != NULL
)
1795 input_line_pointer
= md_gather_operands (input_line_pointer
, insn
,
1799 demand_empty_rest_of_line ();
1802 /* The .byte pseudo-op. This is similar to the normal .byte
1803 pseudo-op, but it can also take a single ASCII string. */
1806 s390_byte (int ignore ATTRIBUTE_UNUSED
)
1808 if (*input_line_pointer
!= '\"')
1814 /* Gather characters. A real double quote is doubled. Unusual
1815 characters are not permitted. */
1816 ++input_line_pointer
;
1821 c
= *input_line_pointer
++;
1825 if (*input_line_pointer
!= '\"')
1827 ++input_line_pointer
;
1830 FRAG_APPEND_1_CHAR (c
);
1833 demand_empty_rest_of_line ();
1836 /* The .ltorg pseudo-op.This emits all literals defined since the last
1837 .ltorg or the invocation of gas. Literals are defined with the
1841 s390_literals (int ignore ATTRIBUTE_UNUSED
)
1843 struct s390_lpe
*lpe
;
1845 if (lp_sym
== NULL
|| lpe_count
== 0)
1846 return; /* Nothing to be done. */
1848 /* Emit symbol for start of literal pool. */
1849 S_SET_SEGMENT (lp_sym
, now_seg
);
1850 S_SET_VALUE (lp_sym
, (valueT
) frag_now_fix ());
1851 symbol_set_frag (lp_sym
, frag_now
);
1856 lpe_list
= lpe_list
->next
;
1857 S_SET_SEGMENT (lpe
->sym
, now_seg
);
1858 S_SET_VALUE (lpe
->sym
, (valueT
) frag_now_fix ());
1859 symbol_set_frag (lpe
->sym
, frag_now
);
1861 /* Emit literal pool entry. */
1862 if (lpe
->reloc
!= BFD_RELOC_UNUSED
)
1864 reloc_howto_type
*reloc_howto
=
1865 bfd_reloc_type_lookup (stdoutput
, lpe
->reloc
);
1866 int size
= bfd_get_reloc_size (reloc_howto
);
1869 if (size
> lpe
->nbytes
)
1870 as_bad (ngettext ("%s relocations do not fit in %d byte",
1871 "%s relocations do not fit in %d bytes",
1873 reloc_howto
->name
, lpe
->nbytes
);
1874 where
= frag_more (lpe
->nbytes
);
1875 md_number_to_chars (where
, 0, size
);
1876 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1877 size
, &lpe
->ex
, reloc_howto
->pc_relative
, lpe
->reloc
);
1881 if (lpe
->ex
.X_op
== O_big
)
1883 if (lpe
->ex
.X_add_number
<= 0)
1884 generic_floating_point_number
= lpe
->floatnum
;
1886 memcpy (generic_bignum
, lpe
->bignum
,
1887 lpe
->ex
.X_add_number
* sizeof (LITTLENUM_TYPE
));
1889 emit_expr (&lpe
->ex
, lpe
->nbytes
);
1892 lpe
->next
= lpe_free_list
;
1893 lpe_free_list
= lpe
;
1895 lpe_list_tail
= NULL
;
1901 #define MAX_HISTORY 100
1903 /* The .machine pseudo op allows to switch to a different CPU level in
1904 the asm listing. The current CPU setting can be stored on a stack
1905 with .machine push and restored with .machine pop. */
1908 s390_machine (int ignore ATTRIBUTE_UNUSED
)
1911 static struct cpu_history
1916 static int curr_hist
;
1920 if (*input_line_pointer
== '"')
1923 cpu_string
= demand_copy_C_string (&len
);
1929 cpu_string
= input_line_pointer
;
1934 c
= get_symbol_name (&str
);
1935 c
= restore_line_pointer (c
);
1937 ++ input_line_pointer
;
1941 c
= *input_line_pointer
;
1942 *input_line_pointer
= 0;
1943 cpu_string
= xstrdup (cpu_string
);
1944 (void) restore_line_pointer (c
);
1947 if (cpu_string
!= NULL
)
1949 unsigned int new_cpu
= current_cpu
;
1950 unsigned int new_flags
= current_flags
;
1952 if (strcmp (cpu_string
, "push") == 0)
1954 if (cpu_history
== NULL
)
1955 cpu_history
= XNEWVEC (struct cpu_history
, MAX_HISTORY
);
1957 if (curr_hist
>= MAX_HISTORY
)
1958 as_bad (_(".machine stack overflow"));
1961 cpu_history
[curr_hist
].cpu
= current_cpu
;
1962 cpu_history
[curr_hist
].flags
= current_flags
;
1966 else if (strcmp (cpu_string
, "pop") == 0)
1969 as_bad (_(".machine stack underflow"));
1973 new_cpu
= cpu_history
[curr_hist
].cpu
;
1974 new_flags
= cpu_history
[curr_hist
].flags
;
1978 new_cpu
= s390_parse_cpu (cpu_string
, &new_flags
, TRUE
);
1980 if (new_cpu
== S390_OPCODE_MAXCPU
)
1981 as_bad (_("invalid machine `%s'"), cpu_string
);
1983 if (new_cpu
!= current_cpu
|| new_flags
!= current_flags
)
1985 current_cpu
= new_cpu
;
1986 current_flags
= new_flags
;
1987 s390_setup_opcodes ();
1991 demand_empty_rest_of_line ();
1994 /* The .machinemode pseudo op allows to switch to a different
1995 architecture mode in the asm listing. The current architecture
1996 mode setting can be stored on a stack with .machinemode push and
1997 restored with .machinemode pop. */
2000 s390_machinemode (int ignore ATTRIBUTE_UNUSED
)
2003 static unsigned int *mode_history
;
2004 static int curr_hist
;
2011 c
= get_symbol_name (&mode_string
);
2012 mode_string
= xstrdup (mode_string
);
2013 (void) restore_line_pointer (c
);
2016 if (mode_string
!= NULL
)
2018 unsigned int old_mode_mask
= current_mode_mask
;
2021 for (p
= mode_string
; *p
!= 0; p
++)
2024 if (strcmp (mode_string
, "push") == 0)
2026 if (mode_history
== NULL
)
2027 mode_history
= XNEWVEC (unsigned int, MAX_HISTORY
);
2029 if (curr_hist
>= MAX_HISTORY
)
2030 as_bad (_(".machinemode stack overflow"));
2032 mode_history
[curr_hist
++] = current_mode_mask
;
2034 else if (strcmp (mode_string
, "pop") == 0)
2037 as_bad (_(".machinemode stack underflow"));
2039 current_mode_mask
= mode_history
[--curr_hist
];
2043 if (strcmp (mode_string
, "esa") == 0)
2044 current_mode_mask
= 1 << S390_OPCODE_ESA
;
2045 else if (strcmp (mode_string
, "zarch") == 0)
2047 if (s390_arch_size
== 32)
2048 set_highgprs_p
= TRUE
;
2049 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
2051 else if (strcmp (mode_string
, "zarch_nohighgprs") == 0)
2052 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
2054 as_bad (_("invalid machine mode `%s'"), mode_string
);
2057 if (current_mode_mask
!= old_mode_mask
)
2058 s390_setup_opcodes ();
2061 demand_empty_rest_of_line ();
2067 md_atof (int type
, char *litp
, int *sizep
)
2069 return ieee_md_atof (type
, litp
, sizep
, TRUE
);
2072 /* Align a section (I don't know why this is machine dependent). */
2075 md_section_align (asection
*seg
, valueT addr
)
2077 int align
= bfd_section_alignment (seg
);
2079 return ((addr
+ (1 << align
) - 1) & -(1 << align
));
2082 /* We don't have any form of relaxing. */
2085 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
2086 asection
*seg ATTRIBUTE_UNUSED
)
2092 /* Convert a machine dependent frag. We never generate these. */
2095 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
2096 asection
*sec ATTRIBUTE_UNUSED
,
2097 fragS
*fragp ATTRIBUTE_UNUSED
)
2103 md_undefined_symbol (char *name
)
2105 if (*name
== '_' && *(name
+ 1) == 'G'
2106 && strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
2110 if (symbol_find (name
))
2111 as_bad (_("GOT already in symbol table"));
2112 GOT_symbol
= symbol_new (name
, undefined_section
,
2113 &zero_address_frag
, 0);
2120 /* Functions concerning relocs. */
2122 /* The location from which a PC relative jump should be calculated,
2123 given a PC relative reloc. */
2126 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
2128 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2131 /* Here we decide which fixups can be adjusted to make them relative to
2132 the beginning of the section instead of the symbol. Basically we need
2133 to make sure that the dynamic relocations are done correctly, so in
2134 some cases we force the original symbol to be used. */
2136 tc_s390_fix_adjustable (fixS
*fixP
)
2138 /* Don't adjust pc-relative references to merge sections. */
2140 && (S_GET_SEGMENT (fixP
->fx_addsy
)->flags
& SEC_MERGE
) != 0)
2143 /* adjust_reloc_syms doesn't know about the GOT. */
2144 if ( fixP
->fx_r_type
== BFD_RELOC_16_GOTOFF
2145 || fixP
->fx_r_type
== BFD_RELOC_32_GOTOFF
2146 || fixP
->fx_r_type
== BFD_RELOC_390_GOTOFF64
2147 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF16
2148 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF32
2149 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF64
2150 || fixP
->fx_r_type
== BFD_RELOC_390_PLT12DBL
2151 || fixP
->fx_r_type
== BFD_RELOC_390_PLT16DBL
2152 || fixP
->fx_r_type
== BFD_RELOC_390_PLT24DBL
2153 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32
2154 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32DBL
2155 || fixP
->fx_r_type
== BFD_RELOC_390_PLT64
2156 || fixP
->fx_r_type
== BFD_RELOC_390_GOT12
2157 || fixP
->fx_r_type
== BFD_RELOC_390_GOT20
2158 || fixP
->fx_r_type
== BFD_RELOC_390_GOT16
2159 || fixP
->fx_r_type
== BFD_RELOC_32_GOT_PCREL
2160 || fixP
->fx_r_type
== BFD_RELOC_390_GOT64
2161 || fixP
->fx_r_type
== BFD_RELOC_390_GOTENT
2162 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT12
2163 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT16
2164 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT20
2165 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT32
2166 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT64
2167 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLTENT
2168 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LOAD
2169 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GDCALL
2170 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDCALL
2171 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD32
2172 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD64
2173 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE12
2174 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE20
2175 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE32
2176 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE64
2177 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM32
2178 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM64
2179 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE32
2180 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE64
2181 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IEENT
2182 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE32
2183 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE64
2184 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO32
2185 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO64
2186 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPMOD
2187 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPOFF
2188 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_TPOFF
2189 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2190 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
2195 /* Return true if we must always emit a reloc for a type and false if
2196 there is some hope of resolving it at assembly time. */
2198 tc_s390_force_relocation (struct fix
*fixp
)
2200 /* Ensure we emit a relocation for every reference to the global
2201 offset table or to the procedure link table. */
2202 switch (fixp
->fx_r_type
)
2204 case BFD_RELOC_390_GOT12
:
2205 case BFD_RELOC_390_GOT20
:
2206 case BFD_RELOC_32_GOT_PCREL
:
2207 case BFD_RELOC_32_GOTOFF
:
2208 case BFD_RELOC_390_GOTOFF64
:
2209 case BFD_RELOC_390_PLTOFF16
:
2210 case BFD_RELOC_390_PLTOFF32
:
2211 case BFD_RELOC_390_PLTOFF64
:
2212 case BFD_RELOC_390_GOTPC
:
2213 case BFD_RELOC_390_GOT16
:
2214 case BFD_RELOC_390_GOTPCDBL
:
2215 case BFD_RELOC_390_GOT64
:
2216 case BFD_RELOC_390_GOTENT
:
2217 case BFD_RELOC_390_PLT32
:
2218 case BFD_RELOC_390_PLT12DBL
:
2219 case BFD_RELOC_390_PLT16DBL
:
2220 case BFD_RELOC_390_PLT24DBL
:
2221 case BFD_RELOC_390_PLT32DBL
:
2222 case BFD_RELOC_390_PLT64
:
2223 case BFD_RELOC_390_GOTPLT12
:
2224 case BFD_RELOC_390_GOTPLT16
:
2225 case BFD_RELOC_390_GOTPLT20
:
2226 case BFD_RELOC_390_GOTPLT32
:
2227 case BFD_RELOC_390_GOTPLT64
:
2228 case BFD_RELOC_390_GOTPLTENT
:
2234 return generic_force_reloc (fixp
);
2237 /* Apply a fixup to the object code. This is called for all the
2238 fixups we generated by the call to fix_new_exp, above. In the call
2239 above we used a reloc code which was the largest legal reloc code
2240 plus the operand index. Here we undo that to recover the operand
2241 index. At this point all symbol values should be fully resolved,
2242 and we attempt to completely resolve the reloc. If we can not do
2243 that, we determine the correct reloc code and put it back in the
2247 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
2250 valueT value
= *valP
;
2252 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
2254 if (fixP
->fx_subsy
!= NULL
)
2255 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2256 _("cannot emit relocation %s against subsy symbol %s"),
2257 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2258 S_GET_NAME (fixP
->fx_subsy
));
2260 if (fixP
->fx_addsy
!= NULL
)
2263 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
2268 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
2270 const struct s390_operand
*operand
;
2273 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
2274 operand
= &s390_operands
[opindex
];
2278 /* Insert the fully resolved operand value. */
2279 s390_insert_operand ((unsigned char *) where
, operand
,
2280 (offsetT
) value
, fixP
->fx_file
, fixP
->fx_line
);
2284 /* Determine a BFD reloc value based on the operand information.
2285 We are only prepared to turn a few of the operands into
2287 fixP
->fx_offset
= value
;
2288 if (operand
->bits
== 12 && operand
->shift
== 20)
2291 fixP
->fx_where
+= 2;
2292 fixP
->fx_r_type
= BFD_RELOC_390_12
;
2294 else if (operand
->bits
== 12 && operand
->shift
== 36)
2297 fixP
->fx_where
+= 4;
2298 fixP
->fx_r_type
= BFD_RELOC_390_12
;
2300 else if (operand
->bits
== 20 && operand
->shift
== 20)
2303 fixP
->fx_where
+= 2;
2304 fixP
->fx_r_type
= BFD_RELOC_390_20
;
2306 else if (operand
->bits
== 8 && operand
->shift
== 8)
2309 fixP
->fx_where
+= 1;
2310 fixP
->fx_r_type
= BFD_RELOC_8
;
2312 else if (operand
->bits
== 12 && operand
->shift
== 12
2313 && (operand
->flags
& S390_OPERAND_PCREL
))
2316 fixP
->fx_where
+= 1;
2317 fixP
->fx_offset
+= 1;
2318 fixP
->fx_pcrel_adjust
= 1;
2319 fixP
->fx_r_type
= BFD_RELOC_390_PC12DBL
;
2321 else if (operand
->bits
== 16 && operand
->shift
== 16)
2324 fixP
->fx_where
+= 2;
2325 if (operand
->flags
& S390_OPERAND_PCREL
)
2327 fixP
->fx_r_type
= BFD_RELOC_390_PC16DBL
;
2328 fixP
->fx_offset
+= 2;
2329 fixP
->fx_pcrel_adjust
= 2;
2332 fixP
->fx_r_type
= BFD_RELOC_16
;
2334 else if (operand
->bits
== 16 && operand
->shift
== 32
2335 && (operand
->flags
& S390_OPERAND_PCREL
))
2338 fixP
->fx_where
+= 4;
2339 fixP
->fx_offset
+= 4;
2340 fixP
->fx_pcrel_adjust
= 4;
2341 fixP
->fx_r_type
= BFD_RELOC_390_PC16DBL
;
2343 else if (operand
->bits
== 24 && operand
->shift
== 24
2344 && (operand
->flags
& S390_OPERAND_PCREL
))
2347 fixP
->fx_where
+= 3;
2348 fixP
->fx_offset
+= 3;
2349 fixP
->fx_pcrel_adjust
= 3;
2350 fixP
->fx_r_type
= BFD_RELOC_390_PC24DBL
;
2352 else if (operand
->bits
== 32 && operand
->shift
== 16
2353 && (operand
->flags
& S390_OPERAND_PCREL
))
2356 fixP
->fx_where
+= 2;
2357 fixP
->fx_offset
+= 2;
2358 fixP
->fx_pcrel_adjust
= 2;
2359 fixP
->fx_r_type
= BFD_RELOC_390_PC32DBL
;
2366 /* Use expr_symbol_where to see if this is an expression
2368 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
2369 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2370 _("unresolved expression that must be resolved"));
2372 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2373 _("unsupported relocation type"));
2380 switch (fixP
->fx_r_type
)
2386 md_number_to_chars (where
, value
, 1);
2388 case BFD_RELOC_390_12
:
2389 case BFD_RELOC_390_GOT12
:
2390 case BFD_RELOC_390_GOTPLT12
:
2391 case BFD_RELOC_390_PC12DBL
:
2392 case BFD_RELOC_390_PLT12DBL
:
2394 value
+= fixP
->fx_pcrel_adjust
;
2403 mop
= bfd_getb16 ((unsigned char *) where
);
2404 mop
|= (unsigned short) (value
& 0xfff);
2405 bfd_putb16 ((bfd_vma
) mop
, (unsigned char *) where
);
2409 case BFD_RELOC_390_20
:
2410 case BFD_RELOC_390_GOT20
:
2411 case BFD_RELOC_390_GOTPLT20
:
2415 mop
= bfd_getb32 ((unsigned char *) where
);
2416 mop
|= (unsigned int) ((value
& 0xfff) << 8 |
2417 (value
& 0xff000) >> 12);
2418 bfd_putb32 ((bfd_vma
) mop
, (unsigned char *) where
);
2423 case BFD_RELOC_GPREL16
:
2424 case BFD_RELOC_16_GOT_PCREL
:
2425 case BFD_RELOC_16_GOTOFF
:
2427 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2428 _("cannot emit PC relative %s relocation%s%s"),
2429 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2430 fixP
->fx_addsy
!= NULL
? " against " : "",
2431 (fixP
->fx_addsy
!= NULL
2432 ? S_GET_NAME (fixP
->fx_addsy
)
2435 md_number_to_chars (where
, value
, 2);
2437 case BFD_RELOC_390_GOT16
:
2438 case BFD_RELOC_390_PLTOFF16
:
2439 case BFD_RELOC_390_GOTPLT16
:
2441 md_number_to_chars (where
, value
, 2);
2443 case BFD_RELOC_390_PC16DBL
:
2444 case BFD_RELOC_390_PLT16DBL
:
2445 value
+= fixP
->fx_pcrel_adjust
;
2447 md_number_to_chars (where
, (offsetT
) value
>> 1, 2);
2450 case BFD_RELOC_390_PC24DBL
:
2451 case BFD_RELOC_390_PLT24DBL
:
2452 value
+= fixP
->fx_pcrel_adjust
;
2458 mop
= bfd_getb32 ((unsigned char *) where
- 1);
2459 mop
|= (unsigned int) (value
& 0xffffff);
2460 bfd_putb32 ((bfd_vma
) mop
, (unsigned char *) where
- 1);
2466 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2468 fixP
->fx_r_type
= BFD_RELOC_32
;
2470 md_number_to_chars (where
, value
, 4);
2472 case BFD_RELOC_32_PCREL
:
2473 case BFD_RELOC_32_BASEREL
:
2474 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2476 md_number_to_chars (where
, value
, 4);
2478 case BFD_RELOC_32_GOT_PCREL
:
2479 case BFD_RELOC_390_PLTOFF32
:
2480 case BFD_RELOC_390_PLT32
:
2481 case BFD_RELOC_390_GOTPLT32
:
2483 md_number_to_chars (where
, value
, 4);
2485 case BFD_RELOC_390_PC32DBL
:
2486 case BFD_RELOC_390_PLT32DBL
:
2487 case BFD_RELOC_390_GOTPCDBL
:
2488 case BFD_RELOC_390_GOTENT
:
2489 case BFD_RELOC_390_GOTPLTENT
:
2490 value
+= fixP
->fx_pcrel_adjust
;
2492 md_number_to_chars (where
, (offsetT
) value
>> 1, 4);
2495 case BFD_RELOC_32_GOTOFF
:
2497 md_number_to_chars (where
, value
, sizeof (int));
2500 case BFD_RELOC_390_GOTOFF64
:
2502 md_number_to_chars (where
, value
, 8);
2505 case BFD_RELOC_390_GOT64
:
2506 case BFD_RELOC_390_PLTOFF64
:
2507 case BFD_RELOC_390_PLT64
:
2508 case BFD_RELOC_390_GOTPLT64
:
2510 md_number_to_chars (where
, value
, 8);
2515 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2517 fixP
->fx_r_type
= BFD_RELOC_64
;
2519 md_number_to_chars (where
, value
, 8);
2522 case BFD_RELOC_64_PCREL
:
2523 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2525 md_number_to_chars (where
, value
, 8);
2528 case BFD_RELOC_VTABLE_INHERIT
:
2529 case BFD_RELOC_VTABLE_ENTRY
:
2533 case BFD_RELOC_390_TLS_LOAD
:
2534 case BFD_RELOC_390_TLS_GDCALL
:
2535 case BFD_RELOC_390_TLS_LDCALL
:
2536 case BFD_RELOC_390_TLS_GD32
:
2537 case BFD_RELOC_390_TLS_GD64
:
2538 case BFD_RELOC_390_TLS_GOTIE12
:
2539 case BFD_RELOC_390_TLS_GOTIE20
:
2540 case BFD_RELOC_390_TLS_GOTIE32
:
2541 case BFD_RELOC_390_TLS_GOTIE64
:
2542 case BFD_RELOC_390_TLS_LDM32
:
2543 case BFD_RELOC_390_TLS_LDM64
:
2544 case BFD_RELOC_390_TLS_IE32
:
2545 case BFD_RELOC_390_TLS_IE64
:
2546 case BFD_RELOC_390_TLS_LE32
:
2547 case BFD_RELOC_390_TLS_LE64
:
2548 case BFD_RELOC_390_TLS_LDO32
:
2549 case BFD_RELOC_390_TLS_LDO64
:
2550 case BFD_RELOC_390_TLS_DTPMOD
:
2551 case BFD_RELOC_390_TLS_DTPOFF
:
2552 case BFD_RELOC_390_TLS_TPOFF
:
2553 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2554 /* Fully resolved at link time. */
2556 case BFD_RELOC_390_TLS_IEENT
:
2557 /* Fully resolved at link time. */
2558 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2564 const char *reloc_name
= bfd_get_reloc_code_name (fixP
->fx_r_type
);
2566 if (reloc_name
!= NULL
)
2567 as_fatal (_("Gas failure, reloc type %s\n"), reloc_name
);
2569 as_fatal (_("Gas failure, reloc type #%i\n"), fixP
->fx_r_type
);
2573 fixP
->fx_offset
= value
;
2577 /* Generate a reloc for a fixup. */
2580 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
2582 bfd_reloc_code_real_type code
;
2585 code
= fixp
->fx_r_type
;
2586 if (GOT_symbol
&& fixp
->fx_addsy
== GOT_symbol
)
2588 if ( (s390_arch_size
== 32 && code
== BFD_RELOC_32_PCREL
)
2589 || (s390_arch_size
== 64 && code
== BFD_RELOC_64_PCREL
))
2590 code
= BFD_RELOC_390_GOTPC
;
2591 if (code
== BFD_RELOC_390_PC32DBL
)
2592 code
= BFD_RELOC_390_GOTPCDBL
;
2595 reloc
= XNEW (arelent
);
2596 reloc
->sym_ptr_ptr
= XNEW (asymbol
*);
2597 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2598 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2599 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2600 if (reloc
->howto
== NULL
)
2602 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2603 _("cannot represent relocation type %s"),
2604 bfd_get_reloc_code_name (code
));
2605 /* Set howto to a garbage value so that we can keep going. */
2606 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
2607 gas_assert (reloc
->howto
!= NULL
);
2609 reloc
->addend
= fixp
->fx_offset
;
2615 s390_cfi_frame_initial_instructions (void)
2617 cfi_add_CFA_def_cfa (15, s390_arch_size
== 64 ? 160 : 96);
2621 tc_s390_regname_to_dw2regnum (char *regname
)
2625 if (regname
[0] != 'c' && regname
[0] != 'a')
2627 regnum
= reg_name_search (regname
);
2628 if (regname
[0] == 'f' && regnum
!= -1)
2631 else if (strcmp (regname
, "ap") == 0)
2633 else if (strcmp (regname
, "cc") == 0)
2639 s390_elf_final_processing (void)
2642 elf_elfheader (stdoutput
)->e_flags
|= EF_S390_HIGH_GPRS
;