1 /* tc-s390.c -- Assemble for the S390
2 Copyright (C) 2000-2020 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
, (void *) op
);
536 while (op
< op_end
- 1 && strcmp (op
->name
, op
[1].name
) == 0)
544 /* This function is called when the assembler starts up. It is called
545 after the options have been parsed and the output file has been
551 const struct s390_opcode
*op
;
552 const struct s390_opcode
*op_end
;
554 /* Give a warning if the combination -m64-bit and -Aesa is used. */
555 if (s390_arch_size
== 64 && current_cpu
< S390_OPCODE_Z900
)
556 as_warn (_("The 64 bit file format is used without esame instructions."));
558 s390_cie_data_alignment
= -s390_arch_size
/ 8;
560 /* Set the ELF flags if desired. */
562 bfd_set_private_flags (stdoutput
, s390_flags
);
564 /* Insert the opcode formats into a hash table. */
565 s390_opformat_hash
= str_htab_create ();
567 op_end
= s390_opformats
+ s390_num_opformats
;
568 for (op
= s390_opformats
; op
< op_end
; op
++)
569 str_hash_insert (s390_opformat_hash
, op
->name
, (void *) op
);
571 s390_setup_opcodes ();
573 record_alignment (text_section
, 2);
574 record_alignment (data_section
, 2);
575 record_alignment (bss_section
, 2);
578 /* Called after all assembly has been done. */
582 if (s390_arch_size
== 64)
583 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_64
);
585 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_31
);
588 /* Insert an operand value into an instruction. */
591 s390_insert_operand (unsigned char *insn
,
592 const struct s390_operand
*operand
,
600 if (operand
->flags
& (S390_OPERAND_SIGNED
|S390_OPERAND_PCREL
))
604 max
= ((offsetT
) 1 << (operand
->bits
- 1)) - 1;
605 min
= - ((offsetT
) 1 << (operand
->bits
- 1));
606 /* Halve PCREL operands. */
607 if (operand
->flags
& S390_OPERAND_PCREL
)
609 /* Check for underflow / overflow. */
610 if (val
< min
|| val
> max
)
613 _("operand out of range (%s not between %ld and %ld)");
616 if (operand
->flags
& S390_OPERAND_PCREL
)
622 sprint_value (buf
, val
);
623 if (file
== (char *) NULL
)
624 as_bad (err
, buf
, (int) min
, (int) max
);
626 as_bad_where (file
, line
, err
, buf
, (int) min
, (int) max
);
629 /* val is ok, now restrict it to operand->bits bits. */
630 uval
= (addressT
) val
& ((((addressT
) 1 << (operand
->bits
-1)) << 1) - 1);
631 /* val is restrict, now check for special case. */
632 if (operand
->bits
== 20 && operand
->shift
== 20)
633 uval
= (uval
>> 12) | ((uval
& 0xfff) << 8);
639 max
= (((addressT
) 1 << (operand
->bits
- 1)) << 1) - 1;
641 uval
= (addressT
) val
;
643 /* Vector register operands have an additional bit in the RXB
645 if (operand
->flags
& S390_OPERAND_VR
)
646 max
= (max
<< 1) | 1;
648 /* Length x in an instructions has real length x+1. */
649 if (operand
->flags
& S390_OPERAND_LENGTH
)
651 /* Check for underflow / overflow. */
652 if (uval
< min
|| uval
> max
)
654 if (operand
->flags
& S390_OPERAND_LENGTH
)
661 as_bad_value_out_of_range (_("operand"), uval
, (offsetT
) min
, (offsetT
) max
, file
, line
);
667 if (operand
->flags
& S390_OPERAND_VR
)
669 /* Insert the extra bit into the RXB field. */
670 switch (operand
->shift
)
673 insn
[4] |= (uval
& 0x10) >> 1;
676 insn
[4] |= (uval
& 0x10) >> 2;
679 insn
[4] |= (uval
& 0x10) >> 3;
682 insn
[4] |= (uval
& 0x10) >> 4;
688 if (operand
->flags
& S390_OPERAND_OR1
)
690 if (operand
->flags
& S390_OPERAND_OR2
)
692 if (operand
->flags
& S390_OPERAND_OR8
)
695 /* Duplicate the operand at bit pos 12 to 16. */
696 if (operand
->flags
& S390_OPERAND_CP16
)
698 /* Copy VR operand at bit pos 12 to bit pos 16. */
699 insn
[2] |= uval
<< 4;
700 /* Copy the flag in the RXB field. */
701 insn
[4] |= (insn
[4] & 4) >> 1;
704 /* Insert fragments of the operand byte for byte. */
705 offset
= operand
->shift
+ operand
->bits
;
706 uval
<<= (-offset
) & 7;
707 insn
+= (offset
- 1) / 8;
719 bfd_reloc_code_real_type reloc
;
722 /* Parse tls marker and return the desired relocation. */
723 static bfd_reloc_code_real_type
724 s390_tls_suffix (char **str_p
, expressionS
*exp_p
)
726 static struct map_tls mapping
[] =
728 { "tls_load", 8, BFD_RELOC_390_TLS_LOAD
},
729 { "tls_gdcall", 10, BFD_RELOC_390_TLS_GDCALL
},
730 { "tls_ldcall", 10, BFD_RELOC_390_TLS_LDCALL
},
731 { NULL
, 0, BFD_RELOC_UNUSED
}
741 return BFD_RELOC_UNUSED
;
744 while (ISIDNUM (*str
))
748 return BFD_RELOC_UNUSED
;
750 orig_line
= input_line_pointer
;
751 input_line_pointer
= str
;
753 str
= input_line_pointer
;
754 if (&input_line_pointer
!= str_p
)
755 input_line_pointer
= orig_line
;
757 if (exp_p
->X_op
!= O_symbol
)
758 return BFD_RELOC_UNUSED
;
760 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
761 if (len
== ptr
->length
762 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
764 /* Found a matching tls suffix. */
768 return BFD_RELOC_UNUSED
;
771 /* Structure used to hold suffixes. */
782 ELF_SUFFIX_TLS_GOTIE
,
794 elf_suffix_type suffix
;
798 /* Parse @got/@plt/@gotoff. and return the desired relocation. */
799 static elf_suffix_type
800 s390_elf_suffix (char **str_p
, expressionS
*exp_p
)
802 static struct map_bfd mapping
[] =
804 { "got", 3, ELF_SUFFIX_GOT
},
805 { "got12", 5, ELF_SUFFIX_GOT
},
806 { "plt", 3, ELF_SUFFIX_PLT
},
807 { "gotent", 6, ELF_SUFFIX_GOTENT
},
808 { "gotoff", 6, ELF_SUFFIX_GOTOFF
},
809 { "gotplt", 6, ELF_SUFFIX_GOTPLT
},
810 { "pltoff", 6, ELF_SUFFIX_PLTOFF
},
811 { "tlsgd", 5, ELF_SUFFIX_TLS_GD
},
812 { "gotntpoff", 9, ELF_SUFFIX_TLS_GOTIE
},
813 { "indntpoff", 9, ELF_SUFFIX_TLS_IE
},
814 { "tlsldm", 6, ELF_SUFFIX_TLS_LDM
},
815 { "dtpoff", 6, ELF_SUFFIX_TLS_LDO
},
816 { "ntpoff", 6, ELF_SUFFIX_TLS_LE
},
817 { NULL
, 0, ELF_SUFFIX_NONE
}
826 return ELF_SUFFIX_NONE
;
829 while (ISALNUM (*str
))
833 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
834 if (len
== ptr
->length
835 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
837 if (exp_p
->X_add_number
!= 0)
838 as_warn (_("identifier+constant@%s means identifier@%s+constant"),
839 ptr
->string
, ptr
->string
);
840 /* Now check for identifier@suffix+constant. */
841 if (*str
== '-' || *str
== '+')
843 char *orig_line
= input_line_pointer
;
846 input_line_pointer
= str
;
847 expression (&new_exp
);
849 switch (new_exp
.X_op
)
851 case O_constant
: /* X_add_number (a constant expression). */
852 exp_p
->X_add_number
+= new_exp
.X_add_number
;
853 str
= input_line_pointer
;
855 case O_symbol
: /* X_add_symbol + X_add_number. */
856 /* this case is used for e.g. xyz@PLT+.Label. */
857 exp_p
->X_add_number
+= new_exp
.X_add_number
;
858 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
860 str
= input_line_pointer
;
862 case O_uminus
: /* (- X_add_symbol) + X_add_number. */
863 /* this case is used for e.g. xyz@PLT-.Label. */
864 exp_p
->X_add_number
+= new_exp
.X_add_number
;
865 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
866 exp_p
->X_op
= O_subtract
;
867 str
= input_line_pointer
;
873 /* If s390_elf_suffix has not been called with
874 &input_line_pointer as first parameter, we have
875 clobbered the input_line_pointer. We have to
877 if (&input_line_pointer
!= str_p
)
878 input_line_pointer
= orig_line
;
884 return ELF_SUFFIX_NONE
;
887 /* Structure used to hold a literal pool entry. */
890 struct s390_lpe
*next
;
892 FLONUM_TYPE floatnum
; /* used if X_op == O_big && X_add_number <= 0 */
893 LITTLENUM_TYPE bignum
[4]; /* used if X_op == O_big && X_add_number > 0 */
895 bfd_reloc_code_real_type reloc
;
899 static struct s390_lpe
*lpe_free_list
= NULL
;
900 static struct s390_lpe
*lpe_list
= NULL
;
901 static struct s390_lpe
*lpe_list_tail
= NULL
;
902 static symbolS
*lp_sym
= NULL
;
903 static int lp_count
= 0;
904 static int lpe_count
= 0;
907 s390_exp_compare (expressionS
*exp1
, expressionS
*exp2
)
909 if (exp1
->X_op
!= exp2
->X_op
)
914 case O_constant
: /* X_add_number must be equal. */
916 return exp1
->X_add_number
== exp2
->X_add_number
;
919 as_bad (_("Can't handle O_big in s390_exp_compare"));
922 case O_symbol
: /* X_add_symbol & X_add_number must be equal. */
927 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
928 && (exp1
->X_add_number
== exp2
->X_add_number
);
930 case O_multiply
: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
935 case O_bit_inclusive_or
:
937 case O_bit_exclusive_or
:
949 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
950 && (exp1
->X_op_symbol
== exp2
->X_op_symbol
)
951 && (exp1
->X_add_number
== exp2
->X_add_number
);
957 /* Test for @lit and if it's present make an entry in the literal pool and
958 modify the current expression to be an offset into the literal pool. */
959 static elf_suffix_type
960 s390_lit_suffix (char **str_p
, expressionS
*exp_p
, elf_suffix_type suffix
)
962 bfd_reloc_code_real_type reloc
;
966 struct s390_lpe
*lpe
;
970 return suffix
; /* No modification. */
972 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
974 while (ISALNUM (*str
))
977 if (len
!= 4 || strncasecmp (ident
, "lit", 3) != 0
978 || (ident
[3]!='1' && ident
[3]!='2' && ident
[3]!='4' && ident
[3]!='8'))
979 return suffix
; /* no modification */
980 nbytes
= ident
[3] - '0';
982 reloc
= BFD_RELOC_UNUSED
;
983 if (suffix
== ELF_SUFFIX_GOT
)
986 reloc
= BFD_RELOC_390_GOT16
;
987 else if (nbytes
== 4)
988 reloc
= BFD_RELOC_32_GOT_PCREL
;
989 else if (nbytes
== 8)
990 reloc
= BFD_RELOC_390_GOT64
;
992 else if (suffix
== ELF_SUFFIX_PLT
)
995 reloc
= BFD_RELOC_390_PLT32
;
996 else if (nbytes
== 8)
997 reloc
= BFD_RELOC_390_PLT64
;
1000 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
1001 as_bad (_("Invalid suffix for literal pool entry"));
1003 /* Search the pool if the new entry is a duplicate. */
1004 if (exp_p
->X_op
== O_big
)
1006 /* Special processing for big numbers. */
1007 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
1009 if (lpe
->ex
.X_op
== O_big
)
1011 if (exp_p
->X_add_number
<= 0 && lpe
->ex
.X_add_number
<= 0)
1013 if (memcmp (&generic_floating_point_number
, &lpe
->floatnum
,
1014 sizeof (FLONUM_TYPE
)) == 0)
1017 else if (exp_p
->X_add_number
== lpe
->ex
.X_add_number
)
1019 if (memcmp (generic_bignum
, lpe
->bignum
,
1020 sizeof (LITTLENUM_TYPE
)*exp_p
->X_add_number
) == 0)
1028 /* Processing for 'normal' data types. */
1029 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
1030 if (lpe
->nbytes
== nbytes
&& lpe
->reloc
== reloc
1031 && s390_exp_compare (exp_p
, &lpe
->ex
) != 0)
1037 /* A new literal. */
1038 if (lpe_free_list
!= NULL
)
1040 lpe
= lpe_free_list
;
1041 lpe_free_list
= lpe_free_list
->next
;
1045 lpe
= XNEW (struct s390_lpe
);
1050 if (exp_p
->X_op
== O_big
)
1052 if (exp_p
->X_add_number
<= 0)
1053 lpe
->floatnum
= generic_floating_point_number
;
1054 else if (exp_p
->X_add_number
<= 4)
1055 memcpy (lpe
->bignum
, generic_bignum
,
1056 exp_p
->X_add_number
* sizeof (LITTLENUM_TYPE
));
1058 as_bad (_("Big number is too big"));
1061 lpe
->nbytes
= nbytes
;
1063 /* Literal pool name defined ? */
1066 sprintf (tmp_name
, ".L\001%i", lp_count
);
1067 lp_sym
= symbol_make (tmp_name
);
1070 /* Make name for literal pool entry. */
1071 sprintf (tmp_name
, ".L\001%i\002%i", lp_count
, lpe_count
);
1073 lpe
->sym
= symbol_make (tmp_name
);
1075 /* Add to literal pool list. */
1077 if (lpe_list_tail
!= NULL
)
1079 lpe_list_tail
->next
= lpe
;
1080 lpe_list_tail
= lpe
;
1083 lpe_list
= lpe_list_tail
= lpe
;
1086 /* Now change exp_p to the offset into the literal pool.
1087 That's the expression: .L^Ax^By-.L^Ax */
1088 exp_p
->X_add_symbol
= lpe
->sym
;
1089 exp_p
->X_op_symbol
= lp_sym
;
1090 exp_p
->X_op
= O_subtract
;
1091 exp_p
->X_add_number
= 0;
1095 /* We change the suffix type to ELF_SUFFIX_NONE, because
1096 the difference of two local labels is just a number. */
1097 return ELF_SUFFIX_NONE
;
1100 /* Like normal .long/.short/.word, except support @got, etc.
1101 clobbers input_line_pointer, checks end-of-line. */
1103 s390_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long */)
1106 elf_suffix_type suffix
;
1108 if (is_it_end_of_statement ())
1110 demand_empty_rest_of_line ();
1118 if (exp
.X_op
== O_symbol
1119 && *input_line_pointer
== '@'
1120 && (suffix
= s390_elf_suffix (&input_line_pointer
, &exp
)) != ELF_SUFFIX_NONE
)
1122 bfd_reloc_code_real_type reloc
;
1123 reloc_howto_type
*reloc_howto
;
1129 static bfd_reloc_code_real_type tab2
[] =
1131 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1132 BFD_RELOC_390_GOT16
, /* ELF_SUFFIX_GOT */
1133 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_PLT */
1134 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1135 BFD_RELOC_16_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1136 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTPLT */
1137 BFD_RELOC_390_PLTOFF16
, /* ELF_SUFFIX_PLTOFF */
1138 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GD */
1139 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GOTIE */
1140 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_IE */
1141 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDM */
1142 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDO */
1143 BFD_RELOC_UNUSED
/* ELF_SUFFIX_TLS_LE */
1145 reloc
= tab2
[suffix
];
1147 else if (nbytes
== 4)
1149 static bfd_reloc_code_real_type tab4
[] =
1151 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1152 BFD_RELOC_32_GOT_PCREL
, /* ELF_SUFFIX_GOT */
1153 BFD_RELOC_390_PLT32
, /* ELF_SUFFIX_PLT */
1154 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1155 BFD_RELOC_32_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1156 BFD_RELOC_390_GOTPLT32
, /* ELF_SUFFIX_GOTPLT */
1157 BFD_RELOC_390_PLTOFF32
, /* ELF_SUFFIX_PLTOFF */
1158 BFD_RELOC_390_TLS_GD32
, /* ELF_SUFFIX_TLS_GD */
1159 BFD_RELOC_390_TLS_GOTIE32
, /* ELF_SUFFIX_TLS_GOTIE */
1160 BFD_RELOC_390_TLS_IE32
, /* ELF_SUFFIX_TLS_IE */
1161 BFD_RELOC_390_TLS_LDM32
, /* ELF_SUFFIX_TLS_LDM */
1162 BFD_RELOC_390_TLS_LDO32
, /* ELF_SUFFIX_TLS_LDO */
1163 BFD_RELOC_390_TLS_LE32
/* ELF_SUFFIX_TLS_LE */
1165 reloc
= tab4
[suffix
];
1167 else if (nbytes
== 8)
1169 static bfd_reloc_code_real_type tab8
[] =
1171 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1172 BFD_RELOC_390_GOT64
, /* ELF_SUFFIX_GOT */
1173 BFD_RELOC_390_PLT64
, /* ELF_SUFFIX_PLT */
1174 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1175 BFD_RELOC_390_GOTOFF64
, /* ELF_SUFFIX_GOTOFF */
1176 BFD_RELOC_390_GOTPLT64
, /* ELF_SUFFIX_GOTPLT */
1177 BFD_RELOC_390_PLTOFF64
, /* ELF_SUFFIX_PLTOFF */
1178 BFD_RELOC_390_TLS_GD64
, /* ELF_SUFFIX_TLS_GD */
1179 BFD_RELOC_390_TLS_GOTIE64
, /* ELF_SUFFIX_TLS_GOTIE */
1180 BFD_RELOC_390_TLS_IE64
, /* ELF_SUFFIX_TLS_IE */
1181 BFD_RELOC_390_TLS_LDM64
, /* ELF_SUFFIX_TLS_LDM */
1182 BFD_RELOC_390_TLS_LDO64
, /* ELF_SUFFIX_TLS_LDO */
1183 BFD_RELOC_390_TLS_LE64
/* ELF_SUFFIX_TLS_LE */
1185 reloc
= tab8
[suffix
];
1188 reloc
= BFD_RELOC_UNUSED
;
1190 if (reloc
!= BFD_RELOC_UNUSED
1191 && (reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
)))
1193 size
= bfd_get_reloc_size (reloc_howto
);
1195 as_bad (ngettext ("%s relocations do not fit in %d byte",
1196 "%s relocations do not fit in %d bytes",
1198 reloc_howto
->name
, nbytes
);
1199 where
= frag_more (nbytes
);
1200 md_number_to_chars (where
, 0, size
);
1201 /* To make fixup_segment do the pc relative conversion the
1202 pcrel parameter on the fix_new_exp call needs to be FALSE. */
1203 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1204 size
, &exp
, FALSE
, reloc
);
1207 as_bad (_("relocation not applicable"));
1210 emit_expr (&exp
, (unsigned int) nbytes
);
1212 while (*input_line_pointer
++ == ',');
1214 input_line_pointer
--; /* Put terminator back into stream. */
1215 demand_empty_rest_of_line ();
1218 /* Return true if all remaining operands in the opcode with
1219 OPCODE_FLAGS can be skipped. */
1221 skip_optargs_p (unsigned int opcode_flags
, const unsigned char *opindex_ptr
)
1223 if ((opcode_flags
& (S390_INSTR_FLAG_OPTPARM
| S390_INSTR_FLAG_OPTPARM2
))
1224 && opindex_ptr
[0] != '\0'
1225 && opindex_ptr
[1] == '\0')
1228 if ((opcode_flags
& S390_INSTR_FLAG_OPTPARM2
)
1229 && opindex_ptr
[0] != '\0'
1230 && opindex_ptr
[1] != '\0'
1231 && opindex_ptr
[2] == '\0')
1236 /* We need to keep a list of fixups. We can't simply generate them as
1237 we go, because that would require us to first create the frag, and
1238 that would screw up references to ``.''. */
1244 bfd_reloc_code_real_type reloc
;
1247 #define MAX_INSN_FIXUPS (4)
1249 /* This routine is called for each instruction to be assembled. */
1252 md_gather_operands (char *str
,
1253 unsigned char *insn
,
1254 const struct s390_opcode
*opcode
)
1256 struct s390_fixup fixups
[MAX_INSN_FIXUPS
];
1257 const struct s390_operand
*operand
;
1258 const unsigned char *opindex_ptr
;
1260 elf_suffix_type suffix
;
1261 bfd_reloc_code_real_type reloc
;
1266 while (ISSPACE (*str
))
1271 /* Gather the operands. */
1273 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1277 operand
= s390_operands
+ *opindex_ptr
;
1279 if ((opcode
->flags
& (S390_INSTR_FLAG_OPTPARM
| S390_INSTR_FLAG_OPTPARM2
))
1282 /* Optional parameters might need to be ORed with a
1283 value so calling s390_insert_operand is needed. */
1284 s390_insert_operand (insn
, operand
, 0, NULL
, 0);
1288 if (skip_optional
&& (operand
->flags
& S390_OPERAND_INDEX
))
1290 /* We do an early skip. For D(X,B) constructions the index
1291 register is skipped (X is optional). For D(L,B) the base
1292 register will be the skipped operand, because L is NOT
1298 /* Gather the operand. */
1299 hold
= input_line_pointer
;
1300 input_line_pointer
= str
;
1302 /* Parse the operand. */
1303 if (! register_name (&ex
))
1306 str
= input_line_pointer
;
1307 input_line_pointer
= hold
;
1309 /* Write the operand to the insn. */
1310 if (ex
.X_op
== O_illegal
)
1311 as_bad (_("illegal operand"));
1312 else if (ex
.X_op
== O_absent
)
1314 if (opindex_ptr
[0] == '\0')
1316 as_bad (_("missing operand"));
1318 else if (ex
.X_op
== O_register
|| ex
.X_op
== O_constant
)
1320 s390_lit_suffix (&str
, &ex
, ELF_SUFFIX_NONE
);
1322 if (ex
.X_op
!= O_register
&& ex
.X_op
!= O_constant
)
1324 /* We need to generate a fixup for the
1325 expression returned by s390_lit_suffix. */
1326 if (fc
>= MAX_INSN_FIXUPS
)
1327 as_fatal (_("too many fixups"));
1328 fixups
[fc
].exp
= ex
;
1329 fixups
[fc
].opindex
= *opindex_ptr
;
1330 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
1335 if ((operand
->flags
& S390_OPERAND_LENGTH
)
1336 && ex
.X_op
!= O_constant
)
1337 as_fatal (_("invalid length field specified"));
1338 if ((operand
->flags
& S390_OPERAND_INDEX
)
1339 && ex
.X_add_number
== 0
1341 as_warn (_("index register specified but zero"));
1342 if ((operand
->flags
& S390_OPERAND_BASE
)
1343 && ex
.X_add_number
== 0
1345 as_warn (_("base register specified but zero"));
1346 if ((operand
->flags
& S390_OPERAND_GPR
)
1347 && (operand
->flags
& S390_OPERAND_REG_PAIR
)
1348 && (ex
.X_add_number
& 1))
1349 as_fatal (_("odd numbered general purpose register specified as "
1351 if ((operand
->flags
& S390_OPERAND_FPR
)
1352 && (operand
->flags
& S390_OPERAND_REG_PAIR
)
1353 && ex
.X_add_number
!= 0 && ex
.X_add_number
!= 1
1354 && ex
.X_add_number
!= 4 && ex
.X_add_number
!= 5
1355 && ex
.X_add_number
!= 8 && ex
.X_add_number
!= 9
1356 && ex
.X_add_number
!= 12 && ex
.X_add_number
!= 13)
1357 as_fatal (_("invalid floating point register pair. Valid fp "
1358 "register pair operands are 0, 1, 4, 5, 8, 9, "
1360 s390_insert_operand (insn
, operand
, ex
.X_add_number
, NULL
, 0);
1365 suffix
= s390_elf_suffix (&str
, &ex
);
1366 suffix
= s390_lit_suffix (&str
, &ex
, suffix
);
1367 reloc
= BFD_RELOC_UNUSED
;
1369 if (suffix
== ELF_SUFFIX_GOT
)
1371 if ((operand
->flags
& S390_OPERAND_DISP
) &&
1372 (operand
->bits
== 12))
1373 reloc
= BFD_RELOC_390_GOT12
;
1374 else if ((operand
->flags
& S390_OPERAND_DISP
) &&
1375 (operand
->bits
== 20))
1376 reloc
= BFD_RELOC_390_GOT20
;
1377 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1378 && (operand
->bits
== 16))
1379 reloc
= BFD_RELOC_390_GOT16
;
1380 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1381 && (operand
->bits
== 32))
1382 reloc
= BFD_RELOC_390_GOTENT
;
1384 else if (suffix
== ELF_SUFFIX_PLT
)
1386 if ((operand
->flags
& S390_OPERAND_PCREL
)
1387 && (operand
->bits
== 12))
1388 reloc
= BFD_RELOC_390_PLT12DBL
;
1389 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1390 && (operand
->bits
== 16))
1391 reloc
= BFD_RELOC_390_PLT16DBL
;
1392 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1393 && (operand
->bits
== 24))
1394 reloc
= BFD_RELOC_390_PLT24DBL
;
1395 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1396 && (operand
->bits
== 32))
1397 reloc
= BFD_RELOC_390_PLT32DBL
;
1399 else if (suffix
== ELF_SUFFIX_GOTENT
)
1401 if ((operand
->flags
& S390_OPERAND_PCREL
)
1402 && (operand
->bits
== 32))
1403 reloc
= BFD_RELOC_390_GOTENT
;
1405 else if (suffix
== ELF_SUFFIX_GOTOFF
)
1407 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1408 && (operand
->bits
== 16))
1409 reloc
= BFD_RELOC_16_GOTOFF
;
1411 else if (suffix
== ELF_SUFFIX_PLTOFF
)
1413 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1414 && (operand
->bits
== 16))
1415 reloc
= BFD_RELOC_390_PLTOFF16
;
1417 else if (suffix
== ELF_SUFFIX_GOTPLT
)
1419 if ((operand
->flags
& S390_OPERAND_DISP
)
1420 && (operand
->bits
== 12))
1421 reloc
= BFD_RELOC_390_GOTPLT12
;
1422 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1423 && (operand
->bits
== 16))
1424 reloc
= BFD_RELOC_390_GOTPLT16
;
1425 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1426 && (operand
->bits
== 32))
1427 reloc
= BFD_RELOC_390_GOTPLTENT
;
1429 else if (suffix
== ELF_SUFFIX_TLS_GOTIE
)
1431 if ((operand
->flags
& S390_OPERAND_DISP
)
1432 && (operand
->bits
== 12))
1433 reloc
= BFD_RELOC_390_TLS_GOTIE12
;
1434 else if ((operand
->flags
& S390_OPERAND_DISP
)
1435 && (operand
->bits
== 20))
1436 reloc
= BFD_RELOC_390_TLS_GOTIE20
;
1438 else if (suffix
== ELF_SUFFIX_TLS_IE
)
1440 if ((operand
->flags
& S390_OPERAND_PCREL
)
1441 && (operand
->bits
== 32))
1442 reloc
= BFD_RELOC_390_TLS_IEENT
;
1445 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
1446 as_bad (_("invalid operand suffix"));
1447 /* We need to generate a fixup of type 'reloc' for this
1449 if (fc
>= MAX_INSN_FIXUPS
)
1450 as_fatal (_("too many fixups"));
1451 fixups
[fc
].exp
= ex
;
1452 fixups
[fc
].opindex
= *opindex_ptr
;
1453 fixups
[fc
].reloc
= reloc
;
1457 /* Check the next character. The call to expression has advanced
1458 str past any whitespace. */
1459 if (operand
->flags
& S390_OPERAND_DISP
)
1461 /* After a displacement a block in parentheses can start. */
1464 /* Check if parenthesized block can be skipped. If the next
1465 operand is neither an optional operand nor a base register
1466 then we have a syntax error. */
1467 operand
= s390_operands
+ *(++opindex_ptr
);
1468 if (!(operand
->flags
& (S390_OPERAND_INDEX
|S390_OPERAND_BASE
)))
1469 as_bad (_("syntax error; missing '(' after displacement"));
1471 /* Ok, skip all operands until S390_OPERAND_BASE. */
1472 while (!(operand
->flags
& S390_OPERAND_BASE
))
1473 operand
= s390_operands
+ *(++opindex_ptr
);
1475 if (*str
== '\0' && skip_optargs_p (opcode
->flags
, &opindex_ptr
[1]))
1478 /* If there is a next operand it must be separated by a comma. */
1479 if (opindex_ptr
[1] != '\0')
1483 while (opindex_ptr
[1] != '\0')
1485 operand
= s390_operands
+ *(++opindex_ptr
);
1486 as_bad (_("syntax error; expected ','"));
1496 /* We found an opening parentheses. */
1498 for (f
= str
; *f
!= '\0'; f
++)
1499 if (*f
== ',' || *f
== ')')
1501 /* If there is no comma until the closing parentheses OR
1502 there is a comma right after the opening parentheses,
1503 we have to skip optional operands. */
1504 if (*f
== ',' && f
== str
)
1506 /* comma directly after '(' ? */
1511 skip_optional
= (*f
!= ',');
1514 else if (operand
->flags
& S390_OPERAND_BASE
)
1516 /* After the base register the parenthesised block ends. */
1518 as_bad (_("syntax error; missing ')' after base register"));
1521 if (*str
== '\0' && skip_optargs_p (opcode
->flags
, &opindex_ptr
[1]))
1524 /* If there is a next operand it must be separated by a comma. */
1525 if (opindex_ptr
[1] != '\0')
1529 while (opindex_ptr
[1] != '\0')
1531 operand
= s390_operands
+ *(++opindex_ptr
);
1532 as_bad (_("syntax error; expected ','"));
1542 /* We can find an 'early' closing parentheses in e.g. D(L) instead
1543 of D(L,B). In this case the base register has to be skipped. */
1546 operand
= s390_operands
+ *(++opindex_ptr
);
1548 if (!(operand
->flags
& S390_OPERAND_BASE
))
1549 as_bad (_("syntax error; ')' not allowed here"));
1553 if (*str
== '\0' && skip_optargs_p (opcode
->flags
, &opindex_ptr
[1]))
1556 /* If there is a next operand it must be separated by a comma. */
1557 if (opindex_ptr
[1] != '\0')
1561 while (opindex_ptr
[1] != '\0')
1563 operand
= s390_operands
+ *(++opindex_ptr
);
1564 as_bad (_("syntax error; expected ','"));
1574 while (ISSPACE (*str
))
1577 /* Check for tls instruction marker. */
1578 reloc
= s390_tls_suffix (&str
, &ex
);
1579 if (reloc
!= BFD_RELOC_UNUSED
)
1581 /* We need to generate a fixup of type 'reloc' for this
1583 if (fc
>= MAX_INSN_FIXUPS
)
1584 as_fatal (_("too many fixups"));
1585 fixups
[fc
].exp
= ex
;
1586 fixups
[fc
].opindex
= -1;
1587 fixups
[fc
].reloc
= reloc
;
1595 if ((linefeed
= strchr (str
, '\n')) != NULL
)
1597 as_bad (_("junk at end of line: `%s'"), str
);
1598 if (linefeed
!= NULL
)
1602 /* Write out the instruction. */
1603 f
= frag_more (opcode
->oplen
);
1604 memcpy (f
, insn
, opcode
->oplen
);
1605 dwarf2_emit_insn (opcode
->oplen
);
1607 /* Create any fixups. At this point we do not use a
1608 bfd_reloc_code_real_type, but instead just use the
1609 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1610 handle fixups for any operand type, although that is admittedly
1611 not a very exciting feature. We pick a BFD reloc type in
1613 for (i
= 0; i
< fc
; i
++)
1616 if (fixups
[i
].opindex
< 0)
1618 /* Create tls instruction marker relocation. */
1619 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, opcode
->oplen
,
1620 &fixups
[i
].exp
, 0, fixups
[i
].reloc
);
1624 operand
= s390_operands
+ fixups
[i
].opindex
;
1626 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
1628 reloc_howto_type
*reloc_howto
;
1632 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
1636 size
= ((reloc_howto
->bitsize
- 1) / 8) + 1;
1638 if (size
< 1 || size
> 4)
1641 fixP
= fix_new_exp (frag_now
,
1642 f
- frag_now
->fr_literal
+ (operand
->shift
/8),
1643 size
, &fixups
[i
].exp
, reloc_howto
->pc_relative
,
1645 /* Turn off overflow checking in fixup_segment. This is necessary
1646 because fixup_segment will signal an overflow for large 4 byte
1647 quantities for GOT12 relocations. */
1648 if ( fixups
[i
].reloc
== BFD_RELOC_390_GOT12
1649 || fixups
[i
].reloc
== BFD_RELOC_390_GOT20
1650 || fixups
[i
].reloc
== BFD_RELOC_390_GOT16
)
1651 fixP
->fx_no_overflow
= 1;
1653 if (operand
->flags
& S390_OPERAND_PCREL
)
1654 fixP
->fx_pcrel_adjust
= operand
->shift
/ 8;
1657 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4, &fixups
[i
].exp
,
1658 (operand
->flags
& S390_OPERAND_PCREL
) != 0,
1659 ((bfd_reloc_code_real_type
)
1660 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
1665 /* This routine is called for each instruction to be assembled. */
1668 md_assemble (char *str
)
1670 const struct s390_opcode
*opcode
;
1671 unsigned char insn
[6];
1674 /* Get the opcode. */
1675 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1680 /* Look up the opcode in the hash table. */
1681 opcode
= (struct s390_opcode
*) str_hash_find (s390_opcode_hash
, str
);
1682 if (opcode
== (const struct s390_opcode
*) NULL
)
1684 as_bad (_("Unrecognized opcode: `%s'"), str
);
1687 else if (!(opcode
->modes
& current_mode_mask
))
1689 as_bad (_("Opcode %s not available in this mode"), str
);
1692 memcpy (insn
, opcode
->opcode
, sizeof (insn
));
1693 md_gather_operands (s
, insn
, opcode
);
1696 #ifndef WORKING_DOT_WORD
1697 /* Handle long and short jumps. We don't support these */
1699 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1701 addressT from_addr
, to_addr
;
1709 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1711 addressT from_addr
, to_addr
;
1720 s390_bss (int ignore ATTRIBUTE_UNUSED
)
1722 /* We don't support putting frags in the BSS segment, we fake it
1723 by marking in_bss, then looking at s_skip for clues. */
1725 subseg_set (bss_section
, 0);
1726 demand_empty_rest_of_line ();
1729 /* Pseudo-op handling. */
1732 s390_insn (int ignore ATTRIBUTE_UNUSED
)
1735 const struct s390_opcode
*opformat
;
1736 unsigned char insn
[6];
1739 /* Get the opcode format. */
1740 s
= input_line_pointer
;
1741 while (*s
!= '\0' && *s
!= ',' && ! ISSPACE (*s
))
1744 as_bad (_("Invalid .insn format\n"));
1747 /* Look up the opcode in the hash table. */
1748 opformat
= (struct s390_opcode
*)
1749 str_hash_find (s390_opformat_hash
, input_line_pointer
);
1750 if (opformat
== (const struct s390_opcode
*) NULL
)
1752 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer
);
1755 input_line_pointer
= s
;
1757 if (exp
.X_op
== O_constant
)
1759 if ( ( opformat
->oplen
== 6
1760 && (addressT
) exp
.X_add_number
< (1ULL << 48))
1761 || ( opformat
->oplen
== 4
1762 && (addressT
) exp
.X_add_number
< (1ULL << 32))
1763 || ( opformat
->oplen
== 2
1764 && (addressT
) exp
.X_add_number
< (1ULL << 16)))
1765 md_number_to_chars ((char *) insn
, exp
.X_add_number
, opformat
->oplen
);
1767 as_bad (_("Invalid .insn format\n"));
1769 else if (exp
.X_op
== O_big
)
1771 if (exp
.X_add_number
> 0
1772 && opformat
->oplen
== 6
1773 && generic_bignum
[3] == 0)
1775 md_number_to_chars ((char *) insn
, generic_bignum
[2], 2);
1776 md_number_to_chars ((char *) &insn
[2], generic_bignum
[1], 2);
1777 md_number_to_chars ((char *) &insn
[4], generic_bignum
[0], 2);
1780 as_bad (_("Invalid .insn format\n"));
1783 as_bad (_("second operand of .insn not a constant\n"));
1785 if (strcmp (opformat
->name
, "e") != 0 && *input_line_pointer
++ != ',')
1786 as_bad (_("missing comma after insn constant\n"));
1788 if ((s
= strchr (input_line_pointer
, '\n')) != NULL
)
1790 input_line_pointer
= md_gather_operands (input_line_pointer
, insn
,
1794 demand_empty_rest_of_line ();
1797 /* The .byte pseudo-op. This is similar to the normal .byte
1798 pseudo-op, but it can also take a single ASCII string. */
1801 s390_byte (int ignore ATTRIBUTE_UNUSED
)
1803 if (*input_line_pointer
!= '\"')
1809 /* Gather characters. A real double quote is doubled. Unusual
1810 characters are not permitted. */
1811 ++input_line_pointer
;
1816 c
= *input_line_pointer
++;
1820 if (*input_line_pointer
!= '\"')
1822 ++input_line_pointer
;
1825 FRAG_APPEND_1_CHAR (c
);
1828 demand_empty_rest_of_line ();
1831 /* The .ltorg pseudo-op.This emits all literals defined since the last
1832 .ltorg or the invocation of gas. Literals are defined with the
1836 s390_literals (int ignore ATTRIBUTE_UNUSED
)
1838 struct s390_lpe
*lpe
;
1840 if (lp_sym
== NULL
|| lpe_count
== 0)
1841 return; /* Nothing to be done. */
1843 /* Emit symbol for start of literal pool. */
1844 S_SET_SEGMENT (lp_sym
, now_seg
);
1845 S_SET_VALUE (lp_sym
, (valueT
) frag_now_fix ());
1846 symbol_set_frag (lp_sym
, frag_now
);
1851 lpe_list
= lpe_list
->next
;
1852 S_SET_SEGMENT (lpe
->sym
, now_seg
);
1853 S_SET_VALUE (lpe
->sym
, (valueT
) frag_now_fix ());
1854 symbol_set_frag (lpe
->sym
, frag_now
);
1856 /* Emit literal pool entry. */
1857 if (lpe
->reloc
!= BFD_RELOC_UNUSED
)
1859 reloc_howto_type
*reloc_howto
=
1860 bfd_reloc_type_lookup (stdoutput
, lpe
->reloc
);
1861 int size
= bfd_get_reloc_size (reloc_howto
);
1864 if (size
> lpe
->nbytes
)
1865 as_bad (ngettext ("%s relocations do not fit in %d byte",
1866 "%s relocations do not fit in %d bytes",
1868 reloc_howto
->name
, lpe
->nbytes
);
1869 where
= frag_more (lpe
->nbytes
);
1870 md_number_to_chars (where
, 0, size
);
1871 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1872 size
, &lpe
->ex
, reloc_howto
->pc_relative
, lpe
->reloc
);
1876 if (lpe
->ex
.X_op
== O_big
)
1878 if (lpe
->ex
.X_add_number
<= 0)
1879 generic_floating_point_number
= lpe
->floatnum
;
1881 memcpy (generic_bignum
, lpe
->bignum
,
1882 lpe
->ex
.X_add_number
* sizeof (LITTLENUM_TYPE
));
1884 emit_expr (&lpe
->ex
, lpe
->nbytes
);
1887 lpe
->next
= lpe_free_list
;
1888 lpe_free_list
= lpe
;
1890 lpe_list_tail
= NULL
;
1896 #define MAX_HISTORY 100
1898 /* The .machine pseudo op allows to switch to a different CPU level in
1899 the asm listing. The current CPU setting can be stored on a stack
1900 with .machine push and restored with .machine pop. */
1903 s390_machine (int ignore ATTRIBUTE_UNUSED
)
1906 static struct cpu_history
1911 static int curr_hist
;
1915 if (*input_line_pointer
== '"')
1918 cpu_string
= demand_copy_C_string (&len
);
1924 cpu_string
= input_line_pointer
;
1929 c
= get_symbol_name (&str
);
1930 c
= restore_line_pointer (c
);
1932 ++ input_line_pointer
;
1936 c
= *input_line_pointer
;
1937 *input_line_pointer
= 0;
1938 cpu_string
= xstrdup (cpu_string
);
1939 (void) restore_line_pointer (c
);
1942 if (cpu_string
!= NULL
)
1944 unsigned int new_cpu
= current_cpu
;
1945 unsigned int new_flags
= current_flags
;
1947 if (strcmp (cpu_string
, "push") == 0)
1949 if (cpu_history
== NULL
)
1950 cpu_history
= XNEWVEC (struct cpu_history
, MAX_HISTORY
);
1952 if (curr_hist
>= MAX_HISTORY
)
1953 as_bad (_(".machine stack overflow"));
1956 cpu_history
[curr_hist
].cpu
= current_cpu
;
1957 cpu_history
[curr_hist
].flags
= current_flags
;
1961 else if (strcmp (cpu_string
, "pop") == 0)
1964 as_bad (_(".machine stack underflow"));
1968 new_cpu
= cpu_history
[curr_hist
].cpu
;
1969 new_flags
= cpu_history
[curr_hist
].flags
;
1973 new_cpu
= s390_parse_cpu (cpu_string
, &new_flags
, TRUE
);
1975 if (new_cpu
== S390_OPCODE_MAXCPU
)
1976 as_bad (_("invalid machine `%s'"), cpu_string
);
1978 if (new_cpu
!= current_cpu
|| new_flags
!= current_flags
)
1980 current_cpu
= new_cpu
;
1981 current_flags
= new_flags
;
1982 s390_setup_opcodes ();
1986 demand_empty_rest_of_line ();
1989 /* The .machinemode pseudo op allows to switch to a different
1990 architecture mode in the asm listing. The current architecture
1991 mode setting can be stored on a stack with .machinemode push and
1992 restored with .machinemode pop. */
1995 s390_machinemode (int ignore ATTRIBUTE_UNUSED
)
1998 static unsigned int *mode_history
;
1999 static int curr_hist
;
2006 c
= get_symbol_name (&mode_string
);
2007 mode_string
= xstrdup (mode_string
);
2008 (void) restore_line_pointer (c
);
2011 if (mode_string
!= NULL
)
2013 unsigned int old_mode_mask
= current_mode_mask
;
2016 for (p
= mode_string
; *p
!= 0; p
++)
2019 if (strcmp (mode_string
, "push") == 0)
2021 if (mode_history
== NULL
)
2022 mode_history
= XNEWVEC (unsigned int, MAX_HISTORY
);
2024 if (curr_hist
>= MAX_HISTORY
)
2025 as_bad (_(".machinemode stack overflow"));
2027 mode_history
[curr_hist
++] = current_mode_mask
;
2029 else if (strcmp (mode_string
, "pop") == 0)
2032 as_bad (_(".machinemode stack underflow"));
2034 current_mode_mask
= mode_history
[--curr_hist
];
2038 if (strcmp (mode_string
, "esa") == 0)
2039 current_mode_mask
= 1 << S390_OPCODE_ESA
;
2040 else if (strcmp (mode_string
, "zarch") == 0)
2042 if (s390_arch_size
== 32)
2043 set_highgprs_p
= TRUE
;
2044 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
2046 else if (strcmp (mode_string
, "zarch_nohighgprs") == 0)
2047 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
2049 as_bad (_("invalid machine mode `%s'"), mode_string
);
2052 if (current_mode_mask
!= old_mode_mask
)
2053 s390_setup_opcodes ();
2056 demand_empty_rest_of_line ();
2062 md_atof (int type
, char *litp
, int *sizep
)
2064 return ieee_md_atof (type
, litp
, sizep
, TRUE
);
2067 /* Align a section (I don't know why this is machine dependent). */
2070 md_section_align (asection
*seg
, valueT addr
)
2072 int align
= bfd_section_alignment (seg
);
2074 return ((addr
+ (1 << align
) - 1) & -(1 << align
));
2077 /* We don't have any form of relaxing. */
2080 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
2081 asection
*seg ATTRIBUTE_UNUSED
)
2087 /* Convert a machine dependent frag. We never generate these. */
2090 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
2091 asection
*sec ATTRIBUTE_UNUSED
,
2092 fragS
*fragp ATTRIBUTE_UNUSED
)
2098 md_undefined_symbol (char *name
)
2100 if (*name
== '_' && *(name
+ 1) == 'G'
2101 && strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
2105 if (symbol_find (name
))
2106 as_bad (_("GOT already in symbol table"));
2107 GOT_symbol
= symbol_new (name
, undefined_section
,
2108 &zero_address_frag
, 0);
2115 /* Functions concerning relocs. */
2117 /* The location from which a PC relative jump should be calculated,
2118 given a PC relative reloc. */
2121 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
2123 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2126 /* Here we decide which fixups can be adjusted to make them relative to
2127 the beginning of the section instead of the symbol. Basically we need
2128 to make sure that the dynamic relocations are done correctly, so in
2129 some cases we force the original symbol to be used. */
2131 tc_s390_fix_adjustable (fixS
*fixP
)
2133 /* Don't adjust pc-relative references to merge sections. */
2135 && (S_GET_SEGMENT (fixP
->fx_addsy
)->flags
& SEC_MERGE
) != 0)
2138 /* adjust_reloc_syms doesn't know about the GOT. */
2139 if ( fixP
->fx_r_type
== BFD_RELOC_16_GOTOFF
2140 || fixP
->fx_r_type
== BFD_RELOC_32_GOTOFF
2141 || fixP
->fx_r_type
== BFD_RELOC_390_GOTOFF64
2142 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF16
2143 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF32
2144 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF64
2145 || fixP
->fx_r_type
== BFD_RELOC_390_PLT12DBL
2146 || fixP
->fx_r_type
== BFD_RELOC_390_PLT16DBL
2147 || fixP
->fx_r_type
== BFD_RELOC_390_PLT24DBL
2148 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32
2149 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32DBL
2150 || fixP
->fx_r_type
== BFD_RELOC_390_PLT64
2151 || fixP
->fx_r_type
== BFD_RELOC_390_GOT12
2152 || fixP
->fx_r_type
== BFD_RELOC_390_GOT20
2153 || fixP
->fx_r_type
== BFD_RELOC_390_GOT16
2154 || fixP
->fx_r_type
== BFD_RELOC_32_GOT_PCREL
2155 || fixP
->fx_r_type
== BFD_RELOC_390_GOT64
2156 || fixP
->fx_r_type
== BFD_RELOC_390_GOTENT
2157 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT12
2158 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT16
2159 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT20
2160 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT32
2161 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT64
2162 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLTENT
2163 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LOAD
2164 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GDCALL
2165 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDCALL
2166 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD32
2167 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD64
2168 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE12
2169 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE20
2170 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE32
2171 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE64
2172 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM32
2173 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM64
2174 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE32
2175 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE64
2176 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IEENT
2177 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE32
2178 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE64
2179 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO32
2180 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO64
2181 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPMOD
2182 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPOFF
2183 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_TPOFF
2184 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2185 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
2190 /* Return true if we must always emit a reloc for a type and false if
2191 there is some hope of resolving it at assembly time. */
2193 tc_s390_force_relocation (struct fix
*fixp
)
2195 /* Ensure we emit a relocation for every reference to the global
2196 offset table or to the procedure link table. */
2197 switch (fixp
->fx_r_type
)
2199 case BFD_RELOC_390_GOT12
:
2200 case BFD_RELOC_390_GOT20
:
2201 case BFD_RELOC_32_GOT_PCREL
:
2202 case BFD_RELOC_32_GOTOFF
:
2203 case BFD_RELOC_390_GOTOFF64
:
2204 case BFD_RELOC_390_PLTOFF16
:
2205 case BFD_RELOC_390_PLTOFF32
:
2206 case BFD_RELOC_390_PLTOFF64
:
2207 case BFD_RELOC_390_GOTPC
:
2208 case BFD_RELOC_390_GOT16
:
2209 case BFD_RELOC_390_GOTPCDBL
:
2210 case BFD_RELOC_390_GOT64
:
2211 case BFD_RELOC_390_GOTENT
:
2212 case BFD_RELOC_390_PLT32
:
2213 case BFD_RELOC_390_PLT12DBL
:
2214 case BFD_RELOC_390_PLT16DBL
:
2215 case BFD_RELOC_390_PLT24DBL
:
2216 case BFD_RELOC_390_PLT32DBL
:
2217 case BFD_RELOC_390_PLT64
:
2218 case BFD_RELOC_390_GOTPLT12
:
2219 case BFD_RELOC_390_GOTPLT16
:
2220 case BFD_RELOC_390_GOTPLT20
:
2221 case BFD_RELOC_390_GOTPLT32
:
2222 case BFD_RELOC_390_GOTPLT64
:
2223 case BFD_RELOC_390_GOTPLTENT
:
2229 return generic_force_reloc (fixp
);
2232 /* Apply a fixup to the object code. This is called for all the
2233 fixups we generated by the call to fix_new_exp, above. In the call
2234 above we used a reloc code which was the largest legal reloc code
2235 plus the operand index. Here we undo that to recover the operand
2236 index. At this point all symbol values should be fully resolved,
2237 and we attempt to completely resolve the reloc. If we can not do
2238 that, we determine the correct reloc code and put it back in the
2242 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
2245 valueT value
= *valP
;
2247 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
2249 if (fixP
->fx_subsy
!= NULL
)
2250 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2251 _("cannot emit relocation %s against subsy symbol %s"),
2252 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2253 S_GET_NAME (fixP
->fx_subsy
));
2255 if (fixP
->fx_addsy
!= NULL
)
2258 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
2263 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
2265 const struct s390_operand
*operand
;
2268 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
2269 operand
= &s390_operands
[opindex
];
2273 /* Insert the fully resolved operand value. */
2274 s390_insert_operand ((unsigned char *) where
, operand
,
2275 (offsetT
) value
, fixP
->fx_file
, fixP
->fx_line
);
2279 /* Determine a BFD reloc value based on the operand information.
2280 We are only prepared to turn a few of the operands into
2282 fixP
->fx_offset
= value
;
2283 if (operand
->bits
== 12 && operand
->shift
== 20)
2286 fixP
->fx_where
+= 2;
2287 fixP
->fx_r_type
= BFD_RELOC_390_12
;
2289 else if (operand
->bits
== 12 && operand
->shift
== 36)
2292 fixP
->fx_where
+= 4;
2293 fixP
->fx_r_type
= BFD_RELOC_390_12
;
2295 else if (operand
->bits
== 20 && operand
->shift
== 20)
2298 fixP
->fx_where
+= 2;
2299 fixP
->fx_r_type
= BFD_RELOC_390_20
;
2301 else if (operand
->bits
== 8 && operand
->shift
== 8)
2304 fixP
->fx_where
+= 1;
2305 fixP
->fx_r_type
= BFD_RELOC_8
;
2307 else if (operand
->bits
== 12 && operand
->shift
== 12
2308 && (operand
->flags
& S390_OPERAND_PCREL
))
2311 fixP
->fx_where
+= 1;
2312 fixP
->fx_offset
+= 1;
2313 fixP
->fx_pcrel_adjust
= 1;
2314 fixP
->fx_r_type
= BFD_RELOC_390_PC12DBL
;
2316 else if (operand
->bits
== 16 && operand
->shift
== 16)
2319 fixP
->fx_where
+= 2;
2320 if (operand
->flags
& S390_OPERAND_PCREL
)
2322 fixP
->fx_r_type
= BFD_RELOC_390_PC16DBL
;
2323 fixP
->fx_offset
+= 2;
2324 fixP
->fx_pcrel_adjust
= 2;
2327 fixP
->fx_r_type
= BFD_RELOC_16
;
2329 else if (operand
->bits
== 16 && operand
->shift
== 32
2330 && (operand
->flags
& S390_OPERAND_PCREL
))
2333 fixP
->fx_where
+= 4;
2334 fixP
->fx_offset
+= 4;
2335 fixP
->fx_pcrel_adjust
= 4;
2336 fixP
->fx_r_type
= BFD_RELOC_390_PC16DBL
;
2338 else if (operand
->bits
== 24 && operand
->shift
== 24
2339 && (operand
->flags
& S390_OPERAND_PCREL
))
2342 fixP
->fx_where
+= 3;
2343 fixP
->fx_offset
+= 3;
2344 fixP
->fx_pcrel_adjust
= 3;
2345 fixP
->fx_r_type
= BFD_RELOC_390_PC24DBL
;
2347 else if (operand
->bits
== 32 && operand
->shift
== 16
2348 && (operand
->flags
& S390_OPERAND_PCREL
))
2351 fixP
->fx_where
+= 2;
2352 fixP
->fx_offset
+= 2;
2353 fixP
->fx_pcrel_adjust
= 2;
2354 fixP
->fx_r_type
= BFD_RELOC_390_PC32DBL
;
2361 /* Use expr_symbol_where to see if this is an expression
2363 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
2364 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2365 _("unresolved expression that must be resolved"));
2367 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2368 _("unsupported relocation type"));
2375 switch (fixP
->fx_r_type
)
2381 md_number_to_chars (where
, value
, 1);
2383 case BFD_RELOC_390_12
:
2384 case BFD_RELOC_390_GOT12
:
2385 case BFD_RELOC_390_GOTPLT12
:
2386 case BFD_RELOC_390_PC12DBL
:
2387 case BFD_RELOC_390_PLT12DBL
:
2389 value
+= fixP
->fx_pcrel_adjust
;
2398 mop
= bfd_getb16 ((unsigned char *) where
);
2399 mop
|= (unsigned short) (value
& 0xfff);
2400 bfd_putb16 ((bfd_vma
) mop
, (unsigned char *) where
);
2404 case BFD_RELOC_390_20
:
2405 case BFD_RELOC_390_GOT20
:
2406 case BFD_RELOC_390_GOTPLT20
:
2410 mop
= bfd_getb32 ((unsigned char *) where
);
2411 mop
|= (unsigned int) ((value
& 0xfff) << 8 |
2412 (value
& 0xff000) >> 12);
2413 bfd_putb32 ((bfd_vma
) mop
, (unsigned char *) where
);
2418 case BFD_RELOC_GPREL16
:
2419 case BFD_RELOC_16_GOT_PCREL
:
2420 case BFD_RELOC_16_GOTOFF
:
2422 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2423 _("cannot emit PC relative %s relocation%s%s"),
2424 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2425 fixP
->fx_addsy
!= NULL
? " against " : "",
2426 (fixP
->fx_addsy
!= NULL
2427 ? S_GET_NAME (fixP
->fx_addsy
)
2430 md_number_to_chars (where
, value
, 2);
2432 case BFD_RELOC_390_GOT16
:
2433 case BFD_RELOC_390_PLTOFF16
:
2434 case BFD_RELOC_390_GOTPLT16
:
2436 md_number_to_chars (where
, value
, 2);
2438 case BFD_RELOC_390_PC16DBL
:
2439 case BFD_RELOC_390_PLT16DBL
:
2440 value
+= fixP
->fx_pcrel_adjust
;
2442 md_number_to_chars (where
, (offsetT
) value
>> 1, 2);
2445 case BFD_RELOC_390_PC24DBL
:
2446 case BFD_RELOC_390_PLT24DBL
:
2447 value
+= fixP
->fx_pcrel_adjust
;
2453 mop
= bfd_getb32 ((unsigned char *) where
- 1);
2454 mop
|= (unsigned int) (value
& 0xffffff);
2455 bfd_putb32 ((bfd_vma
) mop
, (unsigned char *) where
- 1);
2461 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2463 fixP
->fx_r_type
= BFD_RELOC_32
;
2465 md_number_to_chars (where
, value
, 4);
2467 case BFD_RELOC_32_PCREL
:
2468 case BFD_RELOC_32_BASEREL
:
2469 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2471 md_number_to_chars (where
, value
, 4);
2473 case BFD_RELOC_32_GOT_PCREL
:
2474 case BFD_RELOC_390_PLTOFF32
:
2475 case BFD_RELOC_390_PLT32
:
2476 case BFD_RELOC_390_GOTPLT32
:
2478 md_number_to_chars (where
, value
, 4);
2480 case BFD_RELOC_390_PC32DBL
:
2481 case BFD_RELOC_390_PLT32DBL
:
2482 case BFD_RELOC_390_GOTPCDBL
:
2483 case BFD_RELOC_390_GOTENT
:
2484 case BFD_RELOC_390_GOTPLTENT
:
2485 value
+= fixP
->fx_pcrel_adjust
;
2487 md_number_to_chars (where
, (offsetT
) value
>> 1, 4);
2490 case BFD_RELOC_32_GOTOFF
:
2492 md_number_to_chars (where
, value
, sizeof (int));
2495 case BFD_RELOC_390_GOTOFF64
:
2497 md_number_to_chars (where
, value
, 8);
2500 case BFD_RELOC_390_GOT64
:
2501 case BFD_RELOC_390_PLTOFF64
:
2502 case BFD_RELOC_390_PLT64
:
2503 case BFD_RELOC_390_GOTPLT64
:
2505 md_number_to_chars (where
, value
, 8);
2510 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2512 fixP
->fx_r_type
= BFD_RELOC_64
;
2514 md_number_to_chars (where
, value
, 8);
2517 case BFD_RELOC_64_PCREL
:
2518 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2520 md_number_to_chars (where
, value
, 8);
2523 case BFD_RELOC_VTABLE_INHERIT
:
2524 case BFD_RELOC_VTABLE_ENTRY
:
2528 case BFD_RELOC_390_TLS_LOAD
:
2529 case BFD_RELOC_390_TLS_GDCALL
:
2530 case BFD_RELOC_390_TLS_LDCALL
:
2531 case BFD_RELOC_390_TLS_GD32
:
2532 case BFD_RELOC_390_TLS_GD64
:
2533 case BFD_RELOC_390_TLS_GOTIE12
:
2534 case BFD_RELOC_390_TLS_GOTIE20
:
2535 case BFD_RELOC_390_TLS_GOTIE32
:
2536 case BFD_RELOC_390_TLS_GOTIE64
:
2537 case BFD_RELOC_390_TLS_LDM32
:
2538 case BFD_RELOC_390_TLS_LDM64
:
2539 case BFD_RELOC_390_TLS_IE32
:
2540 case BFD_RELOC_390_TLS_IE64
:
2541 case BFD_RELOC_390_TLS_LE32
:
2542 case BFD_RELOC_390_TLS_LE64
:
2543 case BFD_RELOC_390_TLS_LDO32
:
2544 case BFD_RELOC_390_TLS_LDO64
:
2545 case BFD_RELOC_390_TLS_DTPMOD
:
2546 case BFD_RELOC_390_TLS_DTPOFF
:
2547 case BFD_RELOC_390_TLS_TPOFF
:
2548 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2549 /* Fully resolved at link time. */
2551 case BFD_RELOC_390_TLS_IEENT
:
2552 /* Fully resolved at link time. */
2553 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2559 const char *reloc_name
= bfd_get_reloc_code_name (fixP
->fx_r_type
);
2561 if (reloc_name
!= NULL
)
2562 as_fatal (_("Gas failure, reloc type %s\n"), reloc_name
);
2564 as_fatal (_("Gas failure, reloc type #%i\n"), fixP
->fx_r_type
);
2568 fixP
->fx_offset
= value
;
2572 /* Generate a reloc for a fixup. */
2575 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
2577 bfd_reloc_code_real_type code
;
2580 code
= fixp
->fx_r_type
;
2581 if (GOT_symbol
&& fixp
->fx_addsy
== GOT_symbol
)
2583 if ( (s390_arch_size
== 32 && code
== BFD_RELOC_32_PCREL
)
2584 || (s390_arch_size
== 64 && code
== BFD_RELOC_64_PCREL
))
2585 code
= BFD_RELOC_390_GOTPC
;
2586 if (code
== BFD_RELOC_390_PC32DBL
)
2587 code
= BFD_RELOC_390_GOTPCDBL
;
2590 reloc
= XNEW (arelent
);
2591 reloc
->sym_ptr_ptr
= XNEW (asymbol
*);
2592 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2593 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2594 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2595 if (reloc
->howto
== NULL
)
2597 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2598 _("cannot represent relocation type %s"),
2599 bfd_get_reloc_code_name (code
));
2600 /* Set howto to a garbage value so that we can keep going. */
2601 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
2602 gas_assert (reloc
->howto
!= NULL
);
2604 reloc
->addend
= fixp
->fx_offset
;
2610 s390_cfi_frame_initial_instructions (void)
2612 cfi_add_CFA_def_cfa (15, s390_arch_size
== 64 ? 160 : 96);
2616 tc_s390_regname_to_dw2regnum (char *regname
)
2620 if (regname
[0] != 'c' && regname
[0] != 'a')
2622 regnum
= reg_name_search (regname
);
2623 if (regname
[0] == 'f' && regnum
!= -1)
2626 else if (strcmp (regname
, "ap") == 0)
2628 else if (strcmp (regname
, "cc") == 0)
2634 s390_elf_final_processing (void)
2637 elf_elfheader (stdoutput
)->e_flags
|= EF_S390_HIGH_GPRS
;