1 /* tc-s390.c -- Assemble for the S390
2 Copyright 2000, 2001, 2002, 2003 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 2, 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, 59 Temple Place - Suite 330, Boston, MA
24 #include "safe-ctype.h"
26 #include "struc-symbol.h"
27 #include "dwarf2dbg.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 static unsigned int current_mode_mask
= 0;
41 static unsigned int current_cpu
= -1U;
43 /* Whether to use user friendly register names. Default is TRUE. */
44 #ifndef TARGET_REG_NAMES_P
45 #define TARGET_REG_NAMES_P TRUE
48 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
50 /* Set to TRUE if we want to warn about zero base/index registers. */
51 static bfd_boolean warn_areg_zero
= FALSE
;
53 /* Generic assembler global variables which must be defined by all
56 const char comment_chars
[] = "#";
58 /* Characters which start a comment at the beginning of a line. */
59 const char line_comment_chars
[] = "#";
61 /* Characters which may be used to separate multiple commands on a
63 const char line_separator_chars
[] = ";";
65 /* Characters which are used to indicate an exponent in a floating
67 const char EXP_CHARS
[] = "eE";
69 /* Characters which mean that a number is a floating point constant,
71 const char FLT_CHARS
[] = "dD";
73 /* The target specific pseudo-ops which we support. */
75 /* Define the prototypes for the pseudo-ops */
76 static void s390_byte
PARAMS ((int));
77 static void s390_elf_cons
PARAMS ((int));
78 static void s390_bss
PARAMS ((int));
79 static void s390_insn
PARAMS ((int));
80 static void s390_literals
PARAMS ((int));
82 const pseudo_typeS md_pseudo_table
[] =
84 { "align", s_align_bytes
, 0 },
85 /* Pseudo-ops which must be defined. */
86 { "bss", s390_bss
, 0 },
87 { "insn", s390_insn
, 0 },
88 /* Pseudo-ops which must be overridden. */
89 { "byte", s390_byte
, 0 },
90 { "short", s390_elf_cons
, 2 },
91 { "long", s390_elf_cons
, 4 },
92 { "quad", s390_elf_cons
, 8 },
93 { "ltorg", s390_literals
, 0 },
94 { "string", stringer
, 2 },
99 /* Structure to hold information about predefined registers. */
106 /* List of registers that are pre-defined:
108 Each access register has a predefined name of the form:
109 a<reg_num> which has the value <reg_num>.
111 Each control register has a predefined name of the form:
112 c<reg_num> which has the value <reg_num>.
114 Each general register has a predefined name of the form:
115 r<reg_num> which has the value <reg_num>.
117 Each floating point register a has predefined name of the form:
118 f<reg_num> which has the value <reg_num>.
120 There are individual registers as well:
124 The table is sorted. Suitable for searching by a binary search. */
126 static const struct pd_reg pre_defined_registers
[] =
128 { "a0", 0 }, /* Access registers */
145 { "c0", 0 }, /* Control registers */
162 { "f0", 0 }, /* Floating point registers */
179 { "lit", 13 }, /* Pointer to literal pool */
181 { "r0", 0 }, /* General purpose registers */
198 { "sp", 15 }, /* Stack pointer */
202 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
204 static int reg_name_search
205 PARAMS ((const struct pd_reg
*, int, const char *));
206 static bfd_boolean register_name
PARAMS ((expressionS
*));
207 static void init_default_arch
PARAMS ((void));
208 static void s390_insert_operand
209 PARAMS ((unsigned char *, const struct s390_operand
*, offsetT
, char *,
211 static char *md_gather_operands
212 PARAMS ((char *, unsigned char *, const struct s390_opcode
*));
214 /* Given NAME, find the register number associated with that name, return
215 the integer value associated with the given name or -1 on failure. */
218 reg_name_search (regs
, regcount
, name
)
219 const struct pd_reg
*regs
;
223 int middle
, low
, high
;
231 middle
= (low
+ high
) / 2;
232 cmp
= strcasecmp (name
, regs
[middle
].name
);
238 return regs
[middle
].value
;
247 * Summary of register_name().
249 * in: Input_line_pointer points to 1st char of operand.
251 * out: A expressionS.
252 * The operand may have been a register: in this case, X_op == O_register,
253 * X_add_number is set to the register number, and truth is returned.
254 * Input_line_pointer->(next non-blank) char after operand, or is in its
259 register_name (expressionP
)
260 expressionS
*expressionP
;
267 /* Find the spelling of the operand. */
268 start
= name
= input_line_pointer
;
269 if (name
[0] == '%' && ISALPHA (name
[1]))
270 name
= ++input_line_pointer
;
274 c
= get_symbol_end ();
275 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
277 /* Put back the delimiting char. */
278 *input_line_pointer
= c
;
280 /* Look to see if it's in the register table. */
283 expressionP
->X_op
= O_register
;
284 expressionP
->X_add_number
= reg_number
;
286 /* Make the rest nice. */
287 expressionP
->X_add_symbol
= NULL
;
288 expressionP
->X_op_symbol
= NULL
;
292 /* Reset the line as if we had not done anything. */
293 input_line_pointer
= start
;
297 /* Local variables. */
299 /* Opformat hash table. */
300 static struct hash_control
*s390_opformat_hash
;
302 /* Opcode hash table. */
303 static struct hash_control
*s390_opcode_hash
;
305 /* Flags to set in the elf header */
306 static flagword s390_flags
= 0;
308 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
310 #ifndef WORKING_DOT_WORD
311 const int md_short_jump_size
= 4;
312 const int md_long_jump_size
= 4;
315 const char *md_shortopts
= "A:m:kVQ:";
316 struct option md_longopts
[] = {
317 {NULL
, no_argument
, NULL
, 0}
319 size_t md_longopts_size
= sizeof (md_longopts
);
321 /* Initialize the default opcode arch and word size from the default
322 architecture name if not specified by an option. */
326 if (strcmp (default_arch
, "s390") == 0)
328 if (s390_arch_size
== 0)
330 if (current_mode_mask
== 0)
331 current_mode_mask
= 1 << S390_OPCODE_ESA
;
332 if (current_cpu
== -1U)
333 current_cpu
= S390_OPCODE_G5
;
335 else if (strcmp (default_arch
, "s390x") == 0)
337 if (s390_arch_size
== 0)
339 if (current_mode_mask
== 0)
340 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
341 if (current_cpu
== -1U)
342 current_cpu
= S390_OPCODE_Z900
;
345 as_fatal ("Invalid default architecture, broken assembler.");
348 /* Called by TARGET_FORMAT. */
350 s390_target_format ()
352 /* We don't get a chance to initialize anything before we're called,
353 so handle that now. */
354 if (! s390_arch_size
)
355 init_default_arch ();
357 return s390_arch_size
== 64 ? "elf64-s390" : "elf32-s390";
361 md_parse_option (c
, arg
)
367 /* -k: Ignore for FreeBSD compatibility. */
371 if (arg
!= NULL
&& strcmp (arg
, "regnames") == 0)
374 else if (arg
!= NULL
&& strcmp (arg
, "no-regnames") == 0)
377 else if (arg
!= NULL
&& strcmp (arg
, "warn-areg-zero") == 0)
378 warn_areg_zero
= TRUE
;
380 else if (arg
!= NULL
&& strcmp (arg
, "31") == 0)
383 else if (arg
!= NULL
&& strcmp (arg
, "64") == 0)
386 else if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
387 current_mode_mask
= 1 << S390_OPCODE_ESA
;
389 else if (arg
!= NULL
&& strcmp (arg
, "zarch") == 0)
390 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
392 else if (arg
!= NULL
&& strncmp (arg
, "arch=", 5) == 0)
394 if (strcmp (arg
+ 5, "g5") == 0)
395 current_cpu
= S390_OPCODE_G5
;
396 else if (strcmp (arg
+ 5, "g6") == 0)
397 current_cpu
= S390_OPCODE_G6
;
398 else if (strcmp (arg
+ 5, "z900") == 0)
399 current_cpu
= S390_OPCODE_Z900
;
402 as_bad (_("invalid switch -m%s"), arg
);
409 as_bad (_("invalid switch -m%s"), arg
);
415 /* Option -A is deprecated. Still available for compatability. */
416 if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
417 current_cpu
= S390_OPCODE_G5
;
418 else if (arg
!= NULL
&& strcmp (arg
, "esame") == 0)
419 current_cpu
= S390_OPCODE_Z900
;
421 as_bad ("invalid architecture -A%s", arg
);
424 /* -V: SVR4 argument to print version ID. */
429 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
430 should be emitted or not. FIXME: Not implemented. */
442 md_show_usage (stream
)
445 fprintf (stream
, _("\
447 -mregnames Allow symbolic names for registers\n\
448 -mwarn-areg-zero Warn about zero base/index registers\n\
449 -mno-regnames Do not allow symbolic names for registers\n\
450 -m31 Set file format to 31 bit format\n\
451 -m64 Set file format to 64 bit format\n"));
452 fprintf (stream
, _("\
453 -V print assembler version number\n\
454 -Qy, -Qn ignored\n"));
457 /* This function is called when the assembler starts up. It is called
458 after the options have been parsed and the output file has been
464 register const struct s390_opcode
*op
;
465 const struct s390_opcode
*op_end
;
466 bfd_boolean dup_insn
= FALSE
;
469 /* Give a warning if the combination -m64-bit and -Aesa is used. */
470 if (s390_arch_size
== 64 && current_cpu
< S390_OPCODE_Z900
)
471 as_warn ("The 64 bit file format is used without esame instructions.");
473 /* Set the ELF flags if desired. */
475 bfd_set_private_flags (stdoutput
, s390_flags
);
477 /* Insert the opcode formats into a hash table. */
478 s390_opformat_hash
= hash_new ();
480 op_end
= s390_opformats
+ s390_num_opformats
;
481 for (op
= s390_opformats
; op
< op_end
; op
++)
483 retval
= hash_insert (s390_opformat_hash
, op
->name
, (PTR
) op
);
484 if (retval
!= (const char *) NULL
)
486 as_bad (_("Internal assembler error for instruction format %s"),
492 /* Insert the opcodes into a hash table. */
493 s390_opcode_hash
= hash_new ();
495 op_end
= s390_opcodes
+ s390_num_opcodes
;
496 for (op
= s390_opcodes
; op
< op_end
; op
++)
498 retval
= hash_insert (s390_opcode_hash
, op
->name
, (PTR
) op
);
499 if (retval
!= (const char *) NULL
)
501 as_bad (_("Internal assembler error for instruction %s"), op
->name
);
509 record_alignment (text_section
, 2);
510 record_alignment (data_section
, 2);
511 record_alignment (bss_section
, 2);
515 /* Called after all assembly has been done. */
519 if (s390_arch_size
== 64)
520 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_64
);
522 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_31
);
526 s390_align_code (fragP
, count
)
530 /* We use nop pattern 0x0707. */
533 memset (fragP
->fr_literal
+ fragP
->fr_fix
, 0x07, count
);
534 fragP
->fr_var
= count
;
538 /* Insert an operand value into an instruction. */
541 s390_insert_operand (insn
, operand
, val
, file
, line
)
543 const struct s390_operand
*operand
;
551 if (operand
->flags
& (S390_OPERAND_SIGNED
|S390_OPERAND_PCREL
))
555 max
= ((offsetT
) 1 << (operand
->bits
- 1)) - 1;
556 min
= - ((offsetT
) 1 << (operand
->bits
- 1));
557 /* Halve PCREL operands. */
558 if (operand
->flags
& S390_OPERAND_PCREL
)
560 /* Check for underflow / overflow. */
561 if (val
< min
|| val
> max
)
564 "operand out of range (%s not between %ld and %ld)";
567 if (operand
->flags
& S390_OPERAND_PCREL
)
573 sprint_value (buf
, val
);
574 if (file
== (char *) NULL
)
575 as_bad (err
, buf
, (int) min
, (int) max
);
577 as_bad_where (file
, line
, err
, buf
, (int) min
, (int) max
);
580 /* val is ok, now restrict it to operand->bits bits. */
581 uval
= (addressT
) val
& ((((addressT
) 1 << (operand
->bits
-1)) << 1) - 1);
587 max
= (((addressT
) 1 << (operand
->bits
- 1)) << 1) - 1;
589 uval
= (addressT
) val
;
590 /* Length x in an instructions has real length x+1. */
591 if (operand
->flags
& S390_OPERAND_LENGTH
)
593 /* Check for underflow / overflow. */
594 if (uval
< min
|| uval
> max
)
597 "operand out of range (%s not between %ld and %ld)";
600 if (operand
->flags
& S390_OPERAND_LENGTH
)
606 sprint_value (buf
, uval
);
607 if (file
== (char *) NULL
)
608 as_bad (err
, buf
, (int) min
, (int) max
);
610 as_bad_where (file
, line
, err
, buf
, (int) min
, (int) max
);
615 /* Insert fragments of the operand byte for byte. */
616 offset
= operand
->shift
+ operand
->bits
;
617 uval
<<= (-offset
) & 7;
618 insn
+= (offset
- 1) / 8;
630 bfd_reloc_code_real_type reloc
;
633 static bfd_reloc_code_real_type s390_tls_suffix
634 PARAMS ((char **, expressionS
*));
636 /* Parse tls marker and return the desired relocation. */
637 static bfd_reloc_code_real_type
638 s390_tls_suffix (str_p
, exp_p
)
642 static struct map_tls mapping
[] =
644 { "tls_load", 8, BFD_RELOC_390_TLS_LOAD
},
645 { "tls_gdcall", 10, BFD_RELOC_390_TLS_GDCALL
},
646 { "tls_ldcall", 10, BFD_RELOC_390_TLS_LDCALL
},
647 { NULL
, 0, BFD_RELOC_UNUSED
}
657 return BFD_RELOC_UNUSED
;
660 while (ISIDNUM (*str
))
664 return BFD_RELOC_UNUSED
;
666 orig_line
= input_line_pointer
;
667 input_line_pointer
= str
;
669 str
= input_line_pointer
;
670 if (&input_line_pointer
!= str_p
)
671 input_line_pointer
= orig_line
;
673 if (exp_p
->X_op
!= O_symbol
)
674 return BFD_RELOC_UNUSED
;
676 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
677 if (len
== ptr
->length
678 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
680 /* Found a matching tls suffix. */
684 return BFD_RELOC_UNUSED
;
687 /* Structure used to hold suffixes. */
698 ELF_SUFFIX_TLS_GOTIE
,
710 elf_suffix_type suffix
;
713 static elf_suffix_type s390_elf_suffix
PARAMS ((char **, expressionS
*));
714 static int s390_exp_compare
PARAMS ((expressionS
*exp1
, expressionS
*exp2
));
715 static elf_suffix_type s390_lit_suffix
716 PARAMS ((char **, expressionS
*, elf_suffix_type
));
719 /* Parse @got/@plt/@gotoff. and return the desired relocation. */
720 static elf_suffix_type
721 s390_elf_suffix (str_p
, exp_p
)
725 static struct map_bfd mapping
[] =
727 { "got", 3, ELF_SUFFIX_GOT
},
728 { "got12", 5, ELF_SUFFIX_GOT
},
729 { "plt", 3, ELF_SUFFIX_PLT
},
730 { "gotent", 6, ELF_SUFFIX_GOTENT
},
731 { "gotoff", 6, ELF_SUFFIX_GOTOFF
},
732 { "gotplt", 6, ELF_SUFFIX_GOTPLT
},
733 { "pltoff", 6, ELF_SUFFIX_PLTOFF
},
734 { "tlsgd", 5, ELF_SUFFIX_TLS_GD
},
735 { "gotntpoff", 9, ELF_SUFFIX_TLS_GOTIE
},
736 { "indntpoff", 9, ELF_SUFFIX_TLS_IE
},
737 { "tlsldm", 6, ELF_SUFFIX_TLS_LDM
},
738 { "dtpoff", 6, ELF_SUFFIX_TLS_LDO
},
739 { "ntpoff", 6, ELF_SUFFIX_TLS_LE
},
740 { NULL
, 0, ELF_SUFFIX_NONE
}
749 return ELF_SUFFIX_NONE
;
752 while (ISALNUM (*str
))
756 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
757 if (len
== ptr
->length
758 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
760 if (exp_p
->X_add_number
!= 0)
761 as_warn (_("identifier+constant@%s means identifier@%s+constant"),
762 ptr
->string
, ptr
->string
);
763 /* Now check for identifier@suffix+constant. */
764 if (*str
== '-' || *str
== '+')
766 char *orig_line
= input_line_pointer
;
769 input_line_pointer
= str
;
770 expression (&new_exp
);
772 switch (new_exp
.X_op
)
774 case O_constant
: /* X_add_number (a constant expression). */
775 exp_p
->X_add_number
+= new_exp
.X_add_number
;
776 str
= input_line_pointer
;
778 case O_symbol
: /* X_add_symbol + X_add_number. */
779 /* this case is used for e.g. xyz@PLT+.Label. */
780 exp_p
->X_add_number
+= new_exp
.X_add_number
;
781 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
783 str
= input_line_pointer
;
785 case O_uminus
: /* (- X_add_symbol) + X_add_number. */
786 /* this case is used for e.g. xyz@PLT-.Label. */
787 exp_p
->X_add_number
+= new_exp
.X_add_number
;
788 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
789 exp_p
->X_op
= O_subtract
;
790 str
= input_line_pointer
;
796 /* If s390_elf_suffix has not been called with
797 &input_line_pointer as first parameter, we have
798 clobbered the input_line_pointer. We have to
800 if (&input_line_pointer
!= str_p
)
801 input_line_pointer
= orig_line
;
807 return BFD_RELOC_UNUSED
;
810 /* Structure used to hold a literal pool entry. */
813 struct s390_lpe
*next
;
815 FLONUM_TYPE floatnum
; /* used if X_op == O_big && X_add_number <= 0 */
816 LITTLENUM_TYPE bignum
[4]; /* used if X_op == O_big && X_add_number > 0 */
818 bfd_reloc_code_real_type reloc
;
822 static struct s390_lpe
*lpe_free_list
= NULL
;
823 static struct s390_lpe
*lpe_list
= NULL
;
824 static struct s390_lpe
*lpe_list_tail
= NULL
;
825 static symbolS
*lp_sym
= NULL
;
826 static int lp_count
= 0;
827 static int lpe_count
= 0;
830 s390_exp_compare (exp1
, exp2
)
834 if (exp1
->X_op
!= exp2
->X_op
)
839 case O_constant
: /* X_add_number must be equal. */
841 return exp1
->X_add_number
== exp2
->X_add_number
;
844 as_bad (_("Can't handle O_big in s390_exp_compare"));
846 case O_symbol
: /* X_add_symbol & X_add_number must be equal. */
851 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
852 && (exp1
->X_add_number
== exp2
->X_add_number
);
854 case O_multiply
: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
859 case O_bit_inclusive_or
:
861 case O_bit_exclusive_or
:
873 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
874 && (exp1
->X_op_symbol
== exp2
->X_op_symbol
)
875 && (exp1
->X_add_number
== exp2
->X_add_number
);
881 /* Test for @lit and if its present make an entry in the literal pool and
882 modify the current expression to be an offset into the literal pool. */
883 static elf_suffix_type
884 s390_lit_suffix (str_p
, exp_p
, suffix
)
887 elf_suffix_type suffix
;
889 bfd_reloc_code_real_type reloc
;
893 struct s390_lpe
*lpe
;
897 return suffix
; /* No modification. */
899 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
901 while (ISALNUM (*str
))
904 if (len
!= 4 || strncasecmp (ident
, "lit", 3) != 0
905 || (ident
[3]!='1' && ident
[3]!='2' && ident
[3]!='4' && ident
[3]!='8'))
906 return suffix
; /* no modification */
907 nbytes
= ident
[3] - '0';
909 reloc
= BFD_RELOC_UNUSED
;
910 if (suffix
== ELF_SUFFIX_GOT
)
913 reloc
= BFD_RELOC_390_GOT16
;
914 else if (nbytes
== 4)
915 reloc
= BFD_RELOC_32_GOT_PCREL
;
916 else if (nbytes
== 8)
917 reloc
= BFD_RELOC_390_GOT64
;
919 else if (suffix
== ELF_SUFFIX_PLT
)
922 reloc
= BFD_RELOC_390_PLT32
;
923 else if (nbytes
== 8)
924 reloc
= BFD_RELOC_390_PLT64
;
927 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
928 as_bad (_("Invalid suffix for literal pool entry"));
930 /* Search the pool if the new entry is a duplicate. */
931 if (exp_p
->X_op
== O_big
)
933 /* Special processing for big numbers. */
934 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
936 if (lpe
->ex
.X_op
== O_big
)
938 if (exp_p
->X_add_number
<= 0 && lpe
->ex
.X_add_number
<= 0)
940 if (memcmp (&generic_floating_point_number
, &lpe
->floatnum
,
941 sizeof (FLONUM_TYPE
)) == 0)
944 else if (exp_p
->X_add_number
== lpe
->ex
.X_add_number
)
946 if (memcmp (generic_bignum
, lpe
->bignum
,
947 sizeof (LITTLENUM_TYPE
)*exp_p
->X_add_number
) == 0)
955 /* Processing for 'normal' data types. */
956 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
957 if (lpe
->nbytes
== nbytes
&& lpe
->reloc
== reloc
958 && s390_exp_compare (exp_p
, &lpe
->ex
) != 0)
965 if (lpe_free_list
!= NULL
)
968 lpe_free_list
= lpe_free_list
->next
;
972 lpe
= (struct s390_lpe
*) xmalloc (sizeof (struct s390_lpe
));
977 if (exp_p
->X_op
== O_big
)
979 if (exp_p
->X_add_number
<= 0)
980 lpe
->floatnum
= generic_floating_point_number
;
981 else if (exp_p
->X_add_number
<= 4)
982 memcpy (lpe
->bignum
, generic_bignum
,
983 exp_p
->X_add_number
* sizeof (LITTLENUM_TYPE
));
985 as_bad (_("Big number is too big"));
988 lpe
->nbytes
= nbytes
;
990 /* Literal pool name defined ? */
993 sprintf (tmp_name
, ".L\001%i", lp_count
);
994 lp_sym
= symbol_make (tmp_name
);
997 /* Make name for literal pool entry. */
998 sprintf (tmp_name
, ".L\001%i\002%i", lp_count
, lpe_count
);
1000 lpe
->sym
= symbol_make (tmp_name
);
1002 /* Add to literal pool list. */
1004 if (lpe_list_tail
!= NULL
)
1006 lpe_list_tail
->next
= lpe
;
1007 lpe_list_tail
= lpe
;
1010 lpe_list
= lpe_list_tail
= lpe
;
1013 /* Now change exp_p to the offset into the literal pool.
1014 Thats the expression: .L^Ax^By-.L^Ax */
1015 exp_p
->X_add_symbol
= lpe
->sym
;
1016 exp_p
->X_op_symbol
= lp_sym
;
1017 exp_p
->X_op
= O_subtract
;
1018 exp_p
->X_add_number
= 0;
1022 /* We change the suffix type to ELF_SUFFIX_NONE, because
1023 the difference of two local labels is just a number. */
1024 return ELF_SUFFIX_NONE
;
1027 /* Like normal .long/.short/.word, except support @got, etc.
1028 clobbers input_line_pointer, checks end-of-line. */
1030 s390_elf_cons (nbytes
)
1031 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
1034 elf_suffix_type suffix
;
1036 if (is_it_end_of_statement ())
1038 demand_empty_rest_of_line ();
1046 if (exp
.X_op
== O_symbol
1047 && *input_line_pointer
== '@'
1048 && (suffix
= s390_elf_suffix (&input_line_pointer
, &exp
)) != ELF_SUFFIX_NONE
)
1050 bfd_reloc_code_real_type reloc
;
1051 reloc_howto_type
*reloc_howto
;
1057 static bfd_reloc_code_real_type tab2
[] =
1059 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1060 BFD_RELOC_390_GOT16
, /* ELF_SUFFIX_GOT */
1061 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_PLT */
1062 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1063 BFD_RELOC_16_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1064 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTPLT */
1065 BFD_RELOC_390_PLTOFF16
, /* ELF_SUFFIX_PLTOFF */
1066 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GD */
1067 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GOTIE */
1068 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_IE */
1069 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDM */
1070 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDO */
1071 BFD_RELOC_UNUSED
/* ELF_SUFFIX_TLS_LE */
1073 reloc
= tab2
[suffix
];
1075 else if (nbytes
== 4)
1077 static bfd_reloc_code_real_type tab4
[] =
1079 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1080 BFD_RELOC_32_GOT_PCREL
, /* ELF_SUFFIX_GOT */
1081 BFD_RELOC_390_PLT32
, /* ELF_SUFFIX_PLT */
1082 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1083 BFD_RELOC_32_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1084 BFD_RELOC_390_GOTPLT32
, /* ELF_SUFFIX_GOTPLT */
1085 BFD_RELOC_390_PLTOFF32
, /* ELF_SUFFIX_PLTOFF */
1086 BFD_RELOC_390_TLS_GD32
, /* ELF_SUFFIX_TLS_GD */
1087 BFD_RELOC_390_TLS_GOTIE32
, /* ELF_SUFFIX_TLS_GOTIE */
1088 BFD_RELOC_390_TLS_IE32
, /* ELF_SUFFIX_TLS_IE */
1089 BFD_RELOC_390_TLS_LDM32
, /* ELF_SUFFIX_TLS_LDM */
1090 BFD_RELOC_390_TLS_LDO32
, /* ELF_SUFFIX_TLS_LDO */
1091 BFD_RELOC_390_TLS_LE32
/* ELF_SUFFIX_TLS_LE */
1093 reloc
= tab4
[suffix
];
1095 else if (nbytes
== 8)
1097 static bfd_reloc_code_real_type tab8
[] =
1099 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1100 BFD_RELOC_390_GOT64
, /* ELF_SUFFIX_GOT */
1101 BFD_RELOC_390_PLT64
, /* ELF_SUFFIX_PLT */
1102 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1103 BFD_RELOC_390_GOTOFF64
, /* ELF_SUFFIX_GOTOFF */
1104 BFD_RELOC_390_GOTPLT64
, /* ELF_SUFFIX_GOTPLT */
1105 BFD_RELOC_390_PLTOFF64
, /* ELF_SUFFIX_PLTOFF */
1106 BFD_RELOC_390_TLS_GD64
, /* ELF_SUFFIX_TLS_GD */
1107 BFD_RELOC_390_TLS_GOTIE64
, /* ELF_SUFFIX_TLS_GOTIE */
1108 BFD_RELOC_390_TLS_IE64
, /* ELF_SUFFIX_TLS_IE */
1109 BFD_RELOC_390_TLS_LDM64
, /* ELF_SUFFIX_TLS_LDM */
1110 BFD_RELOC_390_TLS_LDO64
, /* ELF_SUFFIX_TLS_LDO */
1111 BFD_RELOC_390_TLS_LE64
/* ELF_SUFFIX_TLS_LE */
1113 reloc
= tab8
[suffix
];
1116 reloc
= BFD_RELOC_UNUSED
;
1118 if (reloc
!= BFD_RELOC_UNUSED
1119 && (reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
)))
1121 size
= bfd_get_reloc_size (reloc_howto
);
1123 as_bad (_("%s relocations do not fit in %d bytes"),
1124 reloc_howto
->name
, nbytes
);
1125 where
= frag_more (nbytes
);
1126 md_number_to_chars (where
, 0, size
);
1127 /* To make fixup_segment do the pc relative conversion the
1128 pcrel parameter on the fix_new_exp call needs to be FALSE. */
1129 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1130 size
, &exp
, FALSE
, reloc
);
1133 as_bad (_("relocation not applicable"));
1136 emit_expr (&exp
, (unsigned int) nbytes
);
1138 while (*input_line_pointer
++ == ',');
1140 input_line_pointer
--; /* Put terminator back into stream. */
1141 demand_empty_rest_of_line ();
1144 /* We need to keep a list of fixups. We can't simply generate them as
1145 we go, because that would require us to first create the frag, and
1146 that would screw up references to ``.''. */
1152 bfd_reloc_code_real_type reloc
;
1155 #define MAX_INSN_FIXUPS (4)
1157 /* This routine is called for each instruction to be assembled. */
1160 md_gather_operands (str
, insn
, opcode
)
1162 unsigned char *insn
;
1163 const struct s390_opcode
*opcode
;
1165 struct s390_fixup fixups
[MAX_INSN_FIXUPS
];
1166 const struct s390_operand
*operand
;
1167 const unsigned char *opindex_ptr
;
1169 elf_suffix_type suffix
;
1170 bfd_reloc_code_real_type reloc
;
1176 while (ISSPACE (*str
))
1182 /* Gather the operands. */
1184 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1188 operand
= s390_operands
+ *opindex_ptr
;
1190 if (skip_optional
&& (operand
->flags
& S390_OPERAND_INDEX
))
1192 /* We do an early skip. For D(X,B) constructions the index
1193 register is skipped (X is optional). For D(L,B) the base
1194 register will be the skipped operand, because L is NOT
1200 /* Gather the operand. */
1201 hold
= input_line_pointer
;
1202 input_line_pointer
= str
;
1204 /* Parse the operand. */
1205 if (! register_name (&ex
))
1208 str
= input_line_pointer
;
1209 input_line_pointer
= hold
;
1211 /* Write the operand to the insn. */
1212 if (ex
.X_op
== O_illegal
)
1213 as_bad (_("illegal operand"));
1214 else if (ex
.X_op
== O_absent
)
1215 as_bad (_("missing operand"));
1216 else if (ex
.X_op
== O_register
|| ex
.X_op
== O_constant
)
1218 s390_lit_suffix (&str
, &ex
, ELF_SUFFIX_NONE
);
1220 if (ex
.X_op
!= O_register
&& ex
.X_op
!= O_constant
)
1222 /* We need to generate a fixup for the
1223 expression returned by s390_lit_suffix. */
1224 if (fc
>= MAX_INSN_FIXUPS
)
1225 as_fatal (_("too many fixups"));
1226 fixups
[fc
].exp
= ex
;
1227 fixups
[fc
].opindex
= *opindex_ptr
;
1228 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
1233 if ((operand
->flags
& S390_OPERAND_INDEX
)
1234 && ex
.X_add_number
== 0
1236 as_warn ("index register specified but zero");
1237 if ((operand
->flags
& S390_OPERAND_BASE
)
1238 && ex
.X_add_number
== 0
1240 as_warn ("base register specified but zero");
1241 s390_insert_operand (insn
, operand
, ex
.X_add_number
, NULL
, 0);
1246 suffix
= s390_elf_suffix (&str
, &ex
);
1247 suffix
= s390_lit_suffix (&str
, &ex
, suffix
);
1248 reloc
= BFD_RELOC_UNUSED
;
1250 if (suffix
== ELF_SUFFIX_GOT
)
1252 if (operand
->flags
& S390_OPERAND_DISP
)
1253 reloc
= BFD_RELOC_390_GOT12
;
1254 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1255 && (operand
->bits
== 16))
1256 reloc
= BFD_RELOC_390_GOT16
;
1257 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1258 && (operand
->bits
== 32))
1259 reloc
= BFD_RELOC_390_GOTENT
;
1261 else if (suffix
== ELF_SUFFIX_PLT
)
1263 if ((operand
->flags
& S390_OPERAND_PCREL
)
1264 && (operand
->bits
== 16))
1265 reloc
= BFD_RELOC_390_PLT16DBL
;
1266 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1267 && (operand
->bits
== 32))
1268 reloc
= BFD_RELOC_390_PLT32DBL
;
1270 else if (suffix
== ELF_SUFFIX_GOTENT
)
1272 if ((operand
->flags
& S390_OPERAND_PCREL
)
1273 && (operand
->bits
== 32))
1274 reloc
= BFD_RELOC_390_GOTENT
;
1276 else if (suffix
== ELF_SUFFIX_GOTOFF
)
1278 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1279 && (operand
->bits
== 16))
1280 reloc
= BFD_RELOC_16_GOTOFF
;
1282 else if (suffix
== ELF_SUFFIX_PLTOFF
)
1284 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1285 && (operand
->bits
== 16))
1286 reloc
= BFD_RELOC_390_PLTOFF16
;
1288 else if (suffix
== ELF_SUFFIX_GOTPLT
)
1290 if ((operand
->flags
& S390_OPERAND_DISP
)
1291 && (operand
->bits
== 12))
1292 reloc
= BFD_RELOC_390_GOTPLT12
;
1293 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1294 && (operand
->bits
== 16))
1295 reloc
= BFD_RELOC_390_GOTPLT16
;
1296 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1297 && (operand
->bits
== 32))
1298 reloc
= BFD_RELOC_390_GOTPLTENT
;
1300 else if (suffix
== ELF_SUFFIX_TLS_GOTIE
)
1302 if ((operand
->flags
& S390_OPERAND_DISP
)
1303 && (operand
->bits
== 12))
1304 reloc
= BFD_RELOC_390_TLS_GOTIE12
;
1306 else if (suffix
== ELF_SUFFIX_TLS_IE
)
1308 if ((operand
->flags
& S390_OPERAND_PCREL
)
1309 && (operand
->bits
== 32))
1310 reloc
= BFD_RELOC_390_TLS_IEENT
;
1313 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
1314 as_bad (_("invalid operand suffix"));
1315 /* We need to generate a fixup of type 'reloc' for this
1317 if (fc
>= MAX_INSN_FIXUPS
)
1318 as_fatal (_("too many fixups"));
1319 fixups
[fc
].exp
= ex
;
1320 fixups
[fc
].opindex
= *opindex_ptr
;
1321 fixups
[fc
].reloc
= reloc
;
1325 /* Check the next character. The call to expression has advanced
1326 str past any whitespace. */
1327 if (operand
->flags
& S390_OPERAND_DISP
)
1329 /* After a displacement a block in parentheses can start. */
1332 /* Check if parethesed block can be skipped. If the next
1333 operand is neiter an optional operand nor a base register
1334 then we have a syntax error. */
1335 operand
= s390_operands
+ *(++opindex_ptr
);
1336 if (!(operand
->flags
& (S390_OPERAND_INDEX
|S390_OPERAND_BASE
)))
1337 as_bad (_("syntax error; missing '(' after displacement"));
1339 /* Ok, skip all operands until S390_OPERAND_BASE. */
1340 while (!(operand
->flags
& S390_OPERAND_BASE
))
1341 operand
= s390_operands
+ *(++opindex_ptr
);
1343 /* If there is a next operand it must be seperated by a comma. */
1344 if (opindex_ptr
[1] != '\0')
1347 as_bad (_("syntax error; expected ,"));
1352 /* We found an opening parentheses. */
1354 for (f
= str
; *f
!= '\0'; f
++)
1355 if (*f
== ',' || *f
== ')')
1357 /* If there is no comma until the closing parentheses OR
1358 there is a comma right after the opening parentheses,
1359 we have to skip optional operands. */
1360 if (*f
== ',' && f
== str
)
1362 /* comma directly after '(' ? */
1367 skip_optional
= (*f
!= ',');
1370 else if (operand
->flags
& S390_OPERAND_BASE
)
1372 /* After the base register the parenthesed block ends. */
1374 as_bad (_("syntax error; missing ')' after base register"));
1376 /* If there is a next operand it must be seperated by a comma. */
1377 if (opindex_ptr
[1] != '\0')
1380 as_bad (_("syntax error; expected ,"));
1385 /* We can find an 'early' closing parentheses in e.g. D(L) instead
1386 of D(L,B). In this case the base register has to be skipped. */
1389 operand
= s390_operands
+ *(++opindex_ptr
);
1391 if (!(operand
->flags
& S390_OPERAND_BASE
))
1392 as_bad (_("syntax error; ')' not allowed here"));
1395 /* If there is a next operand it must be seperated by a comma. */
1396 if (opindex_ptr
[1] != '\0')
1399 as_bad (_("syntax error; expected ,"));
1404 while (ISSPACE (*str
))
1407 /* Check for tls instruction marker. */
1408 reloc
= s390_tls_suffix (&str
, &ex
);
1409 if (reloc
!= BFD_RELOC_UNUSED
)
1411 /* We need to generate a fixup of type 'reloc' for this
1413 if (fc
>= MAX_INSN_FIXUPS
)
1414 as_fatal (_("too many fixups"));
1415 fixups
[fc
].exp
= ex
;
1416 fixups
[fc
].opindex
= -1;
1417 fixups
[fc
].reloc
= reloc
;
1425 if ((linefeed
= strchr (str
, '\n')) != NULL
)
1427 as_bad (_("junk at end of line: `%s'"), str
);
1428 if (linefeed
!= NULL
)
1432 /* Write out the instruction. */
1433 f
= frag_more (opcode
->oplen
);
1434 memcpy (f
, insn
, opcode
->oplen
);
1435 dwarf2_emit_insn (opcode
->oplen
);
1437 /* Create any fixups. At this point we do not use a
1438 bfd_reloc_code_real_type, but instead just use the
1439 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1440 handle fixups for any operand type, although that is admittedly
1441 not a very exciting feature. We pick a BFD reloc type in
1443 for (i
= 0; i
< fc
; i
++)
1446 if (fixups
[i
].opindex
< 0)
1448 /* Create tls instruction marker relocation. */
1449 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, opcode
->oplen
,
1450 &fixups
[i
].exp
, 0, fixups
[i
].reloc
);
1454 operand
= s390_operands
+ fixups
[i
].opindex
;
1456 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
1458 reloc_howto_type
*reloc_howto
;
1462 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
1466 size
= bfd_get_reloc_size (reloc_howto
);
1468 if (size
< 1 || size
> 4)
1471 fixP
= fix_new_exp (frag_now
,
1472 f
- frag_now
->fr_literal
+ (operand
->shift
/8),
1473 size
, &fixups
[i
].exp
, reloc_howto
->pc_relative
,
1475 /* Turn off overflow checking in fixup_segment. This is necessary
1476 because fixup_segment will signal an overflow for large 4 byte
1477 quantities for GOT12 relocations. */
1478 if ( fixups
[i
].reloc
== BFD_RELOC_390_GOT12
1479 || fixups
[i
].reloc
== BFD_RELOC_390_GOT16
)
1480 fixP
->fx_no_overflow
= 1;
1483 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4, &fixups
[i
].exp
,
1484 (operand
->flags
& S390_OPERAND_PCREL
) != 0,
1485 ((bfd_reloc_code_real_type
)
1486 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
1491 /* This routine is called for each instruction to be assembled. */
1497 const struct s390_opcode
*opcode
;
1498 unsigned char insn
[6];
1501 /* Get the opcode. */
1502 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1507 /* Look up the opcode in the hash table. */
1508 opcode
= (struct s390_opcode
*) hash_find (s390_opcode_hash
, str
);
1509 if (opcode
== (const struct s390_opcode
*) NULL
)
1511 as_bad (_("Unrecognized opcode: `%s'"), str
);
1514 else if (!(opcode
->modes
& current_mode_mask
))
1516 as_bad ("Opcode %s not available in this mode", str
);
1519 else if (opcode
->min_cpu
> current_cpu
)
1521 as_bad ("Opcode %s not available for this cpu", str
);
1525 memcpy (insn
, opcode
->opcode
, sizeof (insn
));
1526 md_gather_operands (s
, insn
, opcode
);
1529 #ifndef WORKING_DOT_WORD
1530 /* Handle long and short jumps. We don't support these */
1532 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1534 addressT from_addr
, to_addr
;
1542 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1544 addressT from_addr
, to_addr
;
1554 int ignore ATTRIBUTE_UNUSED
;
1556 /* We don't support putting frags in the BSS segment, we fake it
1557 by marking in_bss, then looking at s_skip for clues. */
1559 subseg_set (bss_section
, 0);
1560 demand_empty_rest_of_line ();
1563 /* Pseudo-op handling. */
1567 int ignore ATTRIBUTE_UNUSED
;
1570 const struct s390_opcode
*opformat
;
1571 unsigned char insn
[6];
1574 /* Get the opcode format. */
1575 s
= input_line_pointer
;
1576 while (*s
!= '\0' && *s
!= ',' && ! ISSPACE (*s
))
1579 as_bad (_("Invalid .insn format\n"));
1582 /* Look up the opcode in the hash table. */
1583 opformat
= (struct s390_opcode
*)
1584 hash_find (s390_opformat_hash
, input_line_pointer
);
1585 if (opformat
== (const struct s390_opcode
*) NULL
)
1587 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer
);
1590 input_line_pointer
= s
;
1592 if (exp
.X_op
== O_constant
)
1594 if ( (opformat
->oplen
== 6 && exp
.X_op
> 0 && exp
.X_op
< (1ULL << 48))
1595 || (opformat
->oplen
== 4 && exp
.X_op
> 0 && exp
.X_op
< (1ULL << 32))
1596 || (opformat
->oplen
== 2 && exp
.X_op
> 0 && exp
.X_op
< (1ULL << 16)))
1597 md_number_to_chars (insn
, exp
.X_add_number
, opformat
->oplen
);
1599 as_bad (_("Invalid .insn format\n"));
1601 else if (exp
.X_op
== O_big
)
1603 if (exp
.X_add_number
> 0
1604 && opformat
->oplen
== 6
1605 && generic_bignum
[3] == 0)
1607 md_number_to_chars (insn
, generic_bignum
[2], 2);
1608 md_number_to_chars (&insn
[2], generic_bignum
[1], 2);
1609 md_number_to_chars (&insn
[4], generic_bignum
[0], 2);
1612 as_bad (_("Invalid .insn format\n"));
1615 as_bad (_("second operand of .insn not a constant\n"));
1617 if (strcmp (opformat
->name
, "e") != 0 && *input_line_pointer
++ != ',')
1618 as_bad (_("missing comma after insn constant\n"));
1620 if ((s
= strchr (input_line_pointer
, '\n')) != NULL
)
1622 input_line_pointer
= md_gather_operands (input_line_pointer
, insn
,
1626 demand_empty_rest_of_line ();
1629 /* The .byte pseudo-op. This is similar to the normal .byte
1630 pseudo-op, but it can also take a single ASCII string. */
1634 int ignore ATTRIBUTE_UNUSED
;
1636 if (*input_line_pointer
!= '\"')
1642 /* Gather characters. A real double quote is doubled. Unusual
1643 characters are not permitted. */
1644 ++input_line_pointer
;
1649 c
= *input_line_pointer
++;
1653 if (*input_line_pointer
!= '\"')
1655 ++input_line_pointer
;
1658 FRAG_APPEND_1_CHAR (c
);
1661 demand_empty_rest_of_line ();
1664 /* The .ltorg pseudo-op.This emits all literals defined since the last
1665 .ltorg or the invocation of gas. Literals are defined with the
1669 s390_literals (ignore
)
1670 int ignore ATTRIBUTE_UNUSED
;
1672 struct s390_lpe
*lpe
;
1674 if (lp_sym
== NULL
|| lpe_count
== 0)
1675 return; /* Nothing to be done. */
1677 /* Emit symbol for start of literal pool. */
1678 S_SET_SEGMENT (lp_sym
, now_seg
);
1679 S_SET_VALUE (lp_sym
, (valueT
) frag_now_fix ());
1680 lp_sym
->sy_frag
= frag_now
;
1685 lpe_list
= lpe_list
->next
;
1686 S_SET_SEGMENT (lpe
->sym
, now_seg
);
1687 S_SET_VALUE (lpe
->sym
, (valueT
) frag_now_fix ());
1688 lpe
->sym
->sy_frag
= frag_now
;
1690 /* Emit literal pool entry. */
1691 if (lpe
->reloc
!= BFD_RELOC_UNUSED
)
1693 reloc_howto_type
*reloc_howto
=
1694 bfd_reloc_type_lookup (stdoutput
, lpe
->reloc
);
1695 int size
= bfd_get_reloc_size (reloc_howto
);
1698 if (size
> lpe
->nbytes
)
1699 as_bad (_("%s relocations do not fit in %d bytes"),
1700 reloc_howto
->name
, lpe
->nbytes
);
1701 where
= frag_more (lpe
->nbytes
);
1702 md_number_to_chars (where
, 0, size
);
1703 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1704 size
, &lpe
->ex
, reloc_howto
->pc_relative
, lpe
->reloc
);
1708 if (lpe
->ex
.X_op
== O_big
)
1710 if (lpe
->ex
.X_add_number
<= 0)
1711 generic_floating_point_number
= lpe
->floatnum
;
1713 memcpy (generic_bignum
, lpe
->bignum
,
1714 lpe
->ex
.X_add_number
* sizeof (LITTLENUM_TYPE
));
1716 emit_expr (&lpe
->ex
, lpe
->nbytes
);
1719 lpe
->next
= lpe_free_list
;
1720 lpe_free_list
= lpe
;
1722 lpe_list_tail
= NULL
;
1728 /* Turn a string in input_line_pointer into a floating point constant
1729 of type type, and store the appropriate bytes in *litp. The number
1730 of LITTLENUMS emitted is stored in *sizep . An error message is
1731 returned, or NULL on OK. */
1734 md_atof (type
, litp
, sizep
)
1740 LITTLENUM_TYPE words
[4];
1756 return "bad call to md_atof";
1759 t
= atof_ieee (input_line_pointer
, type
, words
);
1761 input_line_pointer
= t
;
1765 for (i
= 0; i
< prec
; i
++)
1767 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
1774 /* Align a section (I don't know why this is machine dependent). */
1777 md_section_align (seg
, addr
)
1781 int align
= bfd_get_section_alignment (stdoutput
, seg
);
1783 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
1786 /* We don't have any form of relaxing. */
1789 md_estimate_size_before_relax (fragp
, seg
)
1790 fragS
*fragp ATTRIBUTE_UNUSED
;
1791 asection
*seg ATTRIBUTE_UNUSED
;
1797 /* Convert a machine dependent frag. We never generate these. */
1800 md_convert_frag (abfd
, sec
, fragp
)
1801 bfd
*abfd ATTRIBUTE_UNUSED
;
1802 asection
*sec ATTRIBUTE_UNUSED
;
1803 fragS
*fragp ATTRIBUTE_UNUSED
;
1809 md_undefined_symbol (name
)
1812 if (*name
== '_' && *(name
+ 1) == 'G'
1813 && strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
1817 if (symbol_find (name
))
1818 as_bad (_("GOT already in symbol table"));
1819 GOT_symbol
= symbol_new (name
, undefined_section
,
1820 (valueT
) 0, &zero_address_frag
);
1827 /* Functions concerning relocs. */
1829 /* The location from which a PC relative jump should be calculated,
1830 given a PC relative reloc. */
1833 md_pcrel_from_section (fixp
, sec
)
1835 segT sec ATTRIBUTE_UNUSED
;
1837 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
1840 /* Here we decide which fixups can be adjusted to make them relative to
1841 the beginning of the section instead of the symbol. Basically we need
1842 to make sure that the dynamic relocations are done correctly, so in
1843 some cases we force the original symbol to be used. */
1845 tc_s390_fix_adjustable (fixP
)
1848 /* Don't adjust references to merge sections. */
1849 if ((S_GET_SEGMENT (fixP
->fx_addsy
)->flags
& SEC_MERGE
) != 0)
1851 /* adjust_reloc_syms doesn't know about the GOT. */
1852 if ( fixP
->fx_r_type
== BFD_RELOC_16_GOTOFF
1853 || fixP
->fx_r_type
== BFD_RELOC_32_GOTOFF
1854 || fixP
->fx_r_type
== BFD_RELOC_390_GOTOFF64
1855 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF16
1856 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF32
1857 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF64
1858 || fixP
->fx_r_type
== BFD_RELOC_390_PLT16DBL
1859 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32
1860 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32DBL
1861 || fixP
->fx_r_type
== BFD_RELOC_390_PLT64
1862 || fixP
->fx_r_type
== BFD_RELOC_390_GOT12
1863 || fixP
->fx_r_type
== BFD_RELOC_390_GOT16
1864 || fixP
->fx_r_type
== BFD_RELOC_32_GOT_PCREL
1865 || fixP
->fx_r_type
== BFD_RELOC_390_GOT64
1866 || fixP
->fx_r_type
== BFD_RELOC_390_GOTENT
1867 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT12
1868 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT16
1869 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT32
1870 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT64
1871 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLTENT
1872 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LOAD
1873 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GDCALL
1874 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDCALL
1875 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD32
1876 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD64
1877 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE12
1878 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE32
1879 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE64
1880 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM32
1881 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM64
1882 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE32
1883 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE64
1884 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IEENT
1885 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE32
1886 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE64
1887 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO32
1888 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO64
1889 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPMOD
1890 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPOFF
1891 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_TPOFF
1892 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
1893 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
1898 /* Return true if we must always emit a reloc for a type and false if
1899 there is some hope of resolving it at assembly time. */
1901 tc_s390_force_relocation (fixp
)
1904 /* Ensure we emit a relocation for every reference to the global
1905 offset table or to the procedure link table. */
1906 switch (fixp
->fx_r_type
)
1908 case BFD_RELOC_390_GOT12
:
1909 case BFD_RELOC_32_GOT_PCREL
:
1910 case BFD_RELOC_32_GOTOFF
:
1911 case BFD_RELOC_390_GOTOFF64
:
1912 case BFD_RELOC_390_PLTOFF16
:
1913 case BFD_RELOC_390_PLTOFF32
:
1914 case BFD_RELOC_390_PLTOFF64
:
1915 case BFD_RELOC_390_GOTPC
:
1916 case BFD_RELOC_390_GOT16
:
1917 case BFD_RELOC_390_GOTPCDBL
:
1918 case BFD_RELOC_390_GOT64
:
1919 case BFD_RELOC_390_GOTENT
:
1920 case BFD_RELOC_390_PLT32
:
1921 case BFD_RELOC_390_PLT16DBL
:
1922 case BFD_RELOC_390_PLT32DBL
:
1923 case BFD_RELOC_390_PLT64
:
1924 case BFD_RELOC_390_GOTPLT12
:
1925 case BFD_RELOC_390_GOTPLT16
:
1926 case BFD_RELOC_390_GOTPLT32
:
1927 case BFD_RELOC_390_GOTPLT64
:
1928 case BFD_RELOC_390_GOTPLTENT
:
1934 return generic_force_reloc (fixp
);
1937 /* Apply a fixup to the object code. This is called for all the
1938 fixups we generated by the call to fix_new_exp, above. In the call
1939 above we used a reloc code which was the largest legal reloc code
1940 plus the operand index. Here we undo that to recover the operand
1941 index. At this point all symbol values should be fully resolved,
1942 and we attempt to completely resolve the reloc. If we can not do
1943 that, we determine the correct reloc code and put it back in the
1947 md_apply_fix3 (fixP
, valP
, seg
)
1950 segT seg ATTRIBUTE_UNUSED
;
1953 valueT value
= *valP
;
1955 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
1957 if (fixP
->fx_subsy
!= NULL
)
1958 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1959 "cannot emit relocation %s against subsy symbol %s",
1960 bfd_get_reloc_code_name (fixP
->fx_r_type
),
1961 S_GET_NAME (fixP
->fx_subsy
));
1963 if (fixP
->fx_addsy
!= NULL
)
1966 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
1971 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
1973 const struct s390_operand
*operand
;
1976 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
1977 operand
= &s390_operands
[opindex
];
1981 /* Insert the fully resolved operand value. */
1982 s390_insert_operand (where
, operand
, (offsetT
) value
,
1983 fixP
->fx_file
, fixP
->fx_line
);
1987 /* Determine a BFD reloc value based on the operand information.
1988 We are only prepared to turn a few of the operands into
1990 fixP
->fx_offset
= value
;
1991 if (operand
->bits
== 12 && operand
->shift
== 20)
1994 fixP
->fx_where
+= 2;
1995 fixP
->fx_r_type
= BFD_RELOC_390_12
;
1997 else if (operand
->bits
== 12 && operand
->shift
== 36)
2000 fixP
->fx_where
+= 4;
2001 fixP
->fx_r_type
= BFD_RELOC_390_12
;
2003 else if (operand
->bits
== 8 && operand
->shift
== 8)
2006 fixP
->fx_where
+= 1;
2007 fixP
->fx_r_type
= BFD_RELOC_8
;
2009 else if (operand
->bits
== 16 && operand
->shift
== 16)
2012 fixP
->fx_where
+= 2;
2013 if (operand
->flags
& S390_OPERAND_PCREL
)
2015 fixP
->fx_r_type
= BFD_RELOC_390_PC16DBL
;
2016 fixP
->fx_offset
+= 2;
2019 fixP
->fx_r_type
= BFD_RELOC_16
;
2021 else if (operand
->bits
== 32 && operand
->shift
== 16
2022 && (operand
->flags
& S390_OPERAND_PCREL
))
2025 fixP
->fx_where
+= 2;
2026 fixP
->fx_offset
+= 2;
2027 fixP
->fx_r_type
= BFD_RELOC_390_PC32DBL
;
2034 /* Use expr_symbol_where to see if this is an expression
2036 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
2037 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2038 _("unresolved expression that must be resolved"));
2040 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2041 _("unsupported relocation type"));
2048 switch (fixP
->fx_r_type
)
2054 md_number_to_chars (where
, value
, 1);
2056 case BFD_RELOC_390_12
:
2057 case BFD_RELOC_390_GOT12
:
2058 case BFD_RELOC_390_GOTPLT12
:
2063 mop
= bfd_getb16 ((unsigned char *) where
);
2064 mop
|= (unsigned short) (value
& 0xfff);
2065 bfd_putb16 ((bfd_vma
) mop
, (unsigned char *) where
);
2070 case BFD_RELOC_GPREL16
:
2071 case BFD_RELOC_16_GOT_PCREL
:
2072 case BFD_RELOC_16_GOTOFF
:
2074 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2075 "cannot emit PC relative %s relocation%s%s",
2076 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2077 fixP
->fx_addsy
!= NULL
? " against " : "",
2078 (fixP
->fx_addsy
!= NULL
2079 ? S_GET_NAME (fixP
->fx_addsy
)
2082 md_number_to_chars (where
, value
, 2);
2084 case BFD_RELOC_390_GOT16
:
2085 case BFD_RELOC_390_PLTOFF16
:
2086 case BFD_RELOC_390_GOTPLT16
:
2088 md_number_to_chars (where
, value
, 2);
2090 case BFD_RELOC_390_PC16DBL
:
2091 case BFD_RELOC_390_PLT16DBL
:
2094 md_number_to_chars (where
, (offsetT
) value
>> 1, 2);
2099 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2101 fixP
->fx_r_type
= BFD_RELOC_32
;
2103 md_number_to_chars (where
, value
, 4);
2105 case BFD_RELOC_32_PCREL
:
2106 case BFD_RELOC_32_BASEREL
:
2107 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2109 md_number_to_chars (where
, value
, 4);
2111 case BFD_RELOC_32_GOT_PCREL
:
2112 case BFD_RELOC_390_PLTOFF32
:
2113 case BFD_RELOC_390_PLT32
:
2114 case BFD_RELOC_390_GOTPLT32
:
2116 md_number_to_chars (where
, value
, 4);
2118 case BFD_RELOC_390_PC32DBL
:
2119 case BFD_RELOC_390_PLT32DBL
:
2120 case BFD_RELOC_390_GOTPCDBL
:
2121 case BFD_RELOC_390_GOTENT
:
2122 case BFD_RELOC_390_GOTPLTENT
:
2125 md_number_to_chars (where
, (offsetT
) value
>> 1, 4);
2128 case BFD_RELOC_32_GOTOFF
:
2130 md_number_to_chars (where
, value
, sizeof (int));
2133 case BFD_RELOC_390_GOTOFF64
:
2135 md_number_to_chars (where
, value
, 8);
2138 case BFD_RELOC_390_GOT64
:
2139 case BFD_RELOC_390_PLTOFF64
:
2140 case BFD_RELOC_390_PLT64
:
2141 case BFD_RELOC_390_GOTPLT64
:
2143 md_number_to_chars (where
, value
, 8);
2148 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2150 fixP
->fx_r_type
= BFD_RELOC_64
;
2152 md_number_to_chars (where
, value
, 8);
2155 case BFD_RELOC_64_PCREL
:
2156 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2158 md_number_to_chars (where
, value
, 8);
2161 case BFD_RELOC_VTABLE_INHERIT
:
2162 case BFD_RELOC_VTABLE_ENTRY
:
2166 case BFD_RELOC_390_TLS_LOAD
:
2167 case BFD_RELOC_390_TLS_GDCALL
:
2168 case BFD_RELOC_390_TLS_LDCALL
:
2169 case BFD_RELOC_390_TLS_GD32
:
2170 case BFD_RELOC_390_TLS_GD64
:
2171 case BFD_RELOC_390_TLS_GOTIE12
:
2172 case BFD_RELOC_390_TLS_GOTIE32
:
2173 case BFD_RELOC_390_TLS_GOTIE64
:
2174 case BFD_RELOC_390_TLS_LDM32
:
2175 case BFD_RELOC_390_TLS_LDM64
:
2176 case BFD_RELOC_390_TLS_IE32
:
2177 case BFD_RELOC_390_TLS_IE64
:
2178 case BFD_RELOC_390_TLS_LE32
:
2179 case BFD_RELOC_390_TLS_LE64
:
2180 case BFD_RELOC_390_TLS_LDO32
:
2181 case BFD_RELOC_390_TLS_LDO64
:
2182 case BFD_RELOC_390_TLS_DTPMOD
:
2183 case BFD_RELOC_390_TLS_DTPOFF
:
2184 case BFD_RELOC_390_TLS_TPOFF
:
2185 /* Fully resolved at link time. */
2187 case BFD_RELOC_390_TLS_IEENT
:
2188 /* Fully resolved at link time. */
2194 const char *reloc_name
= bfd_get_reloc_code_name (fixP
->fx_r_type
);
2196 if (reloc_name
!= NULL
)
2197 fprintf (stderr
, "Gas failure, reloc type %s\n", reloc_name
);
2199 fprintf (stderr
, "Gas failure, reloc type #%i\n", fixP
->fx_r_type
);
2205 fixP
->fx_offset
= value
;
2209 /* Generate a reloc for a fixup. */
2212 tc_gen_reloc (seg
, fixp
)
2213 asection
*seg ATTRIBUTE_UNUSED
;
2216 bfd_reloc_code_real_type code
;
2219 code
= fixp
->fx_r_type
;
2220 if (GOT_symbol
&& fixp
->fx_addsy
== GOT_symbol
)
2222 if ( (s390_arch_size
== 32 && code
== BFD_RELOC_32_PCREL
)
2223 || (s390_arch_size
== 64 && code
== BFD_RELOC_64_PCREL
))
2224 code
= BFD_RELOC_390_GOTPC
;
2225 if (code
== BFD_RELOC_390_PC32DBL
)
2226 code
= BFD_RELOC_390_GOTPCDBL
;
2229 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
2230 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
2231 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2232 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2233 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2234 if (reloc
->howto
== NULL
)
2236 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2237 _("cannot represent relocation type %s"),
2238 bfd_get_reloc_code_name (code
));
2239 /* Set howto to a garbage value so that we can keep going. */
2240 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
2241 assert (reloc
->howto
!= NULL
);
2243 reloc
->addend
= fixp
->fx_offset
;