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
;
39 /* Current architecture. Start with the smallest instruction set. */
40 static enum s390_opcode_arch_val current_architecture
= S390_OPCODE_ESA
;
41 static int current_arch_mask
= 1 << S390_OPCODE_ESA
;
42 static int current_arch_requested
= 0;
44 /* Whether to use user friendly register names. Default is TRUE. */
45 #ifndef TARGET_REG_NAMES_P
46 #define TARGET_REG_NAMES_P TRUE
49 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
51 /* Set to TRUE if we want to warn about zero base/index registers. */
52 static bfd_boolean warn_areg_zero
= FALSE
;
54 /* Generic assembler global variables which must be defined by all
57 const char comment_chars
[] = "#";
59 /* Characters which start a comment at the beginning of a line. */
60 const char line_comment_chars
[] = "#";
62 /* Characters which may be used to separate multiple commands on a
64 const char line_separator_chars
[] = ";";
66 /* Characters which are used to indicate an exponent in a floating
68 const char EXP_CHARS
[] = "eE";
70 /* Characters which mean that a number is a floating point constant,
72 const char FLT_CHARS
[] = "dD";
74 /* The target specific pseudo-ops which we support. */
76 /* Define the prototypes for the pseudo-ops */
77 static void s390_byte
PARAMS ((int));
78 static void s390_elf_cons
PARAMS ((int));
79 static void s390_bss
PARAMS ((int));
80 static void s390_insn
PARAMS ((int));
81 static void s390_literals
PARAMS ((int));
83 const pseudo_typeS md_pseudo_table
[] =
85 { "align", s_align_bytes
, 0 },
86 /* Pseudo-ops which must be defined. */
87 { "bss", s390_bss
, 0 },
88 { "insn", s390_insn
, 0 },
89 /* Pseudo-ops which must be overridden. */
90 { "byte", s390_byte
, 0 },
91 { "short", s390_elf_cons
, 2 },
92 { "long", s390_elf_cons
, 4 },
93 { "quad", s390_elf_cons
, 8 },
94 { "ltorg", s390_literals
, 0 },
95 { "string", stringer
, 2 },
100 /* Structure to hold information about predefined registers. */
107 /* List of registers that are pre-defined:
109 Each access register has a predefined name of the form:
110 a<reg_num> which has the value <reg_num>.
112 Each control register has a predefined name of the form:
113 c<reg_num> which has the value <reg_num>.
115 Each general register has a predefined name of the form:
116 r<reg_num> which has the value <reg_num>.
118 Each floating point register a has predefined name of the form:
119 f<reg_num> which has the value <reg_num>.
121 There are individual registers as well:
125 The table is sorted. Suitable for searching by a binary search. */
127 static const struct pd_reg pre_defined_registers
[] =
129 { "a0", 0 }, /* Access registers */
146 { "c0", 0 }, /* Control registers */
163 { "f0", 0 }, /* Floating point registers */
180 { "lit", 13 }, /* Pointer to literal pool */
182 { "r0", 0 }, /* General purpose registers */
199 { "sp", 15 }, /* Stack pointer */
203 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
205 static int reg_name_search
206 PARAMS ((const struct pd_reg
*, int, const char *));
207 static bfd_boolean register_name
PARAMS ((expressionS
*));
208 static void init_default_arch
PARAMS ((void));
209 static void s390_insert_operand
210 PARAMS ((unsigned char *, const struct s390_operand
*, offsetT
, char *,
212 static char *md_gather_operands
213 PARAMS ((char *, unsigned char *, const struct s390_opcode
*));
215 /* Given NAME, find the register number associated with that name, return
216 the integer value associated with the given name or -1 on failure. */
219 reg_name_search (regs
, regcount
, name
)
220 const struct pd_reg
*regs
;
224 int middle
, low
, high
;
232 middle
= (low
+ high
) / 2;
233 cmp
= strcasecmp (name
, regs
[middle
].name
);
239 return regs
[middle
].value
;
248 * Summary of register_name().
250 * in: Input_line_pointer points to 1st char of operand.
252 * out: A expressionS.
253 * The operand may have been a register: in this case, X_op == O_register,
254 * X_add_number is set to the register number, and truth is returned.
255 * Input_line_pointer->(next non-blank) char after operand, or is in its
260 register_name (expressionP
)
261 expressionS
*expressionP
;
268 /* Find the spelling of the operand. */
269 start
= name
= input_line_pointer
;
270 if (name
[0] == '%' && ISALPHA (name
[1]))
271 name
= ++input_line_pointer
;
275 c
= get_symbol_end ();
276 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
278 /* Put back the delimiting char. */
279 *input_line_pointer
= c
;
281 /* Look to see if it's in the register table. */
284 expressionP
->X_op
= O_register
;
285 expressionP
->X_add_number
= reg_number
;
287 /* Make the rest nice. */
288 expressionP
->X_add_symbol
= NULL
;
289 expressionP
->X_op_symbol
= NULL
;
293 /* Reset the line as if we had not done anything. */
294 input_line_pointer
= start
;
298 /* Local variables. */
300 /* Opformat hash table. */
301 static struct hash_control
*s390_opformat_hash
;
303 /* Opcode hash table. */
304 static struct hash_control
*s390_opcode_hash
;
306 /* Flags to set in the elf header */
307 static flagword s390_flags
= 0;
309 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
311 #ifndef WORKING_DOT_WORD
312 const int md_short_jump_size
= 4;
313 const int md_long_jump_size
= 4;
316 const char *md_shortopts
= "A:m:kVQ:";
317 struct option md_longopts
[] = {
318 {NULL
, no_argument
, NULL
, 0}
320 size_t md_longopts_size
= sizeof (md_longopts
);
322 /* Initialize the default opcode arch and word size from the default
323 architecture name. */
327 if (current_arch_requested
)
330 if (strcmp (default_arch
, "s390") == 0)
333 current_architecture
= S390_OPCODE_ESA
;
335 else if (strcmp (default_arch
, "s390x") == 0)
338 current_architecture
= S390_OPCODE_ESAME
;
341 as_fatal ("Invalid default architecture, broken assembler.");
342 current_arch_mask
= 1 << current_architecture
;
345 /* Called by TARGET_FORMAT. */
347 s390_target_format ()
349 /* We don't get a chance to initialize anything before we're called,
350 so handle that now. */
351 if (! s390_arch_size
)
352 init_default_arch ();
354 return s390_arch_size
== 64 ? "elf64-s390" : "elf32-s390";
358 md_parse_option (c
, arg
)
364 /* -k: Ignore for FreeBSD compatibility. */
368 if (arg
!= NULL
&& strcmp (arg
, "regnames") == 0)
371 else if (arg
!= NULL
&& strcmp (arg
, "no-regnames") == 0)
374 else if (arg
!= NULL
&& strcmp (arg
, "warn-areg-zero") == 0)
375 warn_areg_zero
= TRUE
;
377 else if (arg
!= NULL
&& strcmp (arg
, "31") == 0)
380 else if (arg
!= NULL
&& strcmp (arg
, "64") == 0)
385 as_bad (_("invalid switch -m%s"), arg
);
391 if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
392 current_architecture
= S390_OPCODE_ESA
;
393 else if (arg
!= NULL
&& strcmp (arg
, "esame") == 0)
394 current_architecture
= S390_OPCODE_ESAME
;
396 as_bad ("invalid architecture -A%s", arg
);
397 current_arch_mask
= 1 << current_architecture
;
398 current_arch_requested
= 1;
401 /* -V: SVR4 argument to print version ID. */
406 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
407 should be emitted or not. FIXME: Not implemented. */
419 md_show_usage (stream
)
422 fprintf (stream
, _("\
424 -mregnames Allow symbolic names for registers\n\
425 -mwarn-areg-zero Warn about zero base/index registers\n\
426 -mno-regnames Do not allow symbolic names for registers\n\
427 -m31 Set file format to 31 bit format\n\
428 -m64 Set file format to 64 bit format\n"));
429 fprintf (stream
, _("\
430 -V print assembler version number\n\
431 -Qy, -Qn ignored\n"));
434 /* This function is called when the assembler starts up. It is called
435 after the options have been parsed and the output file has been
441 register const struct s390_opcode
*op
;
442 const struct s390_opcode
*op_end
;
443 bfd_boolean dup_insn
= FALSE
;
446 /* Give a warning if the combination -m64-bit and -Aesa is used. */
447 if (s390_arch_size
== 64 && current_arch_mask
== (1 << S390_OPCODE_ESA
))
448 as_warn ("The 64 bit file format is used without esame instructions.");
450 /* Set the ELF flags if desired. */
452 bfd_set_private_flags (stdoutput
, s390_flags
);
454 /* Insert the opcode formats into a hash table. */
455 s390_opformat_hash
= hash_new ();
457 op_end
= s390_opformats
+ s390_num_opformats
;
458 for (op
= s390_opformats
; op
< op_end
; op
++)
460 retval
= hash_insert (s390_opformat_hash
, op
->name
, (PTR
) op
);
461 if (retval
!= (const char *) NULL
)
463 as_bad (_("Internal assembler error for instruction format %s"),
469 /* Insert the opcodes into a hash table. */
470 s390_opcode_hash
= hash_new ();
472 op_end
= s390_opcodes
+ s390_num_opcodes
;
473 for (op
= s390_opcodes
; op
< op_end
; op
++)
475 retval
= hash_insert (s390_opcode_hash
, op
->name
, (PTR
) op
);
476 if (retval
!= (const char *) NULL
)
478 as_bad (_("Internal assembler error for instruction %s"), op
->name
);
486 record_alignment (text_section
, 2);
487 record_alignment (data_section
, 2);
488 record_alignment (bss_section
, 2);
492 /* Called after all assembly has been done. */
496 if (s390_arch_size
== 64)
497 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_64
);
499 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_31
);
503 s390_align_code (fragP
, count
)
507 /* We use nop pattern 0x0707. */
510 memset (fragP
->fr_literal
+ fragP
->fr_fix
, 0x07, count
);
511 fragP
->fr_var
= count
;
515 /* Insert an operand value into an instruction. */
518 s390_insert_operand (insn
, operand
, val
, file
, line
)
520 const struct s390_operand
*operand
;
528 if (operand
->flags
& (S390_OPERAND_SIGNED
|S390_OPERAND_PCREL
))
532 max
= ((offsetT
) 1 << (operand
->bits
- 1)) - 1;
533 min
= - ((offsetT
) 1 << (operand
->bits
- 1));
534 /* Halve PCREL operands. */
535 if (operand
->flags
& S390_OPERAND_PCREL
)
537 /* Check for underflow / overflow. */
538 if (val
< min
|| val
> max
)
541 "operand out of range (%s not between %ld and %ld)";
544 if (operand
->flags
& S390_OPERAND_PCREL
)
550 sprint_value (buf
, val
);
551 if (file
== (char *) NULL
)
552 as_bad (err
, buf
, (int) min
, (int) max
);
554 as_bad_where (file
, line
, err
, buf
, (int) min
, (int) max
);
557 /* val is ok, now restrict it to operand->bits bits. */
558 uval
= (addressT
) val
& ((((addressT
) 1 << (operand
->bits
-1)) << 1) - 1);
564 max
= (((addressT
) 1 << (operand
->bits
- 1)) << 1) - 1;
566 uval
= (addressT
) val
;
567 /* Length x in an instructions has real length x+1. */
568 if (operand
->flags
& S390_OPERAND_LENGTH
)
570 /* Check for underflow / overflow. */
571 if (uval
< min
|| uval
> max
)
574 "operand out of range (%s not between %ld and %ld)";
577 if (operand
->flags
& S390_OPERAND_LENGTH
)
583 sprint_value (buf
, uval
);
584 if (file
== (char *) NULL
)
585 as_bad (err
, buf
, (int) min
, (int) max
);
587 as_bad_where (file
, line
, err
, buf
, (int) min
, (int) max
);
592 /* Insert fragments of the operand byte for byte. */
593 offset
= operand
->shift
+ operand
->bits
;
594 uval
<<= (-offset
) & 7;
595 insn
+= (offset
- 1) / 8;
607 bfd_reloc_code_real_type reloc
;
610 static bfd_reloc_code_real_type s390_tls_suffix
611 PARAMS ((char **, expressionS
*));
613 /* Parse tls marker and return the desired relocation. */
614 static bfd_reloc_code_real_type
615 s390_tls_suffix (str_p
, 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
;
690 static elf_suffix_type s390_elf_suffix
PARAMS ((char **, expressionS
*));
691 static int s390_exp_compare
PARAMS ((expressionS
*exp1
, expressionS
*exp2
));
692 static elf_suffix_type s390_lit_suffix
693 PARAMS ((char **, expressionS
*, elf_suffix_type
));
696 /* Parse @got/@plt/@gotoff. and return the desired relocation. */
697 static elf_suffix_type
698 s390_elf_suffix (str_p
, exp_p
)
702 static struct map_bfd mapping
[] =
704 { "got", 3, ELF_SUFFIX_GOT
},
705 { "got12", 5, ELF_SUFFIX_GOT
},
706 { "plt", 3, ELF_SUFFIX_PLT
},
707 { "gotent", 6, ELF_SUFFIX_GOTENT
},
708 { "gotoff", 6, ELF_SUFFIX_GOTOFF
},
709 { "gotplt", 6, ELF_SUFFIX_GOTPLT
},
710 { "pltoff", 6, ELF_SUFFIX_PLTOFF
},
711 { "tlsgd", 5, ELF_SUFFIX_TLS_GD
},
712 { "gotntpoff", 9, ELF_SUFFIX_TLS_GOTIE
},
713 { "indntpoff", 9, ELF_SUFFIX_TLS_IE
},
714 { "tlsldm", 6, ELF_SUFFIX_TLS_LDM
},
715 { "dtpoff", 6, ELF_SUFFIX_TLS_LDO
},
716 { "ntpoff", 6, ELF_SUFFIX_TLS_LE
},
717 { NULL
, 0, ELF_SUFFIX_NONE
}
726 return ELF_SUFFIX_NONE
;
729 while (ISALNUM (*str
))
733 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
734 if (len
== ptr
->length
735 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
737 if (exp_p
->X_add_number
!= 0)
738 as_warn (_("identifier+constant@%s means identifier@%s+constant"),
739 ptr
->string
, ptr
->string
);
740 /* Now check for identifier@suffix+constant. */
741 if (*str
== '-' || *str
== '+')
743 char *orig_line
= input_line_pointer
;
746 input_line_pointer
= str
;
747 expression (&new_exp
);
749 switch (new_exp
.X_op
)
751 case O_constant
: /* X_add_number (a constant expression). */
752 exp_p
->X_add_number
+= new_exp
.X_add_number
;
753 str
= input_line_pointer
;
755 case O_symbol
: /* 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
;
760 str
= input_line_pointer
;
762 case O_uminus
: /* (- X_add_symbol) + X_add_number. */
763 /* this case is used for e.g. xyz@PLT-.Label. */
764 exp_p
->X_add_number
+= new_exp
.X_add_number
;
765 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
766 exp_p
->X_op
= O_subtract
;
767 str
= input_line_pointer
;
773 /* If s390_elf_suffix has not been called with
774 &input_line_pointer as first parameter, we have
775 clobbered the input_line_pointer. We have to
777 if (&input_line_pointer
!= str_p
)
778 input_line_pointer
= orig_line
;
784 return BFD_RELOC_UNUSED
;
787 /* Structure used to hold a literal pool entry. */
790 struct s390_lpe
*next
;
792 FLONUM_TYPE floatnum
; /* used if X_op == O_big && X_add_number <= 0 */
793 LITTLENUM_TYPE bignum
[4]; /* used if X_op == O_big && X_add_number > 0 */
795 bfd_reloc_code_real_type reloc
;
799 static struct s390_lpe
*lpe_free_list
= NULL
;
800 static struct s390_lpe
*lpe_list
= NULL
;
801 static struct s390_lpe
*lpe_list_tail
= NULL
;
802 static symbolS
*lp_sym
= NULL
;
803 static int lp_count
= 0;
804 static int lpe_count
= 0;
807 s390_exp_compare (exp1
, exp2
)
811 if (exp1
->X_op
!= exp2
->X_op
)
816 case O_constant
: /* X_add_number must be equal. */
818 return exp1
->X_add_number
== exp2
->X_add_number
;
821 as_bad (_("Can't handle O_big in s390_exp_compare"));
823 case O_symbol
: /* X_add_symbol & X_add_number must be equal. */
828 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
829 && (exp1
->X_add_number
== exp2
->X_add_number
);
831 case O_multiply
: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
836 case O_bit_inclusive_or
:
838 case O_bit_exclusive_or
:
850 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
851 && (exp1
->X_op_symbol
== exp2
->X_op_symbol
)
852 && (exp1
->X_add_number
== exp2
->X_add_number
);
858 /* Test for @lit and if its present make an entry in the literal pool and
859 modify the current expression to be an offset into the literal pool. */
860 static elf_suffix_type
861 s390_lit_suffix (str_p
, exp_p
, suffix
)
864 elf_suffix_type suffix
;
866 bfd_reloc_code_real_type reloc
;
870 struct s390_lpe
*lpe
;
874 return suffix
; /* No modification. */
876 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
878 while (ISALNUM (*str
))
881 if (len
!= 4 || strncasecmp (ident
, "lit", 3) != 0
882 || (ident
[3]!='1' && ident
[3]!='2' && ident
[3]!='4' && ident
[3]!='8'))
883 return suffix
; /* no modification */
884 nbytes
= ident
[3] - '0';
886 reloc
= BFD_RELOC_UNUSED
;
887 if (suffix
== ELF_SUFFIX_GOT
)
890 reloc
= BFD_RELOC_390_GOT16
;
891 else if (nbytes
== 4)
892 reloc
= BFD_RELOC_32_GOT_PCREL
;
893 else if (nbytes
== 8)
894 reloc
= BFD_RELOC_390_GOT64
;
896 else if (suffix
== ELF_SUFFIX_PLT
)
899 reloc
= BFD_RELOC_390_PLT32
;
900 else if (nbytes
== 8)
901 reloc
= BFD_RELOC_390_PLT64
;
904 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
905 as_bad (_("Invalid suffix for literal pool entry"));
907 /* Search the pool if the new entry is a duplicate. */
908 if (exp_p
->X_op
== O_big
)
910 /* Special processing for big numbers. */
911 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
913 if (lpe
->ex
.X_op
== O_big
)
915 if (exp_p
->X_add_number
<= 0 && lpe
->ex
.X_add_number
<= 0)
917 if (memcmp (&generic_floating_point_number
, &lpe
->floatnum
,
918 sizeof (FLONUM_TYPE
)) == 0)
921 else if (exp_p
->X_add_number
== lpe
->ex
.X_add_number
)
923 if (memcmp (generic_bignum
, lpe
->bignum
,
924 sizeof (LITTLENUM_TYPE
)*exp_p
->X_add_number
) == 0)
932 /* Processing for 'normal' data types. */
933 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
934 if (lpe
->nbytes
== nbytes
&& lpe
->reloc
== reloc
935 && s390_exp_compare (exp_p
, &lpe
->ex
) != 0)
942 if (lpe_free_list
!= NULL
)
945 lpe_free_list
= lpe_free_list
->next
;
949 lpe
= (struct s390_lpe
*) xmalloc (sizeof (struct s390_lpe
));
954 if (exp_p
->X_op
== O_big
)
956 if (exp_p
->X_add_number
<= 0)
957 lpe
->floatnum
= generic_floating_point_number
;
958 else if (exp_p
->X_add_number
<= 4)
959 memcpy (lpe
->bignum
, generic_bignum
,
960 exp_p
->X_add_number
* sizeof (LITTLENUM_TYPE
));
962 as_bad (_("Big number is too big"));
965 lpe
->nbytes
= nbytes
;
967 /* Literal pool name defined ? */
970 sprintf (tmp_name
, ".L\001%i", lp_count
);
971 lp_sym
= symbol_make (tmp_name
);
974 /* Make name for literal pool entry. */
975 sprintf (tmp_name
, ".L\001%i\002%i", lp_count
, lpe_count
);
977 lpe
->sym
= symbol_make (tmp_name
);
979 /* Add to literal pool list. */
981 if (lpe_list_tail
!= NULL
)
983 lpe_list_tail
->next
= lpe
;
987 lpe_list
= lpe_list_tail
= lpe
;
990 /* Now change exp_p to the offset into the literal pool.
991 Thats the expression: .L^Ax^By-.L^Ax */
992 exp_p
->X_add_symbol
= lpe
->sym
;
993 exp_p
->X_op_symbol
= lp_sym
;
994 exp_p
->X_op
= O_subtract
;
995 exp_p
->X_add_number
= 0;
999 /* We change the suffix type to ELF_SUFFIX_NONE, because
1000 the difference of two local labels is just a number. */
1001 return ELF_SUFFIX_NONE
;
1004 /* Like normal .long/.short/.word, except support @got, etc.
1005 clobbers input_line_pointer, checks end-of-line. */
1007 s390_elf_cons (nbytes
)
1008 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
1011 elf_suffix_type suffix
;
1013 if (is_it_end_of_statement ())
1015 demand_empty_rest_of_line ();
1023 if (exp
.X_op
== O_symbol
1024 && *input_line_pointer
== '@'
1025 && (suffix
= s390_elf_suffix (&input_line_pointer
, &exp
)) != ELF_SUFFIX_NONE
)
1027 bfd_reloc_code_real_type reloc
;
1028 reloc_howto_type
*reloc_howto
;
1034 static bfd_reloc_code_real_type tab2
[] =
1036 [ELF_SUFFIX_NONE
] BFD_RELOC_UNUSED
,
1037 [ELF_SUFFIX_GOT
] BFD_RELOC_390_GOT16
,
1038 [ELF_SUFFIX_PLT
] BFD_RELOC_UNUSED
,
1039 [ELF_SUFFIX_GOTENT
] BFD_RELOC_UNUSED
,
1040 [ELF_SUFFIX_GOTOFF
] BFD_RELOC_16_GOTOFF
,
1041 [ELF_SUFFIX_GOTPLT
] BFD_RELOC_UNUSED
,
1042 [ELF_SUFFIX_PLTOFF
] BFD_RELOC_390_PLTOFF16
,
1043 [ELF_SUFFIX_TLS_GD
] BFD_RELOC_UNUSED
,
1044 [ELF_SUFFIX_TLS_GOTIE
] BFD_RELOC_UNUSED
,
1045 [ELF_SUFFIX_TLS_IE
] BFD_RELOC_UNUSED
,
1046 [ELF_SUFFIX_TLS_LDM
] BFD_RELOC_UNUSED
,
1047 [ELF_SUFFIX_TLS_LDO
] BFD_RELOC_UNUSED
,
1048 [ELF_SUFFIX_TLS_LE
] BFD_RELOC_UNUSED
,
1050 reloc
= tab2
[suffix
];
1052 else if (nbytes
== 4)
1054 static bfd_reloc_code_real_type tab4
[] =
1056 [ELF_SUFFIX_NONE
] BFD_RELOC_UNUSED
,
1057 [ELF_SUFFIX_GOT
] BFD_RELOC_32_GOT_PCREL
,
1058 [ELF_SUFFIX_PLT
] BFD_RELOC_390_PLT32
,
1059 [ELF_SUFFIX_GOTENT
] BFD_RELOC_UNUSED
,
1060 [ELF_SUFFIX_GOTOFF
] BFD_RELOC_32_GOTOFF
,
1061 [ELF_SUFFIX_GOTPLT
] BFD_RELOC_390_GOTPLT32
,
1062 [ELF_SUFFIX_PLTOFF
] BFD_RELOC_390_PLTOFF32
,
1063 [ELF_SUFFIX_TLS_GD
] BFD_RELOC_390_TLS_GD32
,
1064 [ELF_SUFFIX_TLS_GOTIE
] BFD_RELOC_390_TLS_GOTIE32
,
1065 [ELF_SUFFIX_TLS_IE
] BFD_RELOC_390_TLS_IE32
,
1066 [ELF_SUFFIX_TLS_LDM
] BFD_RELOC_390_TLS_LDM32
,
1067 [ELF_SUFFIX_TLS_LDO
] BFD_RELOC_390_TLS_LDO32
,
1068 [ELF_SUFFIX_TLS_LE
] BFD_RELOC_390_TLS_LE32
,
1070 reloc
= tab4
[suffix
];
1072 else if (nbytes
== 8)
1074 static bfd_reloc_code_real_type tab8
[] =
1076 [ELF_SUFFIX_NONE
] BFD_RELOC_UNUSED
,
1077 [ELF_SUFFIX_GOT
] BFD_RELOC_390_GOT64
,
1078 [ELF_SUFFIX_PLT
] BFD_RELOC_390_PLT64
,
1079 [ELF_SUFFIX_GOTENT
] BFD_RELOC_UNUSED
,
1080 [ELF_SUFFIX_GOTOFF
] BFD_RELOC_390_GOTOFF64
,
1081 [ELF_SUFFIX_GOTPLT
] BFD_RELOC_390_GOTPLT64
,
1082 [ELF_SUFFIX_PLTOFF
] BFD_RELOC_390_PLTOFF64
,
1083 [ELF_SUFFIX_TLS_GD
] BFD_RELOC_390_TLS_GD64
,
1084 [ELF_SUFFIX_TLS_GOTIE
] BFD_RELOC_390_TLS_GOTIE64
,
1085 [ELF_SUFFIX_TLS_IE
] BFD_RELOC_390_TLS_IE64
,
1086 [ELF_SUFFIX_TLS_LDM
] BFD_RELOC_390_TLS_LDM64
,
1087 [ELF_SUFFIX_TLS_LDO
] BFD_RELOC_390_TLS_LDO64
,
1088 [ELF_SUFFIX_TLS_LE
] BFD_RELOC_390_TLS_LE64
,
1090 reloc
= tab8
[suffix
];
1093 reloc
= BFD_RELOC_UNUSED
;
1095 if (reloc
!= BFD_RELOC_UNUSED
1096 && (reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
)))
1098 size
= bfd_get_reloc_size (reloc_howto
);
1100 as_bad (_("%s relocations do not fit in %d bytes"),
1101 reloc_howto
->name
, nbytes
);
1102 where
= frag_more (nbytes
);
1103 md_number_to_chars (where
, 0, size
);
1104 /* To make fixup_segment do the pc relative conversion the
1105 pcrel parameter on the fix_new_exp call needs to be FALSE. */
1106 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1107 size
, &exp
, FALSE
, reloc
);
1110 as_bad (_("relocation not applicable"));
1113 emit_expr (&exp
, (unsigned int) nbytes
);
1115 while (*input_line_pointer
++ == ',');
1117 input_line_pointer
--; /* Put terminator back into stream. */
1118 demand_empty_rest_of_line ();
1121 /* We need to keep a list of fixups. We can't simply generate them as
1122 we go, because that would require us to first create the frag, and
1123 that would screw up references to ``.''. */
1129 bfd_reloc_code_real_type reloc
;
1132 #define MAX_INSN_FIXUPS (4)
1134 /* This routine is called for each instruction to be assembled. */
1137 md_gather_operands (str
, insn
, opcode
)
1139 unsigned char *insn
;
1140 const struct s390_opcode
*opcode
;
1142 struct s390_fixup fixups
[MAX_INSN_FIXUPS
];
1143 const struct s390_operand
*operand
;
1144 const unsigned char *opindex_ptr
;
1146 elf_suffix_type suffix
;
1147 bfd_reloc_code_real_type reloc
;
1153 while (ISSPACE (*str
))
1159 /* Gather the operands. */
1161 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1165 operand
= s390_operands
+ *opindex_ptr
;
1167 if (skip_optional
&& (operand
->flags
& S390_OPERAND_INDEX
))
1169 /* We do an early skip. For D(X,B) constructions the index
1170 register is skipped (X is optional). For D(L,B) the base
1171 register will be the skipped operand, because L is NOT
1177 /* Gather the operand. */
1178 hold
= input_line_pointer
;
1179 input_line_pointer
= str
;
1181 /* Parse the operand. */
1182 if (! register_name (&ex
))
1185 str
= input_line_pointer
;
1186 input_line_pointer
= hold
;
1188 /* Write the operand to the insn. */
1189 if (ex
.X_op
== O_illegal
)
1190 as_bad (_("illegal operand"));
1191 else if (ex
.X_op
== O_absent
)
1192 as_bad (_("missing operand"));
1193 else if (ex
.X_op
== O_register
|| ex
.X_op
== O_constant
)
1195 s390_lit_suffix (&str
, &ex
, ELF_SUFFIX_NONE
);
1197 if (ex
.X_op
!= O_register
&& ex
.X_op
!= O_constant
)
1199 /* We need to generate a fixup for the
1200 expression returned by s390_lit_suffix. */
1201 if (fc
>= MAX_INSN_FIXUPS
)
1202 as_fatal (_("too many fixups"));
1203 fixups
[fc
].exp
= ex
;
1204 fixups
[fc
].opindex
= *opindex_ptr
;
1205 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
1210 if ((operand
->flags
& S390_OPERAND_INDEX
)
1211 && ex
.X_add_number
== 0
1213 as_warn ("index register specified but zero");
1214 if ((operand
->flags
& S390_OPERAND_BASE
)
1215 && ex
.X_add_number
== 0
1217 as_warn ("base register specified but zero");
1218 s390_insert_operand (insn
, operand
, ex
.X_add_number
, NULL
, 0);
1223 suffix
= s390_elf_suffix (&str
, &ex
);
1224 suffix
= s390_lit_suffix (&str
, &ex
, suffix
);
1225 reloc
= BFD_RELOC_UNUSED
;
1227 if (suffix
== ELF_SUFFIX_GOT
)
1229 if (operand
->flags
& S390_OPERAND_DISP
)
1230 reloc
= BFD_RELOC_390_GOT12
;
1231 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1232 && (operand
->bits
== 16))
1233 reloc
= BFD_RELOC_390_GOT16
;
1234 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1235 && (operand
->bits
== 32))
1236 reloc
= BFD_RELOC_390_GOTENT
;
1238 else if (suffix
== ELF_SUFFIX_PLT
)
1240 if ((operand
->flags
& S390_OPERAND_PCREL
)
1241 && (operand
->bits
== 16))
1242 reloc
= BFD_RELOC_390_PLT16DBL
;
1243 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1244 && (operand
->bits
== 32))
1245 reloc
= BFD_RELOC_390_PLT32DBL
;
1247 else if (suffix
== ELF_SUFFIX_GOTENT
)
1249 if ((operand
->flags
& S390_OPERAND_PCREL
)
1250 && (operand
->bits
== 32))
1251 reloc
= BFD_RELOC_390_GOTENT
;
1253 else if (suffix
== ELF_SUFFIX_GOTOFF
)
1255 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1256 && (operand
->bits
== 16))
1257 reloc
= BFD_RELOC_16_GOTOFF
;
1259 else if (suffix
== ELF_SUFFIX_PLTOFF
)
1261 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1262 && (operand
->bits
== 16))
1263 reloc
= BFD_RELOC_390_PLTOFF16
;
1265 else if (suffix
== ELF_SUFFIX_GOTPLT
)
1267 if ((operand
->flags
& S390_OPERAND_DISP
)
1268 && (operand
->bits
== 12))
1269 reloc
= BFD_RELOC_390_GOTPLT12
;
1270 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1271 && (operand
->bits
== 16))
1272 reloc
= BFD_RELOC_390_GOTPLT16
;
1273 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1274 && (operand
->bits
== 32))
1275 reloc
= BFD_RELOC_390_GOTPLTENT
;
1277 else if (suffix
== ELF_SUFFIX_TLS_GOTIE
)
1279 if ((operand
->flags
& S390_OPERAND_DISP
)
1280 && (operand
->bits
== 12))
1281 reloc
= BFD_RELOC_390_TLS_GOTIE12
;
1283 else if (suffix
== ELF_SUFFIX_TLS_IE
)
1285 if ((operand
->flags
& S390_OPERAND_PCREL
)
1286 && (operand
->bits
== 32))
1287 reloc
= BFD_RELOC_390_TLS_IEENT
;
1290 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
1291 as_bad (_("invalid operand suffix"));
1292 /* We need to generate a fixup of type 'reloc' for this
1294 if (fc
>= MAX_INSN_FIXUPS
)
1295 as_fatal (_("too many fixups"));
1296 fixups
[fc
].exp
= ex
;
1297 fixups
[fc
].opindex
= *opindex_ptr
;
1298 fixups
[fc
].reloc
= reloc
;
1302 /* Check the next character. The call to expression has advanced
1303 str past any whitespace. */
1304 if (operand
->flags
& S390_OPERAND_DISP
)
1306 /* After a displacement a block in parentheses can start. */
1309 /* Check if parethesed block can be skipped. If the next
1310 operand is neiter an optional operand nor a base register
1311 then we have a syntax error. */
1312 operand
= s390_operands
+ *(++opindex_ptr
);
1313 if (!(operand
->flags
& (S390_OPERAND_INDEX
|S390_OPERAND_BASE
)))
1314 as_bad (_("syntax error; missing '(' after displacement"));
1316 /* Ok, skip all operands until S390_OPERAND_BASE. */
1317 while (!(operand
->flags
& S390_OPERAND_BASE
))
1318 operand
= s390_operands
+ *(++opindex_ptr
);
1320 /* If there is a next operand it must be seperated by a comma. */
1321 if (opindex_ptr
[1] != '\0')
1324 as_bad (_("syntax error; expected ,"));
1329 /* We found an opening parentheses. */
1331 for (f
= str
; *f
!= '\0'; f
++)
1332 if (*f
== ',' || *f
== ')')
1334 /* If there is no comma until the closing parentheses OR
1335 there is a comma right after the opening parentheses,
1336 we have to skip optional operands. */
1337 if (*f
== ',' && f
== str
)
1339 /* comma directly after '(' ? */
1344 skip_optional
= (*f
!= ',');
1347 else if (operand
->flags
& S390_OPERAND_BASE
)
1349 /* After the base register the parenthesed block ends. */
1351 as_bad (_("syntax error; missing ')' after base register"));
1353 /* If there is a next operand it must be seperated by a comma. */
1354 if (opindex_ptr
[1] != '\0')
1357 as_bad (_("syntax error; expected ,"));
1362 /* We can find an 'early' closing parentheses in e.g. D(L) instead
1363 of D(L,B). In this case the base register has to be skipped. */
1366 operand
= s390_operands
+ *(++opindex_ptr
);
1368 if (!(operand
->flags
& S390_OPERAND_BASE
))
1369 as_bad (_("syntax error; ')' not allowed here"));
1372 /* If there is a next operand it must be seperated by a comma. */
1373 if (opindex_ptr
[1] != '\0')
1376 as_bad (_("syntax error; expected ,"));
1381 while (ISSPACE (*str
))
1384 /* Check for tls instruction marker. */
1385 reloc
= s390_tls_suffix (&str
, &ex
);
1386 if (reloc
!= BFD_RELOC_UNUSED
)
1388 /* We need to generate a fixup of type 'reloc' for this
1390 if (fc
>= MAX_INSN_FIXUPS
)
1391 as_fatal (_("too many fixups"));
1392 fixups
[fc
].exp
= ex
;
1393 fixups
[fc
].opindex
= -1;
1394 fixups
[fc
].reloc
= reloc
;
1402 if ((linefeed
= strchr (str
, '\n')) != NULL
)
1404 as_bad (_("junk at end of line: `%s'"), str
);
1405 if (linefeed
!= NULL
)
1409 /* Write out the instruction. */
1410 f
= frag_more (opcode
->oplen
);
1411 memcpy (f
, insn
, opcode
->oplen
);
1412 dwarf2_emit_insn (opcode
->oplen
);
1414 /* Create any fixups. At this point we do not use a
1415 bfd_reloc_code_real_type, but instead just use the
1416 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1417 handle fixups for any operand type, although that is admittedly
1418 not a very exciting feature. We pick a BFD reloc type in
1420 for (i
= 0; i
< fc
; i
++)
1423 if (fixups
[i
].opindex
< 0)
1425 /* Create tls instruction marker relocation. */
1426 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, opcode
->oplen
,
1427 &fixups
[i
].exp
, 0, fixups
[i
].reloc
);
1431 operand
= s390_operands
+ fixups
[i
].opindex
;
1433 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
1435 reloc_howto_type
*reloc_howto
;
1439 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
1443 size
= bfd_get_reloc_size (reloc_howto
);
1445 if (size
< 1 || size
> 4)
1448 fixP
= fix_new_exp (frag_now
,
1449 f
- frag_now
->fr_literal
+ (operand
->shift
/8),
1450 size
, &fixups
[i
].exp
, reloc_howto
->pc_relative
,
1452 /* Turn off overflow checking in fixup_segment. This is necessary
1453 because fixup_segment will signal an overflow for large 4 byte
1454 quantities for GOT12 relocations. */
1455 if ( fixups
[i
].reloc
== BFD_RELOC_390_GOT12
1456 || fixups
[i
].reloc
== BFD_RELOC_390_GOT16
)
1457 fixP
->fx_no_overflow
= 1;
1460 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4, &fixups
[i
].exp
,
1461 (operand
->flags
& S390_OPERAND_PCREL
) != 0,
1462 ((bfd_reloc_code_real_type
)
1463 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
1468 /* This routine is called for each instruction to be assembled. */
1474 const struct s390_opcode
*opcode
;
1475 unsigned char insn
[6];
1478 /* Get the opcode. */
1479 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1484 /* Look up the opcode in the hash table. */
1485 opcode
= (struct s390_opcode
*) hash_find (s390_opcode_hash
, str
);
1486 if (opcode
== (const struct s390_opcode
*) NULL
)
1488 as_bad (_("Unrecognized opcode: `%s'"), str
);
1491 else if (!(opcode
->architecture
& current_arch_mask
))
1493 as_bad ("Opcode %s not available in this architecture", str
);
1497 memcpy (insn
, opcode
->opcode
, sizeof (insn
));
1498 md_gather_operands (s
, insn
, opcode
);
1501 #ifndef WORKING_DOT_WORD
1502 /* Handle long and short jumps. We don't support these */
1504 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1506 addressT from_addr
, to_addr
;
1514 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1516 addressT from_addr
, to_addr
;
1526 int ignore ATTRIBUTE_UNUSED
;
1528 /* We don't support putting frags in the BSS segment, we fake it
1529 by marking in_bss, then looking at s_skip for clues. */
1531 subseg_set (bss_section
, 0);
1532 demand_empty_rest_of_line ();
1535 /* Pseudo-op handling. */
1539 int ignore ATTRIBUTE_UNUSED
;
1542 const struct s390_opcode
*opformat
;
1543 unsigned char insn
[6];
1546 /* Get the opcode format. */
1547 s
= input_line_pointer
;
1548 while (*s
!= '\0' && *s
!= ',' && ! ISSPACE (*s
))
1551 as_bad (_("Invalid .insn format\n"));
1554 /* Look up the opcode in the hash table. */
1555 opformat
= (struct s390_opcode
*)
1556 hash_find (s390_opformat_hash
, input_line_pointer
);
1557 if (opformat
== (const struct s390_opcode
*) NULL
)
1559 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer
);
1562 input_line_pointer
= s
;
1564 if (exp
.X_op
== O_constant
)
1566 if ( (opformat
->oplen
== 6 && exp
.X_op
> 0 && exp
.X_op
< (1ULL << 48))
1567 || (opformat
->oplen
== 4 && exp
.X_op
> 0 && exp
.X_op
< (1ULL << 32))
1568 || (opformat
->oplen
== 2 && exp
.X_op
> 0 && exp
.X_op
< (1ULL << 16)))
1569 md_number_to_chars (insn
, exp
.X_add_number
, opformat
->oplen
);
1571 as_bad (_("Invalid .insn format\n"));
1573 else if (exp
.X_op
== O_big
)
1575 if (exp
.X_add_number
> 0
1576 && opformat
->oplen
== 6
1577 && generic_bignum
[3] == 0)
1579 md_number_to_chars (insn
, generic_bignum
[2], 2);
1580 md_number_to_chars (&insn
[2], generic_bignum
[1], 2);
1581 md_number_to_chars (&insn
[4], generic_bignum
[0], 2);
1584 as_bad (_("Invalid .insn format\n"));
1587 as_bad (_("second operand of .insn not a constant\n"));
1589 if (strcmp (opformat
->name
, "e") != 0 && *input_line_pointer
++ != ',')
1590 as_bad (_("missing comma after insn constant\n"));
1592 if ((s
= strchr (input_line_pointer
, '\n')) != NULL
)
1594 input_line_pointer
= md_gather_operands (input_line_pointer
, insn
,
1598 demand_empty_rest_of_line ();
1601 /* The .byte pseudo-op. This is similar to the normal .byte
1602 pseudo-op, but it can also take a single ASCII string. */
1606 int ignore ATTRIBUTE_UNUSED
;
1608 if (*input_line_pointer
!= '\"')
1614 /* Gather characters. A real double quote is doubled. Unusual
1615 characters are not permitted. */
1616 ++input_line_pointer
;
1621 c
= *input_line_pointer
++;
1625 if (*input_line_pointer
!= '\"')
1627 ++input_line_pointer
;
1630 FRAG_APPEND_1_CHAR (c
);
1633 demand_empty_rest_of_line ();
1636 /* The .ltorg pseudo-op.This emits all literals defined since the last
1637 .ltorg or the invocation of gas. Literals are defined with the
1641 s390_literals (ignore
)
1642 int ignore ATTRIBUTE_UNUSED
;
1644 struct s390_lpe
*lpe
;
1646 if (lp_sym
== NULL
|| lpe_count
== 0)
1647 return; /* Nothing to be done. */
1649 /* Emit symbol for start of literal pool. */
1650 S_SET_SEGMENT (lp_sym
, now_seg
);
1651 S_SET_VALUE (lp_sym
, (valueT
) frag_now_fix ());
1652 lp_sym
->sy_frag
= frag_now
;
1657 lpe_list
= lpe_list
->next
;
1658 S_SET_SEGMENT (lpe
->sym
, now_seg
);
1659 S_SET_VALUE (lpe
->sym
, (valueT
) frag_now_fix ());
1660 lpe
->sym
->sy_frag
= frag_now
;
1662 /* Emit literal pool entry. */
1663 if (lpe
->reloc
!= BFD_RELOC_UNUSED
)
1665 reloc_howto_type
*reloc_howto
=
1666 bfd_reloc_type_lookup (stdoutput
, lpe
->reloc
);
1667 int size
= bfd_get_reloc_size (reloc_howto
);
1670 if (size
> lpe
->nbytes
)
1671 as_bad (_("%s relocations do not fit in %d bytes"),
1672 reloc_howto
->name
, lpe
->nbytes
);
1673 where
= frag_more (lpe
->nbytes
);
1674 md_number_to_chars (where
, 0, size
);
1675 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1676 size
, &lpe
->ex
, reloc_howto
->pc_relative
, lpe
->reloc
);
1680 if (lpe
->ex
.X_op
== O_big
)
1682 if (lpe
->ex
.X_add_number
<= 0)
1683 generic_floating_point_number
= lpe
->floatnum
;
1685 memcpy (generic_bignum
, lpe
->bignum
,
1686 lpe
->ex
.X_add_number
* sizeof (LITTLENUM_TYPE
));
1688 emit_expr (&lpe
->ex
, lpe
->nbytes
);
1691 lpe
->next
= lpe_free_list
;
1692 lpe_free_list
= lpe
;
1694 lpe_list_tail
= NULL
;
1700 /* Turn a string in input_line_pointer into a floating point constant
1701 of type type, and store the appropriate bytes in *litp. The number
1702 of LITTLENUMS emitted is stored in *sizep . An error message is
1703 returned, or NULL on OK. */
1706 md_atof (type
, litp
, sizep
)
1712 LITTLENUM_TYPE words
[4];
1728 return "bad call to md_atof";
1731 t
= atof_ieee (input_line_pointer
, type
, words
);
1733 input_line_pointer
= t
;
1737 for (i
= 0; i
< prec
; i
++)
1739 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
1746 /* Align a section (I don't know why this is machine dependent). */
1749 md_section_align (seg
, addr
)
1753 int align
= bfd_get_section_alignment (stdoutput
, seg
);
1755 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
1758 /* We don't have any form of relaxing. */
1761 md_estimate_size_before_relax (fragp
, seg
)
1762 fragS
*fragp ATTRIBUTE_UNUSED
;
1763 asection
*seg ATTRIBUTE_UNUSED
;
1769 /* Convert a machine dependent frag. We never generate these. */
1772 md_convert_frag (abfd
, sec
, fragp
)
1773 bfd
*abfd ATTRIBUTE_UNUSED
;
1774 asection
*sec ATTRIBUTE_UNUSED
;
1775 fragS
*fragp ATTRIBUTE_UNUSED
;
1781 md_undefined_symbol (name
)
1784 if (*name
== '_' && *(name
+ 1) == 'G'
1785 && strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
1789 if (symbol_find (name
))
1790 as_bad (_("GOT already in symbol table"));
1791 GOT_symbol
= symbol_new (name
, undefined_section
,
1792 (valueT
) 0, &zero_address_frag
);
1799 /* Functions concerning relocs. */
1801 /* The location from which a PC relative jump should be calculated,
1802 given a PC relative reloc. */
1805 md_pcrel_from_section (fixp
, sec
)
1807 segT sec ATTRIBUTE_UNUSED
;
1809 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
1812 /* Here we decide which fixups can be adjusted to make them relative to
1813 the beginning of the section instead of the symbol. Basically we need
1814 to make sure that the dynamic relocations are done correctly, so in
1815 some cases we force the original symbol to be used. */
1817 tc_s390_fix_adjustable (fixP
)
1820 /* Don't adjust references to merge sections. */
1821 if ((S_GET_SEGMENT (fixP
->fx_addsy
)->flags
& SEC_MERGE
) != 0)
1823 /* adjust_reloc_syms doesn't know about the GOT. */
1824 if ( fixP
->fx_r_type
== BFD_RELOC_16_GOTOFF
1825 || fixP
->fx_r_type
== BFD_RELOC_32_GOTOFF
1826 || fixP
->fx_r_type
== BFD_RELOC_390_GOTOFF64
1827 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF16
1828 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF32
1829 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF64
1830 || fixP
->fx_r_type
== BFD_RELOC_390_PLT16DBL
1831 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32
1832 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32DBL
1833 || fixP
->fx_r_type
== BFD_RELOC_390_PLT64
1834 || fixP
->fx_r_type
== BFD_RELOC_390_GOT12
1835 || fixP
->fx_r_type
== BFD_RELOC_390_GOT16
1836 || fixP
->fx_r_type
== BFD_RELOC_32_GOT_PCREL
1837 || fixP
->fx_r_type
== BFD_RELOC_390_GOT64
1838 || fixP
->fx_r_type
== BFD_RELOC_390_GOTENT
1839 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT12
1840 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT16
1841 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT32
1842 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT64
1843 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLTENT
1844 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LOAD
1845 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GDCALL
1846 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDCALL
1847 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD32
1848 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD64
1849 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE12
1850 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE32
1851 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE64
1852 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM32
1853 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM64
1854 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE32
1855 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE64
1856 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IEENT
1857 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE32
1858 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE64
1859 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO32
1860 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO64
1861 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPMOD
1862 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPOFF
1863 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_TPOFF
1864 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
1865 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
1870 /* Return true if we must always emit a reloc for a type and false if
1871 there is some hope of resolving it at assembly time. */
1873 tc_s390_force_relocation (fixp
)
1876 /* Ensure we emit a relocation for every reference to the global
1877 offset table or to the procedure link table. */
1878 switch (fixp
->fx_r_type
)
1880 case BFD_RELOC_390_GOT12
:
1881 case BFD_RELOC_32_GOT_PCREL
:
1882 case BFD_RELOC_32_GOTOFF
:
1883 case BFD_RELOC_390_GOTOFF64
:
1884 case BFD_RELOC_390_PLTOFF16
:
1885 case BFD_RELOC_390_PLTOFF32
:
1886 case BFD_RELOC_390_PLTOFF64
:
1887 case BFD_RELOC_390_GOTPC
:
1888 case BFD_RELOC_390_GOT16
:
1889 case BFD_RELOC_390_GOTPCDBL
:
1890 case BFD_RELOC_390_GOT64
:
1891 case BFD_RELOC_390_GOTENT
:
1892 case BFD_RELOC_390_PLT32
:
1893 case BFD_RELOC_390_PLT16DBL
:
1894 case BFD_RELOC_390_PLT32DBL
:
1895 case BFD_RELOC_390_PLT64
:
1896 case BFD_RELOC_390_GOTPLT12
:
1897 case BFD_RELOC_390_GOTPLT16
:
1898 case BFD_RELOC_390_GOTPLT32
:
1899 case BFD_RELOC_390_GOTPLT64
:
1900 case BFD_RELOC_390_GOTPLTENT
:
1906 return generic_force_reloc (fixp
);
1909 /* Apply a fixup to the object code. This is called for all the
1910 fixups we generated by the call to fix_new_exp, above. In the call
1911 above we used a reloc code which was the largest legal reloc code
1912 plus the operand index. Here we undo that to recover the operand
1913 index. At this point all symbol values should be fully resolved,
1914 and we attempt to completely resolve the reloc. If we can not do
1915 that, we determine the correct reloc code and put it back in the
1919 md_apply_fix3 (fixP
, valP
, seg
)
1922 segT seg ATTRIBUTE_UNUSED
;
1925 valueT value
= *valP
;
1927 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
1929 if (fixP
->fx_subsy
!= NULL
)
1930 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1931 "cannot emit relocation %s against subsy symbol %s",
1932 bfd_get_reloc_code_name (fixP
->fx_r_type
),
1933 S_GET_NAME (fixP
->fx_subsy
));
1935 if (fixP
->fx_addsy
!= NULL
)
1938 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
1943 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
1945 const struct s390_operand
*operand
;
1948 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
1949 operand
= &s390_operands
[opindex
];
1953 /* Insert the fully resolved operand value. */
1954 s390_insert_operand (where
, operand
, (offsetT
) value
,
1955 fixP
->fx_file
, fixP
->fx_line
);
1959 /* Determine a BFD reloc value based on the operand information.
1960 We are only prepared to turn a few of the operands into
1962 fixP
->fx_offset
= value
;
1963 if (operand
->bits
== 12 && operand
->shift
== 20)
1966 fixP
->fx_where
+= 2;
1967 fixP
->fx_r_type
= BFD_RELOC_390_12
;
1969 else if (operand
->bits
== 12 && operand
->shift
== 36)
1972 fixP
->fx_where
+= 4;
1973 fixP
->fx_r_type
= BFD_RELOC_390_12
;
1975 else if (operand
->bits
== 8 && operand
->shift
== 8)
1978 fixP
->fx_where
+= 1;
1979 fixP
->fx_r_type
= BFD_RELOC_8
;
1981 else if (operand
->bits
== 16 && operand
->shift
== 16)
1984 fixP
->fx_where
+= 2;
1985 if (operand
->flags
& S390_OPERAND_PCREL
)
1987 fixP
->fx_r_type
= BFD_RELOC_390_PC16DBL
;
1988 fixP
->fx_offset
+= 2;
1991 fixP
->fx_r_type
= BFD_RELOC_16
;
1993 else if (operand
->bits
== 32 && operand
->shift
== 16
1994 && (operand
->flags
& S390_OPERAND_PCREL
))
1997 fixP
->fx_where
+= 2;
1998 fixP
->fx_offset
+= 2;
1999 fixP
->fx_r_type
= BFD_RELOC_390_PC32DBL
;
2006 /* Use expr_symbol_where to see if this is an expression
2008 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
2009 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2010 _("unresolved expression that must be resolved"));
2012 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2013 _("unsupported relocation type"));
2020 switch (fixP
->fx_r_type
)
2026 md_number_to_chars (where
, value
, 1);
2028 case BFD_RELOC_390_12
:
2029 case BFD_RELOC_390_GOT12
:
2030 case BFD_RELOC_390_GOTPLT12
:
2035 mop
= bfd_getb16 ((unsigned char *) where
);
2036 mop
|= (unsigned short) (value
& 0xfff);
2037 bfd_putb16 ((bfd_vma
) mop
, (unsigned char *) where
);
2042 case BFD_RELOC_GPREL16
:
2043 case BFD_RELOC_16_GOT_PCREL
:
2044 case BFD_RELOC_16_GOTOFF
:
2046 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2047 "cannot emit PC relative %s relocation%s%s",
2048 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2049 fixP
->fx_addsy
!= NULL
? " against " : "",
2050 (fixP
->fx_addsy
!= NULL
2051 ? S_GET_NAME (fixP
->fx_addsy
)
2054 md_number_to_chars (where
, value
, 2);
2056 case BFD_RELOC_390_GOT16
:
2057 case BFD_RELOC_390_PLTOFF16
:
2058 case BFD_RELOC_390_GOTPLT16
:
2060 md_number_to_chars (where
, value
, 2);
2062 case BFD_RELOC_390_PC16DBL
:
2063 case BFD_RELOC_390_PLT16DBL
:
2066 md_number_to_chars (where
, (offsetT
) value
>> 1, 2);
2071 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2073 fixP
->fx_r_type
= BFD_RELOC_32
;
2075 md_number_to_chars (where
, value
, 4);
2077 case BFD_RELOC_32_PCREL
:
2078 case BFD_RELOC_32_BASEREL
:
2079 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2081 md_number_to_chars (where
, value
, 4);
2083 case BFD_RELOC_32_GOT_PCREL
:
2084 case BFD_RELOC_390_PLTOFF32
:
2085 case BFD_RELOC_390_PLT32
:
2086 case BFD_RELOC_390_GOTPLT32
:
2088 md_number_to_chars (where
, value
, 4);
2090 case BFD_RELOC_390_PC32DBL
:
2091 case BFD_RELOC_390_PLT32DBL
:
2092 case BFD_RELOC_390_GOTPCDBL
:
2093 case BFD_RELOC_390_GOTENT
:
2094 case BFD_RELOC_390_GOTPLTENT
:
2097 md_number_to_chars (where
, (offsetT
) value
>> 1, 4);
2100 case BFD_RELOC_32_GOTOFF
:
2102 md_number_to_chars (where
, value
, sizeof (int));
2105 case BFD_RELOC_390_GOTOFF64
:
2107 md_number_to_chars (where
, value
, 8);
2110 case BFD_RELOC_390_GOT64
:
2111 case BFD_RELOC_390_PLTOFF64
:
2112 case BFD_RELOC_390_PLT64
:
2113 case BFD_RELOC_390_GOTPLT64
:
2115 md_number_to_chars (where
, value
, 8);
2120 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2122 fixP
->fx_r_type
= BFD_RELOC_64
;
2124 md_number_to_chars (where
, value
, 8);
2127 case BFD_RELOC_64_PCREL
:
2128 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2130 md_number_to_chars (where
, value
, 8);
2133 case BFD_RELOC_VTABLE_INHERIT
:
2134 case BFD_RELOC_VTABLE_ENTRY
:
2138 case BFD_RELOC_390_TLS_LOAD
:
2139 case BFD_RELOC_390_TLS_GDCALL
:
2140 case BFD_RELOC_390_TLS_LDCALL
:
2141 case BFD_RELOC_390_TLS_GD32
:
2142 case BFD_RELOC_390_TLS_GD64
:
2143 case BFD_RELOC_390_TLS_GOTIE12
:
2144 case BFD_RELOC_390_TLS_GOTIE32
:
2145 case BFD_RELOC_390_TLS_GOTIE64
:
2146 case BFD_RELOC_390_TLS_LDM32
:
2147 case BFD_RELOC_390_TLS_LDM64
:
2148 case BFD_RELOC_390_TLS_IE32
:
2149 case BFD_RELOC_390_TLS_IE64
:
2150 case BFD_RELOC_390_TLS_LE32
:
2151 case BFD_RELOC_390_TLS_LE64
:
2152 case BFD_RELOC_390_TLS_LDO32
:
2153 case BFD_RELOC_390_TLS_LDO64
:
2154 case BFD_RELOC_390_TLS_DTPMOD
:
2155 case BFD_RELOC_390_TLS_DTPOFF
:
2156 case BFD_RELOC_390_TLS_TPOFF
:
2157 /* Fully resolved at link time. */
2159 case BFD_RELOC_390_TLS_IEENT
:
2160 /* Fully resolved at link time. */
2166 const char *reloc_name
= bfd_get_reloc_code_name (fixP
->fx_r_type
);
2168 if (reloc_name
!= NULL
)
2169 fprintf (stderr
, "Gas failure, reloc type %s\n", reloc_name
);
2171 fprintf (stderr
, "Gas failure, reloc type #%i\n", fixP
->fx_r_type
);
2177 fixP
->fx_offset
= value
;
2181 /* Generate a reloc for a fixup. */
2184 tc_gen_reloc (seg
, fixp
)
2185 asection
*seg ATTRIBUTE_UNUSED
;
2188 bfd_reloc_code_real_type code
;
2191 code
= fixp
->fx_r_type
;
2192 if (GOT_symbol
&& fixp
->fx_addsy
== GOT_symbol
)
2194 if ( (s390_arch_size
== 32 && code
== BFD_RELOC_32_PCREL
)
2195 || (s390_arch_size
== 64 && code
== BFD_RELOC_64_PCREL
))
2196 code
= BFD_RELOC_390_GOTPC
;
2197 if (code
== BFD_RELOC_390_PC32DBL
)
2198 code
= BFD_RELOC_390_GOTPCDBL
;
2201 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
2202 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
2203 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2204 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2205 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2206 if (reloc
->howto
== NULL
)
2208 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2209 _("cannot represent relocation type %s"),
2210 bfd_get_reloc_code_name (code
));
2211 /* Set howto to a garbage value so that we can keep going. */
2212 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
2213 assert (reloc
->howto
!= NULL
);
2215 reloc
->addend
= fixp
->fx_offset
;