1 /* tc-s390.c -- Assemble for the S390
2 Copyright (C) 2000-2015 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 "struc-symbol.h"
26 #include "dwarf2dbg.h"
27 #include "dw2gencfi.h"
29 #include "opcode/s390.h"
32 /* The default architecture. */
34 #define DEFAULT_ARCH "s390"
36 static char *default_arch
= DEFAULT_ARCH
;
37 /* Either 32 or 64, selects file format. */
38 static int s390_arch_size
= 0;
40 /* If no -march option was given default to the highest available CPU.
41 Since with S/390 a newer CPU always supports everything from its
42 predecessors this will accept every valid asm input. */
43 static unsigned int current_cpu
= S390_OPCODE_MAXCPU
- 1;
44 static unsigned int current_mode_mask
= 0;
46 /* Set to TRUE if the highgprs flag in the ELF header needs to be set
47 for the output file. */
48 static bfd_boolean set_highgprs_p
= FALSE
;
50 /* Whether to use user friendly register names. Default is TRUE. */
51 #ifndef TARGET_REG_NAMES_P
52 #define TARGET_REG_NAMES_P TRUE
55 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
57 /* Set to TRUE if we want to warn about zero base/index registers. */
58 static bfd_boolean warn_areg_zero
= FALSE
;
60 /* Generic assembler global variables which must be defined by all
63 const char comment_chars
[] = "#";
65 /* Characters which start a comment at the beginning of a line. */
66 const char line_comment_chars
[] = "#";
68 /* Characters which may be used to separate multiple commands on a
70 const char line_separator_chars
[] = ";";
72 /* Characters which are used to indicate an exponent in a floating
74 const char EXP_CHARS
[] = "eE";
76 /* Characters which mean that a number is a floating point constant,
78 const char FLT_CHARS
[] = "dD";
80 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
81 int s390_cie_data_alignment
;
83 /* The target specific pseudo-ops which we support. */
85 /* Define the prototypes for the pseudo-ops */
86 static void s390_byte (int);
87 static void s390_elf_cons (int);
88 static void s390_bss (int);
89 static void s390_insn (int);
90 static void s390_literals (int);
91 static void s390_machine (int);
92 static void s390_machinemode (int);
94 const pseudo_typeS md_pseudo_table
[] =
96 { "align", s_align_bytes
, 0 },
97 /* Pseudo-ops which must be defined. */
98 { "bss", s390_bss
, 0 },
99 { "insn", s390_insn
, 0 },
100 /* Pseudo-ops which must be overridden. */
101 { "byte", s390_byte
, 0 },
102 { "short", s390_elf_cons
, 2 },
103 { "long", s390_elf_cons
, 4 },
104 { "quad", s390_elf_cons
, 8 },
105 { "ltorg", s390_literals
, 0 },
106 { "string", stringer
, 8 + 1 },
107 { "machine", s390_machine
, 0 },
108 { "machinemode", s390_machinemode
, 0 },
112 /* Given NAME, find the register number associated with that name, return
113 the integer value associated with the given name or -1 on failure. */
116 reg_name_search (const char *name
)
120 if (strcasecmp (name
, "lit") == 0)
123 if (strcasecmp (name
, "sp") == 0)
126 if (name
[0] != 'a' && name
[0] != 'c' && name
[0] != 'f'
127 && name
[0] != 'r' && name
[0] != 'v')
130 if (ISDIGIT (name
[1]))
133 if (ISDIGIT (name
[2]))
134 val
= val
* 10 + name
[2] - '0';
137 if ((name
[0] != 'v' && val
> 15) || val
> 31)
145 * Summary of register_name().
147 * in: Input_line_pointer points to 1st char of operand.
149 * out: A expressionS.
150 * The operand may have been a register: in this case, X_op == O_register,
151 * X_add_number is set to the register number, and truth is returned.
152 * Input_line_pointer->(next non-blank) char after operand, or is in its
157 register_name (expressionS
*expressionP
)
164 /* Find the spelling of the operand. */
165 start
= name
= input_line_pointer
;
166 if (name
[0] == '%' && ISALPHA (name
[1]))
167 name
= ++input_line_pointer
;
171 c
= get_symbol_end ();
172 reg_number
= reg_name_search (name
);
174 /* Put back the delimiting char. */
175 *input_line_pointer
= c
;
177 /* Look to see if it's in the register table. */
180 expressionP
->X_op
= O_register
;
181 expressionP
->X_add_number
= reg_number
;
183 /* Make the rest nice. */
184 expressionP
->X_add_symbol
= NULL
;
185 expressionP
->X_op_symbol
= NULL
;
189 /* Reset the line as if we had not done anything. */
190 input_line_pointer
= start
;
194 /* Local variables. */
196 /* Opformat hash table. */
197 static struct hash_control
*s390_opformat_hash
;
199 /* Opcode hash table. */
200 static struct hash_control
*s390_opcode_hash
= NULL
;
202 /* Flags to set in the elf header */
203 static flagword s390_flags
= 0;
205 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
207 #ifndef WORKING_DOT_WORD
208 int md_short_jump_size
= 4;
209 int md_long_jump_size
= 4;
212 const char *md_shortopts
= "A:m:kVQ:";
213 struct option md_longopts
[] = {
214 {NULL
, no_argument
, NULL
, 0}
216 size_t md_longopts_size
= sizeof (md_longopts
);
218 /* Initialize the default opcode arch and word size from the default
219 architecture name if not specified by an option. */
221 init_default_arch (void)
223 if (strcmp (default_arch
, "s390") == 0)
225 if (s390_arch_size
== 0)
228 else if (strcmp (default_arch
, "s390x") == 0)
230 if (s390_arch_size
== 0)
234 as_fatal (_("Invalid default architecture, broken assembler."));
236 if (current_mode_mask
== 0)
238 /* Default to z/Architecture mode if the CPU supports it. */
239 if (current_cpu
< S390_OPCODE_Z900
)
240 current_mode_mask
= 1 << S390_OPCODE_ESA
;
242 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
246 /* Called by TARGET_FORMAT. */
248 s390_target_format (void)
250 /* We don't get a chance to initialize anything before we're called,
251 so handle that now. */
252 init_default_arch ();
254 return s390_arch_size
== 64 ? "elf64-s390" : "elf32-s390";
257 /* Map a CPU string as given with -march= or .machine to the
258 respective enum s390_opcode_cpu_val value. 0xffffffff is returned
259 in case of an error. */
262 s390_parse_cpu (char *arg
)
264 if (strcmp (arg
, "g5") == 0)
265 return S390_OPCODE_G5
;
266 else if (strcmp (arg
, "g6") == 0)
267 return S390_OPCODE_G6
;
268 else if (strcmp (arg
, "z900") == 0)
269 return S390_OPCODE_Z900
;
270 else if (strcmp (arg
, "z990") == 0)
271 return S390_OPCODE_Z990
;
272 else if (strcmp (arg
, "z9-109") == 0)
273 return S390_OPCODE_Z9_109
;
274 else if (strcmp (arg
, "z9-ec") == 0)
275 return S390_OPCODE_Z9_EC
;
276 else if (strcmp (arg
, "z10") == 0)
277 return S390_OPCODE_Z10
;
278 else if (strcmp (arg
, "z196") == 0)
279 return S390_OPCODE_Z196
;
280 else if (strcmp (arg
, "zEC12") == 0)
281 return S390_OPCODE_ZEC12
;
282 else if (strcmp (arg
, "z13") == 0)
283 return S390_OPCODE_Z13
;
284 else if (strcmp (arg
, "all") == 0)
285 return S390_OPCODE_MAXCPU
- 1;
291 md_parse_option (int c
, char *arg
)
295 /* -k: Ignore for FreeBSD compatibility. */
299 if (arg
!= NULL
&& strcmp (arg
, "regnames") == 0)
302 else if (arg
!= NULL
&& strcmp (arg
, "no-regnames") == 0)
305 else if (arg
!= NULL
&& strcmp (arg
, "warn-areg-zero") == 0)
306 warn_areg_zero
= TRUE
;
308 else if (arg
!= NULL
&& strcmp (arg
, "31") == 0)
311 else if (arg
!= NULL
&& strcmp (arg
, "64") == 0)
314 else if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
315 current_mode_mask
= 1 << S390_OPCODE_ESA
;
317 else if (arg
!= NULL
&& strcmp (arg
, "zarch") == 0)
319 if (s390_arch_size
== 32)
320 set_highgprs_p
= TRUE
;
321 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
324 else if (arg
!= NULL
&& strncmp (arg
, "arch=", 5) == 0)
326 current_cpu
= s390_parse_cpu (arg
+ 5);
328 if (current_cpu
== (unsigned int)-1)
330 as_bad (_("invalid switch -m%s"), arg
);
337 as_bad (_("invalid switch -m%s"), arg
);
343 /* Option -A is deprecated. Still available for compatibility. */
344 if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
345 current_cpu
= S390_OPCODE_G5
;
346 else if (arg
!= NULL
&& strcmp (arg
, "esame") == 0)
347 current_cpu
= S390_OPCODE_Z900
;
349 as_bad (_("invalid architecture -A%s"), arg
);
352 /* -V: SVR4 argument to print version ID. */
357 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
358 should be emitted or not. FIXME: Not implemented. */
370 md_show_usage (FILE *stream
)
372 fprintf (stream
, _("\
374 -mregnames Allow symbolic names for registers\n\
375 -mwarn-areg-zero Warn about zero base/index registers\n\
376 -mno-regnames Do not allow symbolic names for registers\n\
377 -m31 Set file format to 31 bit format\n\
378 -m64 Set file format to 64 bit format\n"));
379 fprintf (stream
, _("\
380 -V print assembler version number\n\
381 -Qy, -Qn ignored\n"));
384 /* Generate the hash table mapping mnemonics to struct s390_opcode.
385 This table is built at startup and whenever the CPU level is
386 changed using .machine. */
389 s390_setup_opcodes (void)
391 const struct s390_opcode
*op
;
392 const struct s390_opcode
*op_end
;
393 bfd_boolean dup_insn
= FALSE
;
396 if (s390_opcode_hash
!= NULL
)
397 hash_die (s390_opcode_hash
);
399 /* Insert the opcodes into a hash table. */
400 s390_opcode_hash
= hash_new ();
402 op_end
= s390_opcodes
+ s390_num_opcodes
;
403 for (op
= s390_opcodes
; op
< op_end
; op
++)
405 while (op
< op_end
- 1 && strcmp(op
->name
, op
[1].name
) == 0)
407 if (op
->min_cpu
<= current_cpu
&& (op
->modes
& current_mode_mask
))
412 if (op
->min_cpu
<= current_cpu
&& (op
->modes
& current_mode_mask
))
414 retval
= hash_insert (s390_opcode_hash
, op
->name
, (void *) op
);
415 if (retval
!= (const char *) NULL
)
417 as_bad (_("Internal assembler error for instruction %s"),
423 while (op
< op_end
- 1 && strcmp (op
->name
, op
[1].name
) == 0)
431 /* This function is called when the assembler starts up. It is called
432 after the options have been parsed and the output file has been
438 const struct s390_opcode
*op
;
439 const struct s390_opcode
*op_end
;
442 /* Give a warning if the combination -m64-bit and -Aesa is used. */
443 if (s390_arch_size
== 64 && current_cpu
< S390_OPCODE_Z900
)
444 as_warn (_("The 64 bit file format is used without esame instructions."));
446 s390_cie_data_alignment
= -s390_arch_size
/ 8;
448 /* Set the ELF flags if desired. */
450 bfd_set_private_flags (stdoutput
, s390_flags
);
452 /* Insert the opcode formats into a hash table. */
453 s390_opformat_hash
= hash_new ();
455 op_end
= s390_opformats
+ s390_num_opformats
;
456 for (op
= s390_opformats
; op
< op_end
; op
++)
458 retval
= hash_insert (s390_opformat_hash
, op
->name
, (void *) op
);
459 if (retval
!= (const char *) NULL
)
460 as_bad (_("Internal assembler error for instruction format %s"),
464 s390_setup_opcodes ();
466 record_alignment (text_section
, 2);
467 record_alignment (data_section
, 2);
468 record_alignment (bss_section
, 2);
471 /* Called after all assembly has been done. */
475 if (s390_arch_size
== 64)
476 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_64
);
478 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_31
);
481 /* Insert an operand value into an instruction. */
484 s390_insert_operand (unsigned char *insn
,
485 const struct s390_operand
*operand
,
493 if (operand
->flags
& (S390_OPERAND_SIGNED
|S390_OPERAND_PCREL
))
497 max
= ((offsetT
) 1 << (operand
->bits
- 1)) - 1;
498 min
= - ((offsetT
) 1 << (operand
->bits
- 1));
499 /* Halve PCREL operands. */
500 if (operand
->flags
& S390_OPERAND_PCREL
)
502 /* Check for underflow / overflow. */
503 if (val
< min
|| val
> max
)
506 _("operand out of range (%s not between %ld and %ld)");
509 if (operand
->flags
& S390_OPERAND_PCREL
)
515 sprint_value (buf
, val
);
516 if (file
== (char *) NULL
)
517 as_bad (err
, buf
, (int) min
, (int) max
);
519 as_bad_where (file
, line
, err
, buf
, (int) min
, (int) max
);
522 /* val is ok, now restrict it to operand->bits bits. */
523 uval
= (addressT
) val
& ((((addressT
) 1 << (operand
->bits
-1)) << 1) - 1);
524 /* val is restrict, now check for special case. */
525 if (operand
->bits
== 20 && operand
->shift
== 20)
526 uval
= (uval
>> 12) | ((uval
& 0xfff) << 8);
532 max
= (((addressT
) 1 << (operand
->bits
- 1)) << 1) - 1;
534 uval
= (addressT
) val
;
536 /* Vector register operands have an additional bit in the RXB
538 if (operand
->flags
& S390_OPERAND_VR
)
539 max
= (max
<< 1) | 1;
541 /* Length x in an instructions has real length x+1. */
542 if (operand
->flags
& S390_OPERAND_LENGTH
)
544 /* Check for underflow / overflow. */
545 if (uval
< min
|| uval
> max
)
547 if (operand
->flags
& S390_OPERAND_LENGTH
)
554 as_bad_value_out_of_range (_("operand"), uval
, (offsetT
) min
, (offsetT
) max
, file
, line
);
560 if (operand
->flags
& S390_OPERAND_VR
)
562 /* Insert the extra bit into the RXB field. */
563 switch (operand
->shift
)
566 insn
[4] |= (uval
& 0x10) >> 1;
569 insn
[4] |= (uval
& 0x10) >> 2;
572 insn
[4] |= (uval
& 0x10) >> 3;
575 insn
[4] |= (uval
& 0x10) >> 4;
581 if (operand
->flags
& S390_OPERAND_OR1
)
583 if (operand
->flags
& S390_OPERAND_OR2
)
585 if (operand
->flags
& S390_OPERAND_OR8
)
588 /* Duplicate the operand at bit pos 12 to 16. */
589 if (operand
->flags
& S390_OPERAND_CP16
)
591 /* Copy VR operand at bit pos 12 to bit pos 16. */
592 insn
[2] |= uval
<< 4;
593 /* Copy the flag in the RXB field. */
594 insn
[4] |= (insn
[4] & 4) >> 1;
597 /* Insert fragments of the operand byte for byte. */
598 offset
= operand
->shift
+ operand
->bits
;
599 uval
<<= (-offset
) & 7;
600 insn
+= (offset
- 1) / 8;
612 bfd_reloc_code_real_type reloc
;
615 /* Parse tls marker and return the desired relocation. */
616 static bfd_reloc_code_real_type
617 s390_tls_suffix (char **str_p
, expressionS
*exp_p
)
619 static struct map_tls mapping
[] =
621 { "tls_load", 8, BFD_RELOC_390_TLS_LOAD
},
622 { "tls_gdcall", 10, BFD_RELOC_390_TLS_GDCALL
},
623 { "tls_ldcall", 10, BFD_RELOC_390_TLS_LDCALL
},
624 { NULL
, 0, BFD_RELOC_UNUSED
}
634 return BFD_RELOC_UNUSED
;
637 while (ISIDNUM (*str
))
641 return BFD_RELOC_UNUSED
;
643 orig_line
= input_line_pointer
;
644 input_line_pointer
= str
;
646 str
= input_line_pointer
;
647 if (&input_line_pointer
!= str_p
)
648 input_line_pointer
= orig_line
;
650 if (exp_p
->X_op
!= O_symbol
)
651 return BFD_RELOC_UNUSED
;
653 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
654 if (len
== ptr
->length
655 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
657 /* Found a matching tls suffix. */
661 return BFD_RELOC_UNUSED
;
664 /* Structure used to hold suffixes. */
675 ELF_SUFFIX_TLS_GOTIE
,
687 elf_suffix_type suffix
;
691 /* Parse @got/@plt/@gotoff. and return the desired relocation. */
692 static elf_suffix_type
693 s390_elf_suffix (char **str_p
, expressionS
*exp_p
)
695 static struct map_bfd mapping
[] =
697 { "got", 3, ELF_SUFFIX_GOT
},
698 { "got12", 5, ELF_SUFFIX_GOT
},
699 { "plt", 3, ELF_SUFFIX_PLT
},
700 { "gotent", 6, ELF_SUFFIX_GOTENT
},
701 { "gotoff", 6, ELF_SUFFIX_GOTOFF
},
702 { "gotplt", 6, ELF_SUFFIX_GOTPLT
},
703 { "pltoff", 6, ELF_SUFFIX_PLTOFF
},
704 { "tlsgd", 5, ELF_SUFFIX_TLS_GD
},
705 { "gotntpoff", 9, ELF_SUFFIX_TLS_GOTIE
},
706 { "indntpoff", 9, ELF_SUFFIX_TLS_IE
},
707 { "tlsldm", 6, ELF_SUFFIX_TLS_LDM
},
708 { "dtpoff", 6, ELF_SUFFIX_TLS_LDO
},
709 { "ntpoff", 6, ELF_SUFFIX_TLS_LE
},
710 { NULL
, 0, ELF_SUFFIX_NONE
}
719 return ELF_SUFFIX_NONE
;
722 while (ISALNUM (*str
))
726 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
727 if (len
== ptr
->length
728 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
730 if (exp_p
->X_add_number
!= 0)
731 as_warn (_("identifier+constant@%s means identifier@%s+constant"),
732 ptr
->string
, ptr
->string
);
733 /* Now check for identifier@suffix+constant. */
734 if (*str
== '-' || *str
== '+')
736 char *orig_line
= input_line_pointer
;
739 input_line_pointer
= str
;
740 expression (&new_exp
);
742 switch (new_exp
.X_op
)
744 case O_constant
: /* X_add_number (a constant expression). */
745 exp_p
->X_add_number
+= new_exp
.X_add_number
;
746 str
= input_line_pointer
;
748 case O_symbol
: /* X_add_symbol + X_add_number. */
749 /* this case is used for e.g. xyz@PLT+.Label. */
750 exp_p
->X_add_number
+= new_exp
.X_add_number
;
751 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
753 str
= input_line_pointer
;
755 case O_uminus
: /* (- X_add_symbol) + X_add_number. */
756 /* this case is used for e.g. xyz@PLT-.Label. */
757 exp_p
->X_add_number
+= new_exp
.X_add_number
;
758 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
759 exp_p
->X_op
= O_subtract
;
760 str
= input_line_pointer
;
766 /* If s390_elf_suffix has not been called with
767 &input_line_pointer as first parameter, we have
768 clobbered the input_line_pointer. We have to
770 if (&input_line_pointer
!= str_p
)
771 input_line_pointer
= orig_line
;
777 return BFD_RELOC_UNUSED
;
780 /* Structure used to hold a literal pool entry. */
783 struct s390_lpe
*next
;
785 FLONUM_TYPE floatnum
; /* used if X_op == O_big && X_add_number <= 0 */
786 LITTLENUM_TYPE bignum
[4]; /* used if X_op == O_big && X_add_number > 0 */
788 bfd_reloc_code_real_type reloc
;
792 static struct s390_lpe
*lpe_free_list
= NULL
;
793 static struct s390_lpe
*lpe_list
= NULL
;
794 static struct s390_lpe
*lpe_list_tail
= NULL
;
795 static symbolS
*lp_sym
= NULL
;
796 static int lp_count
= 0;
797 static int lpe_count
= 0;
800 s390_exp_compare (expressionS
*exp1
, expressionS
*exp2
)
802 if (exp1
->X_op
!= exp2
->X_op
)
807 case O_constant
: /* X_add_number must be equal. */
809 return exp1
->X_add_number
== exp2
->X_add_number
;
812 as_bad (_("Can't handle O_big in s390_exp_compare"));
814 case O_symbol
: /* X_add_symbol & X_add_number must be equal. */
819 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
820 && (exp1
->X_add_number
== exp2
->X_add_number
);
822 case O_multiply
: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
827 case O_bit_inclusive_or
:
829 case O_bit_exclusive_or
:
841 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
842 && (exp1
->X_op_symbol
== exp2
->X_op_symbol
)
843 && (exp1
->X_add_number
== exp2
->X_add_number
);
849 /* Test for @lit and if its present make an entry in the literal pool and
850 modify the current expression to be an offset into the literal pool. */
851 static elf_suffix_type
852 s390_lit_suffix (char **str_p
, expressionS
*exp_p
, elf_suffix_type suffix
)
854 bfd_reloc_code_real_type reloc
;
858 struct s390_lpe
*lpe
;
862 return suffix
; /* No modification. */
864 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
866 while (ISALNUM (*str
))
869 if (len
!= 4 || strncasecmp (ident
, "lit", 3) != 0
870 || (ident
[3]!='1' && ident
[3]!='2' && ident
[3]!='4' && ident
[3]!='8'))
871 return suffix
; /* no modification */
872 nbytes
= ident
[3] - '0';
874 reloc
= BFD_RELOC_UNUSED
;
875 if (suffix
== ELF_SUFFIX_GOT
)
878 reloc
= BFD_RELOC_390_GOT16
;
879 else if (nbytes
== 4)
880 reloc
= BFD_RELOC_32_GOT_PCREL
;
881 else if (nbytes
== 8)
882 reloc
= BFD_RELOC_390_GOT64
;
884 else if (suffix
== ELF_SUFFIX_PLT
)
887 reloc
= BFD_RELOC_390_PLT32
;
888 else if (nbytes
== 8)
889 reloc
= BFD_RELOC_390_PLT64
;
892 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
893 as_bad (_("Invalid suffix for literal pool entry"));
895 /* Search the pool if the new entry is a duplicate. */
896 if (exp_p
->X_op
== O_big
)
898 /* Special processing for big numbers. */
899 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
901 if (lpe
->ex
.X_op
== O_big
)
903 if (exp_p
->X_add_number
<= 0 && lpe
->ex
.X_add_number
<= 0)
905 if (memcmp (&generic_floating_point_number
, &lpe
->floatnum
,
906 sizeof (FLONUM_TYPE
)) == 0)
909 else if (exp_p
->X_add_number
== lpe
->ex
.X_add_number
)
911 if (memcmp (generic_bignum
, lpe
->bignum
,
912 sizeof (LITTLENUM_TYPE
)*exp_p
->X_add_number
) == 0)
920 /* Processing for 'normal' data types. */
921 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
922 if (lpe
->nbytes
== nbytes
&& lpe
->reloc
== reloc
923 && s390_exp_compare (exp_p
, &lpe
->ex
) != 0)
930 if (lpe_free_list
!= NULL
)
933 lpe_free_list
= lpe_free_list
->next
;
937 lpe
= (struct s390_lpe
*) xmalloc (sizeof (struct s390_lpe
));
942 if (exp_p
->X_op
== O_big
)
944 if (exp_p
->X_add_number
<= 0)
945 lpe
->floatnum
= generic_floating_point_number
;
946 else if (exp_p
->X_add_number
<= 4)
947 memcpy (lpe
->bignum
, generic_bignum
,
948 exp_p
->X_add_number
* sizeof (LITTLENUM_TYPE
));
950 as_bad (_("Big number is too big"));
953 lpe
->nbytes
= nbytes
;
955 /* Literal pool name defined ? */
958 sprintf (tmp_name
, ".L\001%i", lp_count
);
959 lp_sym
= symbol_make (tmp_name
);
962 /* Make name for literal pool entry. */
963 sprintf (tmp_name
, ".L\001%i\002%i", lp_count
, lpe_count
);
965 lpe
->sym
= symbol_make (tmp_name
);
967 /* Add to literal pool list. */
969 if (lpe_list_tail
!= NULL
)
971 lpe_list_tail
->next
= lpe
;
975 lpe_list
= lpe_list_tail
= lpe
;
978 /* Now change exp_p to the offset into the literal pool.
979 Thats the expression: .L^Ax^By-.L^Ax */
980 exp_p
->X_add_symbol
= lpe
->sym
;
981 exp_p
->X_op_symbol
= lp_sym
;
982 exp_p
->X_op
= O_subtract
;
983 exp_p
->X_add_number
= 0;
987 /* We change the suffix type to ELF_SUFFIX_NONE, because
988 the difference of two local labels is just a number. */
989 return ELF_SUFFIX_NONE
;
992 /* Like normal .long/.short/.word, except support @got, etc.
993 clobbers input_line_pointer, checks end-of-line. */
995 s390_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long */)
998 elf_suffix_type suffix
;
1000 if (is_it_end_of_statement ())
1002 demand_empty_rest_of_line ();
1010 if (exp
.X_op
== O_symbol
1011 && *input_line_pointer
== '@'
1012 && (suffix
= s390_elf_suffix (&input_line_pointer
, &exp
)) != ELF_SUFFIX_NONE
)
1014 bfd_reloc_code_real_type reloc
;
1015 reloc_howto_type
*reloc_howto
;
1021 static bfd_reloc_code_real_type tab2
[] =
1023 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1024 BFD_RELOC_390_GOT16
, /* ELF_SUFFIX_GOT */
1025 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_PLT */
1026 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1027 BFD_RELOC_16_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1028 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTPLT */
1029 BFD_RELOC_390_PLTOFF16
, /* ELF_SUFFIX_PLTOFF */
1030 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GD */
1031 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GOTIE */
1032 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_IE */
1033 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDM */
1034 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDO */
1035 BFD_RELOC_UNUSED
/* ELF_SUFFIX_TLS_LE */
1037 reloc
= tab2
[suffix
];
1039 else if (nbytes
== 4)
1041 static bfd_reloc_code_real_type tab4
[] =
1043 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1044 BFD_RELOC_32_GOT_PCREL
, /* ELF_SUFFIX_GOT */
1045 BFD_RELOC_390_PLT32
, /* ELF_SUFFIX_PLT */
1046 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1047 BFD_RELOC_32_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1048 BFD_RELOC_390_GOTPLT32
, /* ELF_SUFFIX_GOTPLT */
1049 BFD_RELOC_390_PLTOFF32
, /* ELF_SUFFIX_PLTOFF */
1050 BFD_RELOC_390_TLS_GD32
, /* ELF_SUFFIX_TLS_GD */
1051 BFD_RELOC_390_TLS_GOTIE32
, /* ELF_SUFFIX_TLS_GOTIE */
1052 BFD_RELOC_390_TLS_IE32
, /* ELF_SUFFIX_TLS_IE */
1053 BFD_RELOC_390_TLS_LDM32
, /* ELF_SUFFIX_TLS_LDM */
1054 BFD_RELOC_390_TLS_LDO32
, /* ELF_SUFFIX_TLS_LDO */
1055 BFD_RELOC_390_TLS_LE32
/* ELF_SUFFIX_TLS_LE */
1057 reloc
= tab4
[suffix
];
1059 else if (nbytes
== 8)
1061 static bfd_reloc_code_real_type tab8
[] =
1063 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1064 BFD_RELOC_390_GOT64
, /* ELF_SUFFIX_GOT */
1065 BFD_RELOC_390_PLT64
, /* ELF_SUFFIX_PLT */
1066 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1067 BFD_RELOC_390_GOTOFF64
, /* ELF_SUFFIX_GOTOFF */
1068 BFD_RELOC_390_GOTPLT64
, /* ELF_SUFFIX_GOTPLT */
1069 BFD_RELOC_390_PLTOFF64
, /* ELF_SUFFIX_PLTOFF */
1070 BFD_RELOC_390_TLS_GD64
, /* ELF_SUFFIX_TLS_GD */
1071 BFD_RELOC_390_TLS_GOTIE64
, /* ELF_SUFFIX_TLS_GOTIE */
1072 BFD_RELOC_390_TLS_IE64
, /* ELF_SUFFIX_TLS_IE */
1073 BFD_RELOC_390_TLS_LDM64
, /* ELF_SUFFIX_TLS_LDM */
1074 BFD_RELOC_390_TLS_LDO64
, /* ELF_SUFFIX_TLS_LDO */
1075 BFD_RELOC_390_TLS_LE64
/* ELF_SUFFIX_TLS_LE */
1077 reloc
= tab8
[suffix
];
1080 reloc
= BFD_RELOC_UNUSED
;
1082 if (reloc
!= BFD_RELOC_UNUSED
1083 && (reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
)))
1085 size
= bfd_get_reloc_size (reloc_howto
);
1087 as_bad (_("%s relocations do not fit in %d bytes"),
1088 reloc_howto
->name
, nbytes
);
1089 where
= frag_more (nbytes
);
1090 md_number_to_chars (where
, 0, size
);
1091 /* To make fixup_segment do the pc relative conversion the
1092 pcrel parameter on the fix_new_exp call needs to be FALSE. */
1093 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1094 size
, &exp
, FALSE
, reloc
);
1097 as_bad (_("relocation not applicable"));
1100 emit_expr (&exp
, (unsigned int) nbytes
);
1102 while (*input_line_pointer
++ == ',');
1104 input_line_pointer
--; /* Put terminator back into stream. */
1105 demand_empty_rest_of_line ();
1108 /* We need to keep a list of fixups. We can't simply generate them as
1109 we go, because that would require us to first create the frag, and
1110 that would screw up references to ``.''. */
1116 bfd_reloc_code_real_type reloc
;
1119 #define MAX_INSN_FIXUPS (4)
1121 /* This routine is called for each instruction to be assembled. */
1124 md_gather_operands (char *str
,
1125 unsigned char *insn
,
1126 const struct s390_opcode
*opcode
)
1128 struct s390_fixup fixups
[MAX_INSN_FIXUPS
];
1129 const struct s390_operand
*operand
;
1130 const unsigned char *opindex_ptr
;
1132 elf_suffix_type suffix
;
1133 bfd_reloc_code_real_type reloc
;
1138 while (ISSPACE (*str
))
1143 /* Gather the operands. */
1145 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1149 operand
= s390_operands
+ *opindex_ptr
;
1151 if ((opcode
->flags
& S390_INSTR_FLAG_OPTPARM
) && *str
== '\0')
1153 /* Optional parameters might need to be ORed with a
1154 value so calling s390_insert_operand is needed. */
1155 s390_insert_operand (insn
, operand
, 0, NULL
, 0);
1159 if (skip_optional
&& (operand
->flags
& S390_OPERAND_INDEX
))
1161 /* We do an early skip. For D(X,B) constructions the index
1162 register is skipped (X is optional). For D(L,B) the base
1163 register will be the skipped operand, because L is NOT
1169 /* Gather the operand. */
1170 hold
= input_line_pointer
;
1171 input_line_pointer
= str
;
1173 /* Parse the operand. */
1174 if (! register_name (&ex
))
1177 str
= input_line_pointer
;
1178 input_line_pointer
= hold
;
1180 /* Write the operand to the insn. */
1181 if (ex
.X_op
== O_illegal
)
1182 as_bad (_("illegal operand"));
1183 else if (ex
.X_op
== O_absent
)
1185 /* No operands, check if all operands can be skipped. */
1186 while (*opindex_ptr
!= 0 && operand
->flags
& S390_OPERAND_OPTIONAL
)
1188 if (operand
->flags
& S390_OPERAND_DISP
)
1190 /* An optional displacement makes the whole D(X,B)
1191 D(L,B) or D(B) block optional. */
1193 operand
= s390_operands
+ *(++opindex_ptr
);
1194 } while (!(operand
->flags
& S390_OPERAND_BASE
));
1196 operand
= s390_operands
+ *(++opindex_ptr
);
1198 if (opindex_ptr
[0] == '\0')
1200 as_bad (_("missing operand"));
1202 else if (ex
.X_op
== O_register
|| ex
.X_op
== O_constant
)
1204 s390_lit_suffix (&str
, &ex
, ELF_SUFFIX_NONE
);
1206 if (ex
.X_op
!= O_register
&& ex
.X_op
!= O_constant
)
1208 /* We need to generate a fixup for the
1209 expression returned by s390_lit_suffix. */
1210 if (fc
>= MAX_INSN_FIXUPS
)
1211 as_fatal (_("too many fixups"));
1212 fixups
[fc
].exp
= ex
;
1213 fixups
[fc
].opindex
= *opindex_ptr
;
1214 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
1219 if ((operand
->flags
& S390_OPERAND_LENGTH
)
1220 && ex
.X_op
!= O_constant
)
1221 as_fatal (_("invalid length field specified"));
1222 if ((operand
->flags
& S390_OPERAND_INDEX
)
1223 && ex
.X_add_number
== 0
1225 as_warn (_("index register specified but zero"));
1226 if ((operand
->flags
& S390_OPERAND_BASE
)
1227 && ex
.X_add_number
== 0
1229 as_warn (_("base register specified but zero"));
1230 if ((operand
->flags
& S390_OPERAND_GPR
)
1231 && (operand
->flags
& S390_OPERAND_REG_PAIR
)
1232 && (ex
.X_add_number
& 1))
1233 as_fatal (_("odd numbered general purpose register specified as "
1235 if ((operand
->flags
& S390_OPERAND_FPR
)
1236 && (operand
->flags
& S390_OPERAND_REG_PAIR
)
1237 && ex
.X_add_number
!= 0 && ex
.X_add_number
!= 1
1238 && ex
.X_add_number
!= 4 && ex
.X_add_number
!= 5
1239 && ex
.X_add_number
!= 8 && ex
.X_add_number
!= 9
1240 && ex
.X_add_number
!= 12 && ex
.X_add_number
!= 13)
1241 as_fatal (_("invalid floating point register pair. Valid fp "
1242 "register pair operands are 0, 1, 4, 5, 8, 9, "
1244 s390_insert_operand (insn
, operand
, ex
.X_add_number
, NULL
, 0);
1249 suffix
= s390_elf_suffix (&str
, &ex
);
1250 suffix
= s390_lit_suffix (&str
, &ex
, suffix
);
1251 reloc
= BFD_RELOC_UNUSED
;
1253 if (suffix
== ELF_SUFFIX_GOT
)
1255 if ((operand
->flags
& S390_OPERAND_DISP
) &&
1256 (operand
->bits
== 12))
1257 reloc
= BFD_RELOC_390_GOT12
;
1258 else if ((operand
->flags
& S390_OPERAND_DISP
) &&
1259 (operand
->bits
== 20))
1260 reloc
= BFD_RELOC_390_GOT20
;
1261 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1262 && (operand
->bits
== 16))
1263 reloc
= BFD_RELOC_390_GOT16
;
1264 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1265 && (operand
->bits
== 32))
1266 reloc
= BFD_RELOC_390_GOTENT
;
1268 else if (suffix
== ELF_SUFFIX_PLT
)
1270 if ((operand
->flags
& S390_OPERAND_PCREL
)
1271 && (operand
->bits
== 12))
1272 reloc
= BFD_RELOC_390_PLT12DBL
;
1273 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1274 && (operand
->bits
== 16))
1275 reloc
= BFD_RELOC_390_PLT16DBL
;
1276 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1277 && (operand
->bits
== 24))
1278 reloc
= BFD_RELOC_390_PLT24DBL
;
1279 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1280 && (operand
->bits
== 32))
1281 reloc
= BFD_RELOC_390_PLT32DBL
;
1283 else if (suffix
== ELF_SUFFIX_GOTENT
)
1285 if ((operand
->flags
& S390_OPERAND_PCREL
)
1286 && (operand
->bits
== 32))
1287 reloc
= BFD_RELOC_390_GOTENT
;
1289 else if (suffix
== ELF_SUFFIX_GOTOFF
)
1291 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1292 && (operand
->bits
== 16))
1293 reloc
= BFD_RELOC_16_GOTOFF
;
1295 else if (suffix
== ELF_SUFFIX_PLTOFF
)
1297 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1298 && (operand
->bits
== 16))
1299 reloc
= BFD_RELOC_390_PLTOFF16
;
1301 else if (suffix
== ELF_SUFFIX_GOTPLT
)
1303 if ((operand
->flags
& S390_OPERAND_DISP
)
1304 && (operand
->bits
== 12))
1305 reloc
= BFD_RELOC_390_GOTPLT12
;
1306 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1307 && (operand
->bits
== 16))
1308 reloc
= BFD_RELOC_390_GOTPLT16
;
1309 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1310 && (operand
->bits
== 32))
1311 reloc
= BFD_RELOC_390_GOTPLTENT
;
1313 else if (suffix
== ELF_SUFFIX_TLS_GOTIE
)
1315 if ((operand
->flags
& S390_OPERAND_DISP
)
1316 && (operand
->bits
== 12))
1317 reloc
= BFD_RELOC_390_TLS_GOTIE12
;
1318 else if ((operand
->flags
& S390_OPERAND_DISP
)
1319 && (operand
->bits
== 20))
1320 reloc
= BFD_RELOC_390_TLS_GOTIE20
;
1322 else if (suffix
== ELF_SUFFIX_TLS_IE
)
1324 if ((operand
->flags
& S390_OPERAND_PCREL
)
1325 && (operand
->bits
== 32))
1326 reloc
= BFD_RELOC_390_TLS_IEENT
;
1329 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
1330 as_bad (_("invalid operand suffix"));
1331 /* We need to generate a fixup of type 'reloc' for this
1333 if (fc
>= MAX_INSN_FIXUPS
)
1334 as_fatal (_("too many fixups"));
1335 fixups
[fc
].exp
= ex
;
1336 fixups
[fc
].opindex
= *opindex_ptr
;
1337 fixups
[fc
].reloc
= reloc
;
1341 /* Check the next character. The call to expression has advanced
1342 str past any whitespace. */
1343 if (operand
->flags
& S390_OPERAND_DISP
)
1345 /* After a displacement a block in parentheses can start. */
1348 /* Check if parenthesized block can be skipped. If the next
1349 operand is neiter an optional operand nor a base register
1350 then we have a syntax error. */
1351 operand
= s390_operands
+ *(++opindex_ptr
);
1352 if (!(operand
->flags
& (S390_OPERAND_INDEX
|S390_OPERAND_BASE
)))
1353 as_bad (_("syntax error; missing '(' after displacement"));
1355 /* Ok, skip all operands until S390_OPERAND_BASE. */
1356 while (!(operand
->flags
& S390_OPERAND_BASE
))
1357 operand
= s390_operands
+ *(++opindex_ptr
);
1359 /* If there is a next operand it must be separated by a comma. */
1360 if (opindex_ptr
[1] != '\0')
1364 while (opindex_ptr
[1] != '\0')
1366 operand
= s390_operands
+ *(++opindex_ptr
);
1367 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1369 as_bad (_("syntax error; expected ,"));
1379 /* We found an opening parentheses. */
1381 for (f
= str
; *f
!= '\0'; f
++)
1382 if (*f
== ',' || *f
== ')')
1384 /* If there is no comma until the closing parentheses OR
1385 there is a comma right after the opening parentheses,
1386 we have to skip optional operands. */
1387 if (*f
== ',' && f
== str
)
1389 /* comma directly after '(' ? */
1394 skip_optional
= (*f
!= ',');
1397 else if (operand
->flags
& S390_OPERAND_BASE
)
1399 /* After the base register the parenthesed block ends. */
1401 as_bad (_("syntax error; missing ')' after base register"));
1403 /* If there is a next operand it must be separated by a comma. */
1404 if (opindex_ptr
[1] != '\0')
1408 while (opindex_ptr
[1] != '\0')
1410 operand
= s390_operands
+ *(++opindex_ptr
);
1411 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1413 as_bad (_("syntax error; expected ,"));
1423 /* We can find an 'early' closing parentheses in e.g. D(L) instead
1424 of D(L,B). In this case the base register has to be skipped. */
1427 operand
= s390_operands
+ *(++opindex_ptr
);
1429 if (!(operand
->flags
& S390_OPERAND_BASE
))
1430 as_bad (_("syntax error; ')' not allowed here"));
1434 if ((opcode
->flags
& S390_INSTR_FLAG_OPTPARM
) && *str
== '\0')
1437 /* If there is a next operand it must be separated by a comma. */
1438 if (opindex_ptr
[1] != '\0')
1442 while (opindex_ptr
[1] != '\0')
1444 operand
= s390_operands
+ *(++opindex_ptr
);
1445 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1447 as_bad (_("syntax error; expected ,"));
1457 while (ISSPACE (*str
))
1460 /* Check for tls instruction marker. */
1461 reloc
= s390_tls_suffix (&str
, &ex
);
1462 if (reloc
!= BFD_RELOC_UNUSED
)
1464 /* We need to generate a fixup of type 'reloc' for this
1466 if (fc
>= MAX_INSN_FIXUPS
)
1467 as_fatal (_("too many fixups"));
1468 fixups
[fc
].exp
= ex
;
1469 fixups
[fc
].opindex
= -1;
1470 fixups
[fc
].reloc
= reloc
;
1478 if ((linefeed
= strchr (str
, '\n')) != NULL
)
1480 as_bad (_("junk at end of line: `%s'"), str
);
1481 if (linefeed
!= NULL
)
1485 /* Write out the instruction. */
1486 f
= frag_more (opcode
->oplen
);
1487 memcpy (f
, insn
, opcode
->oplen
);
1488 dwarf2_emit_insn (opcode
->oplen
);
1490 /* Create any fixups. At this point we do not use a
1491 bfd_reloc_code_real_type, but instead just use the
1492 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1493 handle fixups for any operand type, although that is admittedly
1494 not a very exciting feature. We pick a BFD reloc type in
1496 for (i
= 0; i
< fc
; i
++)
1499 if (fixups
[i
].opindex
< 0)
1501 /* Create tls instruction marker relocation. */
1502 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, opcode
->oplen
,
1503 &fixups
[i
].exp
, 0, fixups
[i
].reloc
);
1507 operand
= s390_operands
+ fixups
[i
].opindex
;
1509 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
1511 reloc_howto_type
*reloc_howto
;
1515 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
1519 size
= ((reloc_howto
->bitsize
- 1) / 8) + 1;
1521 if (size
< 1 || size
> 4)
1524 fixP
= fix_new_exp (frag_now
,
1525 f
- frag_now
->fr_literal
+ (operand
->shift
/8),
1526 size
, &fixups
[i
].exp
, reloc_howto
->pc_relative
,
1528 /* Turn off overflow checking in fixup_segment. This is necessary
1529 because fixup_segment will signal an overflow for large 4 byte
1530 quantities for GOT12 relocations. */
1531 if ( fixups
[i
].reloc
== BFD_RELOC_390_GOT12
1532 || fixups
[i
].reloc
== BFD_RELOC_390_GOT20
1533 || fixups
[i
].reloc
== BFD_RELOC_390_GOT16
)
1534 fixP
->fx_no_overflow
= 1;
1537 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4, &fixups
[i
].exp
,
1538 (operand
->flags
& S390_OPERAND_PCREL
) != 0,
1539 ((bfd_reloc_code_real_type
)
1540 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
1545 /* This routine is called for each instruction to be assembled. */
1548 md_assemble (char *str
)
1550 const struct s390_opcode
*opcode
;
1551 unsigned char insn
[6];
1554 /* Get the opcode. */
1555 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1560 /* Look up the opcode in the hash table. */
1561 opcode
= (struct s390_opcode
*) hash_find (s390_opcode_hash
, str
);
1562 if (opcode
== (const struct s390_opcode
*) NULL
)
1564 as_bad (_("Unrecognized opcode: `%s'"), str
);
1567 else if (!(opcode
->modes
& current_mode_mask
))
1569 as_bad (_("Opcode %s not available in this mode"), str
);
1572 memcpy (insn
, opcode
->opcode
, sizeof (insn
));
1573 md_gather_operands (s
, insn
, opcode
);
1576 #ifndef WORKING_DOT_WORD
1577 /* Handle long and short jumps. We don't support these */
1579 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1581 addressT from_addr
, to_addr
;
1589 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1591 addressT from_addr
, to_addr
;
1600 s390_bss (int ignore ATTRIBUTE_UNUSED
)
1602 /* We don't support putting frags in the BSS segment, we fake it
1603 by marking in_bss, then looking at s_skip for clues. */
1605 subseg_set (bss_section
, 0);
1606 demand_empty_rest_of_line ();
1609 /* Pseudo-op handling. */
1612 s390_insn (int ignore ATTRIBUTE_UNUSED
)
1615 const struct s390_opcode
*opformat
;
1616 unsigned char insn
[6];
1619 /* Get the opcode format. */
1620 s
= input_line_pointer
;
1621 while (*s
!= '\0' && *s
!= ',' && ! ISSPACE (*s
))
1624 as_bad (_("Invalid .insn format\n"));
1627 /* Look up the opcode in the hash table. */
1628 opformat
= (struct s390_opcode
*)
1629 hash_find (s390_opformat_hash
, input_line_pointer
);
1630 if (opformat
== (const struct s390_opcode
*) NULL
)
1632 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer
);
1635 input_line_pointer
= s
;
1637 if (exp
.X_op
== O_constant
)
1639 if ( ( opformat
->oplen
== 6
1640 && (addressT
) exp
.X_add_number
< (1ULL << 48))
1641 || ( opformat
->oplen
== 4
1642 && (addressT
) exp
.X_add_number
< (1ULL << 32))
1643 || ( opformat
->oplen
== 2
1644 && (addressT
) exp
.X_add_number
< (1ULL << 16)))
1645 md_number_to_chars ((char *) insn
, exp
.X_add_number
, opformat
->oplen
);
1647 as_bad (_("Invalid .insn format\n"));
1649 else if (exp
.X_op
== O_big
)
1651 if (exp
.X_add_number
> 0
1652 && opformat
->oplen
== 6
1653 && generic_bignum
[3] == 0)
1655 md_number_to_chars ((char *) insn
, generic_bignum
[2], 2);
1656 md_number_to_chars ((char *) &insn
[2], generic_bignum
[1], 2);
1657 md_number_to_chars ((char *) &insn
[4], generic_bignum
[0], 2);
1660 as_bad (_("Invalid .insn format\n"));
1663 as_bad (_("second operand of .insn not a constant\n"));
1665 if (strcmp (opformat
->name
, "e") != 0 && *input_line_pointer
++ != ',')
1666 as_bad (_("missing comma after insn constant\n"));
1668 if ((s
= strchr (input_line_pointer
, '\n')) != NULL
)
1670 input_line_pointer
= md_gather_operands (input_line_pointer
, insn
,
1674 demand_empty_rest_of_line ();
1677 /* The .byte pseudo-op. This is similar to the normal .byte
1678 pseudo-op, but it can also take a single ASCII string. */
1681 s390_byte (int ignore ATTRIBUTE_UNUSED
)
1683 if (*input_line_pointer
!= '\"')
1689 /* Gather characters. A real double quote is doubled. Unusual
1690 characters are not permitted. */
1691 ++input_line_pointer
;
1696 c
= *input_line_pointer
++;
1700 if (*input_line_pointer
!= '\"')
1702 ++input_line_pointer
;
1705 FRAG_APPEND_1_CHAR (c
);
1708 demand_empty_rest_of_line ();
1711 /* The .ltorg pseudo-op.This emits all literals defined since the last
1712 .ltorg or the invocation of gas. Literals are defined with the
1716 s390_literals (int ignore ATTRIBUTE_UNUSED
)
1718 struct s390_lpe
*lpe
;
1720 if (lp_sym
== NULL
|| lpe_count
== 0)
1721 return; /* Nothing to be done. */
1723 /* Emit symbol for start of literal pool. */
1724 S_SET_SEGMENT (lp_sym
, now_seg
);
1725 S_SET_VALUE (lp_sym
, (valueT
) frag_now_fix ());
1726 lp_sym
->sy_frag
= frag_now
;
1731 lpe_list
= lpe_list
->next
;
1732 S_SET_SEGMENT (lpe
->sym
, now_seg
);
1733 S_SET_VALUE (lpe
->sym
, (valueT
) frag_now_fix ());
1734 lpe
->sym
->sy_frag
= frag_now
;
1736 /* Emit literal pool entry. */
1737 if (lpe
->reloc
!= BFD_RELOC_UNUSED
)
1739 reloc_howto_type
*reloc_howto
=
1740 bfd_reloc_type_lookup (stdoutput
, lpe
->reloc
);
1741 int size
= bfd_get_reloc_size (reloc_howto
);
1744 if (size
> lpe
->nbytes
)
1745 as_bad (_("%s relocations do not fit in %d bytes"),
1746 reloc_howto
->name
, lpe
->nbytes
);
1747 where
= frag_more (lpe
->nbytes
);
1748 md_number_to_chars (where
, 0, size
);
1749 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1750 size
, &lpe
->ex
, reloc_howto
->pc_relative
, lpe
->reloc
);
1754 if (lpe
->ex
.X_op
== O_big
)
1756 if (lpe
->ex
.X_add_number
<= 0)
1757 generic_floating_point_number
= lpe
->floatnum
;
1759 memcpy (generic_bignum
, lpe
->bignum
,
1760 lpe
->ex
.X_add_number
* sizeof (LITTLENUM_TYPE
));
1762 emit_expr (&lpe
->ex
, lpe
->nbytes
);
1765 lpe
->next
= lpe_free_list
;
1766 lpe_free_list
= lpe
;
1768 lpe_list_tail
= NULL
;
1774 /* The .machine pseudo op allows to switch to a different CPU level in
1775 the asm listing. The current CPU setting can be stored on a stack
1776 with .machine push and restored with .machine pop. */
1779 s390_machine (int ignore ATTRIBUTE_UNUSED
)
1782 #define MAX_HISTORY 100
1783 static unsigned int *cpu_history
;
1784 static int curr_hist
;
1788 if (*input_line_pointer
== '"')
1791 cpu_string
= demand_copy_C_string (&len
);
1796 cpu_string
= input_line_pointer
;
1797 c
= get_symbol_end ();
1798 cpu_string
= xstrdup (cpu_string
);
1799 *input_line_pointer
= c
;
1802 if (cpu_string
!= NULL
)
1804 unsigned int old_cpu
= current_cpu
;
1805 unsigned int new_cpu
;
1807 if (strcmp (cpu_string
, "push") == 0)
1809 if (cpu_history
== NULL
)
1810 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
1812 if (curr_hist
>= MAX_HISTORY
)
1813 as_bad (_(".machine stack overflow"));
1815 cpu_history
[curr_hist
++] = current_cpu
;
1817 else if (strcmp (cpu_string
, "pop") == 0)
1820 as_bad (_(".machine stack underflow"));
1822 current_cpu
= cpu_history
[--curr_hist
];
1824 else if ((new_cpu
= s390_parse_cpu (cpu_string
)) != (unsigned int)-1)
1825 current_cpu
= new_cpu
;
1827 as_bad (_("invalid machine `%s'"), cpu_string
);
1829 if (current_cpu
!= old_cpu
)
1830 s390_setup_opcodes ();
1833 demand_empty_rest_of_line ();
1836 /* The .machinemode pseudo op allows to switch to a different
1837 architecture mode in the asm listing. The current architecture
1838 mode setting can be stored on a stack with .machinemode push and
1839 restored with .machinemode pop. */
1842 s390_machinemode (int ignore ATTRIBUTE_UNUSED
)
1845 #define MAX_HISTORY 100
1846 static unsigned int *mode_history
;
1847 static int curr_hist
;
1851 if (*input_line_pointer
== '"')
1854 mode_string
= demand_copy_C_string (&len
);
1859 mode_string
= input_line_pointer
;
1860 c
= get_symbol_end ();
1861 mode_string
= xstrdup (mode_string
);
1862 *input_line_pointer
= c
;
1865 if (mode_string
!= NULL
)
1867 unsigned int old_mode_mask
= current_mode_mask
;
1870 for (p
= mode_string
; *p
!= 0; p
++)
1873 if (strcmp (mode_string
, "push") == 0)
1875 if (mode_history
== NULL
)
1876 mode_history
= xmalloc (MAX_HISTORY
* sizeof (*mode_history
));
1878 if (curr_hist
>= MAX_HISTORY
)
1879 as_bad (_(".machinemode stack overflow"));
1881 mode_history
[curr_hist
++] = current_mode_mask
;
1883 else if (strcmp (mode_string
, "pop") == 0)
1886 as_bad (_(".machinemode stack underflow"));
1888 current_mode_mask
= mode_history
[--curr_hist
];
1892 if (strcmp (mode_string
, "esa") == 0)
1893 current_mode_mask
= 1 << S390_OPCODE_ESA
;
1894 else if (strcmp (mode_string
, "zarch") == 0)
1896 if (s390_arch_size
== 32)
1897 set_highgprs_p
= TRUE
;
1898 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
1900 else if (strcmp (mode_string
, "zarch_nohighgprs") == 0)
1901 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
1903 as_bad (_("invalid machine `%s'"), mode_string
);
1906 if (current_mode_mask
!= old_mode_mask
)
1907 s390_setup_opcodes ();
1910 demand_empty_rest_of_line ();
1914 md_atof (int type
, char *litp
, int *sizep
)
1916 return ieee_md_atof (type
, litp
, sizep
, TRUE
);
1919 /* Align a section (I don't know why this is machine dependent). */
1922 md_section_align (asection
*seg
, valueT addr
)
1924 int align
= bfd_get_section_alignment (stdoutput
, seg
);
1926 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
1929 /* We don't have any form of relaxing. */
1932 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
1933 asection
*seg ATTRIBUTE_UNUSED
)
1939 /* Convert a machine dependent frag. We never generate these. */
1942 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
1943 asection
*sec ATTRIBUTE_UNUSED
,
1944 fragS
*fragp ATTRIBUTE_UNUSED
)
1950 md_undefined_symbol (char *name
)
1952 if (*name
== '_' && *(name
+ 1) == 'G'
1953 && strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
1957 if (symbol_find (name
))
1958 as_bad (_("GOT already in symbol table"));
1959 GOT_symbol
= symbol_new (name
, undefined_section
,
1960 (valueT
) 0, &zero_address_frag
);
1967 /* Functions concerning relocs. */
1969 /* The location from which a PC relative jump should be calculated,
1970 given a PC relative reloc. */
1973 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
1975 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
1978 /* Here we decide which fixups can be adjusted to make them relative to
1979 the beginning of the section instead of the symbol. Basically we need
1980 to make sure that the dynamic relocations are done correctly, so in
1981 some cases we force the original symbol to be used. */
1983 tc_s390_fix_adjustable (fixS
*fixP
)
1985 /* Don't adjust references to merge sections. */
1986 if ((S_GET_SEGMENT (fixP
->fx_addsy
)->flags
& SEC_MERGE
) != 0)
1988 /* adjust_reloc_syms doesn't know about the GOT. */
1989 if ( fixP
->fx_r_type
== BFD_RELOC_16_GOTOFF
1990 || fixP
->fx_r_type
== BFD_RELOC_32_GOTOFF
1991 || fixP
->fx_r_type
== BFD_RELOC_390_GOTOFF64
1992 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF16
1993 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF32
1994 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF64
1995 || fixP
->fx_r_type
== BFD_RELOC_390_PLT12DBL
1996 || fixP
->fx_r_type
== BFD_RELOC_390_PLT16DBL
1997 || fixP
->fx_r_type
== BFD_RELOC_390_PLT24DBL
1998 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32
1999 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32DBL
2000 || fixP
->fx_r_type
== BFD_RELOC_390_PLT64
2001 || fixP
->fx_r_type
== BFD_RELOC_390_GOT12
2002 || fixP
->fx_r_type
== BFD_RELOC_390_GOT20
2003 || fixP
->fx_r_type
== BFD_RELOC_390_GOT16
2004 || fixP
->fx_r_type
== BFD_RELOC_32_GOT_PCREL
2005 || fixP
->fx_r_type
== BFD_RELOC_390_GOT64
2006 || fixP
->fx_r_type
== BFD_RELOC_390_GOTENT
2007 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT12
2008 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT16
2009 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT20
2010 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT32
2011 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT64
2012 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLTENT
2013 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LOAD
2014 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GDCALL
2015 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDCALL
2016 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD32
2017 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD64
2018 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE12
2019 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE20
2020 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE32
2021 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE64
2022 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM32
2023 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM64
2024 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE32
2025 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE64
2026 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IEENT
2027 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE32
2028 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE64
2029 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO32
2030 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO64
2031 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPMOD
2032 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPOFF
2033 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_TPOFF
2034 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2035 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
2040 /* Return true if we must always emit a reloc for a type and false if
2041 there is some hope of resolving it at assembly time. */
2043 tc_s390_force_relocation (struct fix
*fixp
)
2045 /* Ensure we emit a relocation for every reference to the global
2046 offset table or to the procedure link table. */
2047 switch (fixp
->fx_r_type
)
2049 case BFD_RELOC_390_GOT12
:
2050 case BFD_RELOC_390_GOT20
:
2051 case BFD_RELOC_32_GOT_PCREL
:
2052 case BFD_RELOC_32_GOTOFF
:
2053 case BFD_RELOC_390_GOTOFF64
:
2054 case BFD_RELOC_390_PLTOFF16
:
2055 case BFD_RELOC_390_PLTOFF32
:
2056 case BFD_RELOC_390_PLTOFF64
:
2057 case BFD_RELOC_390_GOTPC
:
2058 case BFD_RELOC_390_GOT16
:
2059 case BFD_RELOC_390_GOTPCDBL
:
2060 case BFD_RELOC_390_GOT64
:
2061 case BFD_RELOC_390_GOTENT
:
2062 case BFD_RELOC_390_PLT32
:
2063 case BFD_RELOC_390_PLT12DBL
:
2064 case BFD_RELOC_390_PLT16DBL
:
2065 case BFD_RELOC_390_PLT24DBL
:
2066 case BFD_RELOC_390_PLT32DBL
:
2067 case BFD_RELOC_390_PLT64
:
2068 case BFD_RELOC_390_GOTPLT12
:
2069 case BFD_RELOC_390_GOTPLT16
:
2070 case BFD_RELOC_390_GOTPLT20
:
2071 case BFD_RELOC_390_GOTPLT32
:
2072 case BFD_RELOC_390_GOTPLT64
:
2073 case BFD_RELOC_390_GOTPLTENT
:
2079 return generic_force_reloc (fixp
);
2082 /* Apply a fixup to the object code. This is called for all the
2083 fixups we generated by the call to fix_new_exp, above. In the call
2084 above we used a reloc code which was the largest legal reloc code
2085 plus the operand index. Here we undo that to recover the operand
2086 index. At this point all symbol values should be fully resolved,
2087 and we attempt to completely resolve the reloc. If we can not do
2088 that, we determine the correct reloc code and put it back in the
2092 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
2095 valueT value
= *valP
;
2097 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
2099 if (fixP
->fx_subsy
!= NULL
)
2100 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2101 _("cannot emit relocation %s against subsy symbol %s"),
2102 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2103 S_GET_NAME (fixP
->fx_subsy
));
2105 if (fixP
->fx_addsy
!= NULL
)
2108 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
2113 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
2115 const struct s390_operand
*operand
;
2118 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
2119 operand
= &s390_operands
[opindex
];
2123 /* Insert the fully resolved operand value. */
2124 s390_insert_operand ((unsigned char *) where
, operand
,
2125 (offsetT
) value
, fixP
->fx_file
, fixP
->fx_line
);
2129 /* Determine a BFD reloc value based on the operand information.
2130 We are only prepared to turn a few of the operands into
2132 fixP
->fx_offset
= value
;
2133 if (operand
->bits
== 12 && operand
->shift
== 20)
2136 fixP
->fx_where
+= 2;
2137 fixP
->fx_r_type
= BFD_RELOC_390_12
;
2139 else if (operand
->bits
== 12 && operand
->shift
== 36)
2142 fixP
->fx_where
+= 4;
2143 fixP
->fx_r_type
= BFD_RELOC_390_12
;
2145 else if (operand
->bits
== 20 && operand
->shift
== 20)
2148 fixP
->fx_where
+= 2;
2149 fixP
->fx_r_type
= BFD_RELOC_390_20
;
2151 else if (operand
->bits
== 8 && operand
->shift
== 8)
2154 fixP
->fx_where
+= 1;
2155 fixP
->fx_r_type
= BFD_RELOC_8
;
2157 else if (operand
->bits
== 12 && operand
->shift
== 12
2158 && (operand
->flags
& S390_OPERAND_PCREL
))
2161 fixP
->fx_where
+= 1;
2162 fixP
->fx_offset
+= 1;
2163 fixP
->fx_r_type
= BFD_RELOC_390_PC12DBL
;
2165 else if (operand
->bits
== 16 && operand
->shift
== 16)
2168 fixP
->fx_where
+= 2;
2169 if (operand
->flags
& S390_OPERAND_PCREL
)
2171 fixP
->fx_r_type
= BFD_RELOC_390_PC16DBL
;
2172 fixP
->fx_offset
+= 2;
2175 fixP
->fx_r_type
= BFD_RELOC_16
;
2177 else if (operand
->bits
== 24 && operand
->shift
== 24
2178 && (operand
->flags
& S390_OPERAND_PCREL
))
2181 fixP
->fx_where
+= 3;
2182 fixP
->fx_offset
+= 3;
2183 fixP
->fx_r_type
= BFD_RELOC_390_PC24DBL
;
2185 else if (operand
->bits
== 32 && operand
->shift
== 16
2186 && (operand
->flags
& S390_OPERAND_PCREL
))
2189 fixP
->fx_where
+= 2;
2190 fixP
->fx_offset
+= 2;
2191 fixP
->fx_r_type
= BFD_RELOC_390_PC32DBL
;
2198 /* Use expr_symbol_where to see if this is an expression
2200 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
2201 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2202 _("unresolved expression that must be resolved"));
2204 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2205 _("unsupported relocation type"));
2212 switch (fixP
->fx_r_type
)
2218 md_number_to_chars (where
, value
, 1);
2220 case BFD_RELOC_390_12
:
2221 case BFD_RELOC_390_GOT12
:
2222 case BFD_RELOC_390_GOTPLT12
:
2223 case BFD_RELOC_390_PC12DBL
:
2224 case BFD_RELOC_390_PLT12DBL
:
2235 mop
= bfd_getb16 ((unsigned char *) where
);
2236 mop
|= (unsigned short) (value
& 0xfff);
2237 bfd_putb16 ((bfd_vma
) mop
, (unsigned char *) where
);
2241 case BFD_RELOC_390_20
:
2242 case BFD_RELOC_390_GOT20
:
2243 case BFD_RELOC_390_GOTPLT20
:
2247 mop
= bfd_getb32 ((unsigned char *) where
);
2248 mop
|= (unsigned int) ((value
& 0xfff) << 8 |
2249 (value
& 0xff000) >> 12);
2250 bfd_putb32 ((bfd_vma
) mop
, (unsigned char *) where
);
2255 case BFD_RELOC_GPREL16
:
2256 case BFD_RELOC_16_GOT_PCREL
:
2257 case BFD_RELOC_16_GOTOFF
:
2259 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2260 _("cannot emit PC relative %s relocation%s%s"),
2261 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2262 fixP
->fx_addsy
!= NULL
? " against " : "",
2263 (fixP
->fx_addsy
!= NULL
2264 ? S_GET_NAME (fixP
->fx_addsy
)
2267 md_number_to_chars (where
, value
, 2);
2269 case BFD_RELOC_390_GOT16
:
2270 case BFD_RELOC_390_PLTOFF16
:
2271 case BFD_RELOC_390_GOTPLT16
:
2273 md_number_to_chars (where
, value
, 2);
2275 case BFD_RELOC_390_PC16DBL
:
2276 case BFD_RELOC_390_PLT16DBL
:
2279 md_number_to_chars (where
, (offsetT
) value
>> 1, 2);
2282 case BFD_RELOC_390_PC24DBL
:
2283 case BFD_RELOC_390_PLT24DBL
:
2290 mop
= bfd_getb32 ((unsigned char *) where
- 1);
2291 mop
|= (unsigned int) (value
& 0xffffff);
2292 bfd_putb32 ((bfd_vma
) mop
, (unsigned char *) where
- 1);
2298 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2300 fixP
->fx_r_type
= BFD_RELOC_32
;
2302 md_number_to_chars (where
, value
, 4);
2304 case BFD_RELOC_32_PCREL
:
2305 case BFD_RELOC_32_BASEREL
:
2306 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2308 md_number_to_chars (where
, value
, 4);
2310 case BFD_RELOC_32_GOT_PCREL
:
2311 case BFD_RELOC_390_PLTOFF32
:
2312 case BFD_RELOC_390_PLT32
:
2313 case BFD_RELOC_390_GOTPLT32
:
2315 md_number_to_chars (where
, value
, 4);
2317 case BFD_RELOC_390_PC32DBL
:
2318 case BFD_RELOC_390_PLT32DBL
:
2319 case BFD_RELOC_390_GOTPCDBL
:
2320 case BFD_RELOC_390_GOTENT
:
2321 case BFD_RELOC_390_GOTPLTENT
:
2324 md_number_to_chars (where
, (offsetT
) value
>> 1, 4);
2327 case BFD_RELOC_32_GOTOFF
:
2329 md_number_to_chars (where
, value
, sizeof (int));
2332 case BFD_RELOC_390_GOTOFF64
:
2334 md_number_to_chars (where
, value
, 8);
2337 case BFD_RELOC_390_GOT64
:
2338 case BFD_RELOC_390_PLTOFF64
:
2339 case BFD_RELOC_390_PLT64
:
2340 case BFD_RELOC_390_GOTPLT64
:
2342 md_number_to_chars (where
, value
, 8);
2347 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2349 fixP
->fx_r_type
= BFD_RELOC_64
;
2351 md_number_to_chars (where
, value
, 8);
2354 case BFD_RELOC_64_PCREL
:
2355 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2357 md_number_to_chars (where
, value
, 8);
2360 case BFD_RELOC_VTABLE_INHERIT
:
2361 case BFD_RELOC_VTABLE_ENTRY
:
2365 case BFD_RELOC_390_TLS_LOAD
:
2366 case BFD_RELOC_390_TLS_GDCALL
:
2367 case BFD_RELOC_390_TLS_LDCALL
:
2368 case BFD_RELOC_390_TLS_GD32
:
2369 case BFD_RELOC_390_TLS_GD64
:
2370 case BFD_RELOC_390_TLS_GOTIE12
:
2371 case BFD_RELOC_390_TLS_GOTIE20
:
2372 case BFD_RELOC_390_TLS_GOTIE32
:
2373 case BFD_RELOC_390_TLS_GOTIE64
:
2374 case BFD_RELOC_390_TLS_LDM32
:
2375 case BFD_RELOC_390_TLS_LDM64
:
2376 case BFD_RELOC_390_TLS_IE32
:
2377 case BFD_RELOC_390_TLS_IE64
:
2378 case BFD_RELOC_390_TLS_LE32
:
2379 case BFD_RELOC_390_TLS_LE64
:
2380 case BFD_RELOC_390_TLS_LDO32
:
2381 case BFD_RELOC_390_TLS_LDO64
:
2382 case BFD_RELOC_390_TLS_DTPMOD
:
2383 case BFD_RELOC_390_TLS_DTPOFF
:
2384 case BFD_RELOC_390_TLS_TPOFF
:
2385 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2386 /* Fully resolved at link time. */
2388 case BFD_RELOC_390_TLS_IEENT
:
2389 /* Fully resolved at link time. */
2390 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2396 const char *reloc_name
= bfd_get_reloc_code_name (fixP
->fx_r_type
);
2398 if (reloc_name
!= NULL
)
2399 as_fatal (_("Gas failure, reloc type %s\n"), reloc_name
);
2401 as_fatal (_("Gas failure, reloc type #%i\n"), fixP
->fx_r_type
);
2405 fixP
->fx_offset
= value
;
2409 /* Generate a reloc for a fixup. */
2412 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
2414 bfd_reloc_code_real_type code
;
2417 code
= fixp
->fx_r_type
;
2418 if (GOT_symbol
&& fixp
->fx_addsy
== GOT_symbol
)
2420 if ( (s390_arch_size
== 32 && code
== BFD_RELOC_32_PCREL
)
2421 || (s390_arch_size
== 64 && code
== BFD_RELOC_64_PCREL
))
2422 code
= BFD_RELOC_390_GOTPC
;
2423 if (code
== BFD_RELOC_390_PC32DBL
)
2424 code
= BFD_RELOC_390_GOTPCDBL
;
2427 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
2428 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
2429 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2430 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2431 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2432 if (reloc
->howto
== NULL
)
2434 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2435 _("cannot represent relocation type %s"),
2436 bfd_get_reloc_code_name (code
));
2437 /* Set howto to a garbage value so that we can keep going. */
2438 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
2439 gas_assert (reloc
->howto
!= NULL
);
2441 reloc
->addend
= fixp
->fx_offset
;
2447 s390_cfi_frame_initial_instructions (void)
2449 cfi_add_CFA_def_cfa (15, s390_arch_size
== 64 ? 160 : 96);
2453 tc_s390_regname_to_dw2regnum (char *regname
)
2457 if (regname
[0] != 'c' && regname
[0] != 'a')
2459 regnum
= reg_name_search (regname
);
2460 if (regname
[0] == 'f' && regnum
!= -1)
2463 else if (strcmp (regname
, "ap") == 0)
2465 else if (strcmp (regname
, "cc") == 0)
2471 s390_elf_final_processing (void)
2474 elf_elfheader (stdoutput
)->e_flags
|= EF_S390_HIGH_GPRS
;