1 /* tc-s390.c -- Assemble for the S390
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
4 Contributed by Martin Schwidefsky (schwidefsky@de.ibm.com).
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
24 #include "safe-ctype.h"
26 #include "struc-symbol.h"
27 #include "dwarf2dbg.h"
28 #include "dw2gencfi.h"
30 #include "opcode/s390.h"
33 /* The default architecture. */
35 #define DEFAULT_ARCH "s390"
37 static char *default_arch
= DEFAULT_ARCH
;
38 /* Either 32 or 64, selects file format. */
39 static int s390_arch_size
= 0;
41 static unsigned int current_mode_mask
= 0;
42 static unsigned int current_cpu
= -1U;
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 dwarf2 data alignment, adjusted for 32 or 64 bit. */
75 int s390_cie_data_alignment
;
77 /* The target specific pseudo-ops which we support. */
79 /* Define the prototypes for the pseudo-ops */
80 static void s390_byte
PARAMS ((int));
81 static void s390_elf_cons
PARAMS ((int));
82 static void s390_bss
PARAMS ((int));
83 static void s390_insn
PARAMS ((int));
84 static void s390_literals
PARAMS ((int));
86 const pseudo_typeS md_pseudo_table
[] =
88 { "align", s_align_bytes
, 0 },
89 /* Pseudo-ops which must be defined. */
90 { "bss", s390_bss
, 0 },
91 { "insn", s390_insn
, 0 },
92 /* Pseudo-ops which must be overridden. */
93 { "byte", s390_byte
, 0 },
94 { "short", s390_elf_cons
, 2 },
95 { "long", s390_elf_cons
, 4 },
96 { "quad", s390_elf_cons
, 8 },
97 { "ltorg", s390_literals
, 0 },
98 { "string", stringer
, 2 },
103 /* Structure to hold information about predefined registers. */
110 /* List of registers that are pre-defined:
112 Each access register has a predefined name of the form:
113 a<reg_num> which has the value <reg_num>.
115 Each control register has a predefined name of the form:
116 c<reg_num> which has the value <reg_num>.
118 Each general register has a predefined name of the form:
119 r<reg_num> which has the value <reg_num>.
121 Each floating point register a has predefined name of the form:
122 f<reg_num> which has the value <reg_num>.
124 There are individual registers as well:
128 The table is sorted. Suitable for searching by a binary search. */
130 static const struct pd_reg pre_defined_registers
[] =
132 { "a0", 0 }, /* Access registers */
149 { "c0", 0 }, /* Control registers */
166 { "f0", 0 }, /* Floating point registers */
183 { "lit", 13 }, /* Pointer to literal pool */
185 { "r0", 0 }, /* General purpose registers */
202 { "sp", 15 }, /* Stack pointer */
206 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
208 static int reg_name_search
209 PARAMS ((const struct pd_reg
*, int, const char *));
210 static bfd_boolean register_name
PARAMS ((expressionS
*));
211 static void init_default_arch
PARAMS ((void));
212 static void s390_insert_operand
213 PARAMS ((unsigned char *, const struct s390_operand
*, offsetT
, char *,
215 static char *md_gather_operands
216 PARAMS ((char *, unsigned char *, const struct s390_opcode
*));
218 /* Given NAME, find the register number associated with that name, return
219 the integer value associated with the given name or -1 on failure. */
222 reg_name_search (regs
, regcount
, name
)
223 const struct pd_reg
*regs
;
227 int middle
, low
, high
;
235 middle
= (low
+ high
) / 2;
236 cmp
= strcasecmp (name
, regs
[middle
].name
);
242 return regs
[middle
].value
;
251 * Summary of register_name().
253 * in: Input_line_pointer points to 1st char of operand.
255 * out: A expressionS.
256 * The operand may have been a register: in this case, X_op == O_register,
257 * X_add_number is set to the register number, and truth is returned.
258 * Input_line_pointer->(next non-blank) char after operand, or is in its
263 register_name (expressionP
)
264 expressionS
*expressionP
;
271 /* Find the spelling of the operand. */
272 start
= name
= input_line_pointer
;
273 if (name
[0] == '%' && ISALPHA (name
[1]))
274 name
= ++input_line_pointer
;
278 c
= get_symbol_end ();
279 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
281 /* Put back the delimiting char. */
282 *input_line_pointer
= c
;
284 /* Look to see if it's in the register table. */
287 expressionP
->X_op
= O_register
;
288 expressionP
->X_add_number
= reg_number
;
290 /* Make the rest nice. */
291 expressionP
->X_add_symbol
= NULL
;
292 expressionP
->X_op_symbol
= NULL
;
296 /* Reset the line as if we had not done anything. */
297 input_line_pointer
= start
;
301 /* Local variables. */
303 /* Opformat hash table. */
304 static struct hash_control
*s390_opformat_hash
;
306 /* Opcode hash table. */
307 static struct hash_control
*s390_opcode_hash
;
309 /* Flags to set in the elf header */
310 static flagword s390_flags
= 0;
312 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
314 #ifndef WORKING_DOT_WORD
315 int md_short_jump_size
= 4;
316 int md_long_jump_size
= 4;
319 const char *md_shortopts
= "A:m:kVQ:";
320 struct option md_longopts
[] = {
321 {NULL
, no_argument
, NULL
, 0}
323 size_t md_longopts_size
= sizeof (md_longopts
);
325 /* Initialize the default opcode arch and word size from the default
326 architecture name if not specified by an option. */
330 if (strcmp (default_arch
, "s390") == 0)
332 if (s390_arch_size
== 0)
335 else if (strcmp (default_arch
, "s390x") == 0)
337 if (s390_arch_size
== 0)
341 as_fatal ("Invalid default architecture, broken assembler.");
343 if (current_mode_mask
== 0)
345 if (s390_arch_size
== 32)
346 current_mode_mask
= 1 << S390_OPCODE_ESA
;
348 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
350 if (current_cpu
== -1U)
352 if (current_mode_mask
== (1 << S390_OPCODE_ESA
))
353 current_cpu
= S390_OPCODE_G5
;
355 current_cpu
= S390_OPCODE_Z900
;
359 /* Called by TARGET_FORMAT. */
361 s390_target_format ()
363 /* We don't get a chance to initialize anything before we're called,
364 so handle that now. */
365 init_default_arch ();
367 return s390_arch_size
== 64 ? "elf64-s390" : "elf32-s390";
371 md_parse_option (c
, arg
)
377 /* -k: Ignore for FreeBSD compatibility. */
381 if (arg
!= NULL
&& strcmp (arg
, "regnames") == 0)
384 else if (arg
!= NULL
&& strcmp (arg
, "no-regnames") == 0)
387 else if (arg
!= NULL
&& strcmp (arg
, "warn-areg-zero") == 0)
388 warn_areg_zero
= TRUE
;
390 else if (arg
!= NULL
&& strcmp (arg
, "31") == 0)
393 else if (arg
!= NULL
&& strcmp (arg
, "64") == 0)
396 else if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
397 current_mode_mask
= 1 << S390_OPCODE_ESA
;
399 else if (arg
!= NULL
&& strcmp (arg
, "zarch") == 0)
400 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
402 else if (arg
!= NULL
&& strncmp (arg
, "arch=", 5) == 0)
404 if (strcmp (arg
+ 5, "g5") == 0)
405 current_cpu
= S390_OPCODE_G5
;
406 else if (strcmp (arg
+ 5, "g6") == 0)
407 current_cpu
= S390_OPCODE_G6
;
408 else if (strcmp (arg
+ 5, "z900") == 0)
409 current_cpu
= S390_OPCODE_Z900
;
410 else if (strcmp (arg
+ 5, "z990") == 0)
411 current_cpu
= S390_OPCODE_Z990
;
412 else if (strcmp (arg
+ 5, "z9-109") == 0)
413 current_cpu
= S390_OPCODE_Z9_109
;
416 as_bad (_("invalid switch -m%s"), arg
);
423 as_bad (_("invalid switch -m%s"), arg
);
429 /* Option -A is deprecated. Still available for compatibility. */
430 if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
431 current_cpu
= S390_OPCODE_G5
;
432 else if (arg
!= NULL
&& strcmp (arg
, "esame") == 0)
433 current_cpu
= S390_OPCODE_Z900
;
435 as_bad ("invalid architecture -A%s", arg
);
438 /* -V: SVR4 argument to print version ID. */
443 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
444 should be emitted or not. FIXME: Not implemented. */
456 md_show_usage (stream
)
459 fprintf (stream
, _("\
461 -mregnames Allow symbolic names for registers\n\
462 -mwarn-areg-zero Warn about zero base/index registers\n\
463 -mno-regnames Do not allow symbolic names for registers\n\
464 -m31 Set file format to 31 bit format\n\
465 -m64 Set file format to 64 bit format\n"));
466 fprintf (stream
, _("\
467 -V print assembler version number\n\
468 -Qy, -Qn ignored\n"));
471 /* This function is called when the assembler starts up. It is called
472 after the options have been parsed and the output file has been
478 register const struct s390_opcode
*op
;
479 const struct s390_opcode
*op_end
;
480 bfd_boolean dup_insn
= FALSE
;
483 /* Give a warning if the combination -m64-bit and -Aesa is used. */
484 if (s390_arch_size
== 64 && current_cpu
< S390_OPCODE_Z900
)
485 as_warn ("The 64 bit file format is used without esame instructions.");
487 s390_cie_data_alignment
= -s390_arch_size
/ 8;
489 /* Set the ELF flags if desired. */
491 bfd_set_private_flags (stdoutput
, s390_flags
);
493 /* Insert the opcode formats into a hash table. */
494 s390_opformat_hash
= hash_new ();
496 op_end
= s390_opformats
+ s390_num_opformats
;
497 for (op
= s390_opformats
; op
< op_end
; op
++)
499 retval
= hash_insert (s390_opformat_hash
, op
->name
, (PTR
) op
);
500 if (retval
!= (const char *) NULL
)
502 as_bad (_("Internal assembler error for instruction format %s"),
508 /* Insert the opcodes into a hash table. */
509 s390_opcode_hash
= hash_new ();
511 op_end
= s390_opcodes
+ s390_num_opcodes
;
512 for (op
= s390_opcodes
; op
< op_end
; op
++)
513 if (op
->min_cpu
<= current_cpu
)
515 retval
= hash_insert (s390_opcode_hash
, op
->name
, (PTR
) op
);
516 if (retval
!= (const char *) NULL
)
518 as_bad (_("Internal assembler error for instruction %s"),
522 while (op
< op_end
- 1 && strcmp (op
->name
, op
[1].name
) == 0)
529 record_alignment (text_section
, 2);
530 record_alignment (data_section
, 2);
531 record_alignment (bss_section
, 2);
535 /* Called after all assembly has been done. */
539 if (s390_arch_size
== 64)
540 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_64
);
542 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_31
);
545 /* Insert an operand value into an instruction. */
548 s390_insert_operand (insn
, operand
, val
, file
, line
)
550 const struct s390_operand
*operand
;
558 if (operand
->flags
& (S390_OPERAND_SIGNED
|S390_OPERAND_PCREL
))
562 max
= ((offsetT
) 1 << (operand
->bits
- 1)) - 1;
563 min
= - ((offsetT
) 1 << (operand
->bits
- 1));
564 /* Halve PCREL operands. */
565 if (operand
->flags
& S390_OPERAND_PCREL
)
567 /* Check for underflow / overflow. */
568 if (val
< min
|| val
> max
)
571 "operand out of range (%s not between %ld and %ld)";
574 if (operand
->flags
& S390_OPERAND_PCREL
)
580 sprint_value (buf
, val
);
581 if (file
== (char *) NULL
)
582 as_bad (err
, buf
, (int) min
, (int) max
);
584 as_bad_where (file
, line
, err
, buf
, (int) min
, (int) max
);
587 /* val is ok, now restrict it to operand->bits bits. */
588 uval
= (addressT
) val
& ((((addressT
) 1 << (operand
->bits
-1)) << 1) - 1);
589 /* val is restrict, now check for special case. */
590 if (operand
->bits
== 20 && operand
->shift
== 20)
591 uval
= (uval
>> 12) | ((uval
& 0xfff) << 8);
597 max
= (((addressT
) 1 << (operand
->bits
- 1)) << 1) - 1;
599 uval
= (addressT
) val
;
600 /* Length x in an instructions has real length x+1. */
601 if (operand
->flags
& S390_OPERAND_LENGTH
)
603 /* Check for underflow / overflow. */
604 if (uval
< min
|| uval
> max
)
606 if (operand
->flags
& S390_OPERAND_LENGTH
)
613 as_bad_value_out_of_range (_("operand"), uval
, (offsetT
) min
, (offsetT
) max
, file
, line
);
619 /* Insert fragments of the operand byte for byte. */
620 offset
= operand
->shift
+ operand
->bits
;
621 uval
<<= (-offset
) & 7;
622 insn
+= (offset
- 1) / 8;
634 bfd_reloc_code_real_type reloc
;
637 static bfd_reloc_code_real_type s390_tls_suffix
638 PARAMS ((char **, expressionS
*));
640 /* Parse tls marker and return the desired relocation. */
641 static bfd_reloc_code_real_type
642 s390_tls_suffix (str_p
, exp_p
)
646 static struct map_tls mapping
[] =
648 { "tls_load", 8, BFD_RELOC_390_TLS_LOAD
},
649 { "tls_gdcall", 10, BFD_RELOC_390_TLS_GDCALL
},
650 { "tls_ldcall", 10, BFD_RELOC_390_TLS_LDCALL
},
651 { NULL
, 0, BFD_RELOC_UNUSED
}
661 return BFD_RELOC_UNUSED
;
664 while (ISIDNUM (*str
))
668 return BFD_RELOC_UNUSED
;
670 orig_line
= input_line_pointer
;
671 input_line_pointer
= str
;
673 str
= input_line_pointer
;
674 if (&input_line_pointer
!= str_p
)
675 input_line_pointer
= orig_line
;
677 if (exp_p
->X_op
!= O_symbol
)
678 return BFD_RELOC_UNUSED
;
680 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
681 if (len
== ptr
->length
682 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
684 /* Found a matching tls suffix. */
688 return BFD_RELOC_UNUSED
;
691 /* Structure used to hold suffixes. */
702 ELF_SUFFIX_TLS_GOTIE
,
714 elf_suffix_type suffix
;
717 static elf_suffix_type s390_elf_suffix
PARAMS ((char **, expressionS
*));
718 static int s390_exp_compare
PARAMS ((expressionS
*exp1
, expressionS
*exp2
));
719 static elf_suffix_type s390_lit_suffix
720 PARAMS ((char **, expressionS
*, elf_suffix_type
));
723 /* Parse @got/@plt/@gotoff. and return the desired relocation. */
724 static elf_suffix_type
725 s390_elf_suffix (str_p
, exp_p
)
729 static struct map_bfd mapping
[] =
731 { "got", 3, ELF_SUFFIX_GOT
},
732 { "got12", 5, ELF_SUFFIX_GOT
},
733 { "plt", 3, ELF_SUFFIX_PLT
},
734 { "gotent", 6, ELF_SUFFIX_GOTENT
},
735 { "gotoff", 6, ELF_SUFFIX_GOTOFF
},
736 { "gotplt", 6, ELF_SUFFIX_GOTPLT
},
737 { "pltoff", 6, ELF_SUFFIX_PLTOFF
},
738 { "tlsgd", 5, ELF_SUFFIX_TLS_GD
},
739 { "gotntpoff", 9, ELF_SUFFIX_TLS_GOTIE
},
740 { "indntpoff", 9, ELF_SUFFIX_TLS_IE
},
741 { "tlsldm", 6, ELF_SUFFIX_TLS_LDM
},
742 { "dtpoff", 6, ELF_SUFFIX_TLS_LDO
},
743 { "ntpoff", 6, ELF_SUFFIX_TLS_LE
},
744 { NULL
, 0, ELF_SUFFIX_NONE
}
753 return ELF_SUFFIX_NONE
;
756 while (ISALNUM (*str
))
760 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
761 if (len
== ptr
->length
762 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
764 if (exp_p
->X_add_number
!= 0)
765 as_warn (_("identifier+constant@%s means identifier@%s+constant"),
766 ptr
->string
, ptr
->string
);
767 /* Now check for identifier@suffix+constant. */
768 if (*str
== '-' || *str
== '+')
770 char *orig_line
= input_line_pointer
;
773 input_line_pointer
= str
;
774 expression (&new_exp
);
776 switch (new_exp
.X_op
)
778 case O_constant
: /* X_add_number (a constant expression). */
779 exp_p
->X_add_number
+= new_exp
.X_add_number
;
780 str
= input_line_pointer
;
782 case O_symbol
: /* X_add_symbol + X_add_number. */
783 /* this case is used for e.g. xyz@PLT+.Label. */
784 exp_p
->X_add_number
+= new_exp
.X_add_number
;
785 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
787 str
= input_line_pointer
;
789 case O_uminus
: /* (- X_add_symbol) + X_add_number. */
790 /* this case is used for e.g. xyz@PLT-.Label. */
791 exp_p
->X_add_number
+= new_exp
.X_add_number
;
792 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
793 exp_p
->X_op
= O_subtract
;
794 str
= input_line_pointer
;
800 /* If s390_elf_suffix has not been called with
801 &input_line_pointer as first parameter, we have
802 clobbered the input_line_pointer. We have to
804 if (&input_line_pointer
!= str_p
)
805 input_line_pointer
= orig_line
;
811 return BFD_RELOC_UNUSED
;
814 /* Structure used to hold a literal pool entry. */
817 struct s390_lpe
*next
;
819 FLONUM_TYPE floatnum
; /* used if X_op == O_big && X_add_number <= 0 */
820 LITTLENUM_TYPE bignum
[4]; /* used if X_op == O_big && X_add_number > 0 */
822 bfd_reloc_code_real_type reloc
;
826 static struct s390_lpe
*lpe_free_list
= NULL
;
827 static struct s390_lpe
*lpe_list
= NULL
;
828 static struct s390_lpe
*lpe_list_tail
= NULL
;
829 static symbolS
*lp_sym
= NULL
;
830 static int lp_count
= 0;
831 static int lpe_count
= 0;
834 s390_exp_compare (exp1
, exp2
)
838 if (exp1
->X_op
!= exp2
->X_op
)
843 case O_constant
: /* X_add_number must be equal. */
845 return exp1
->X_add_number
== exp2
->X_add_number
;
848 as_bad (_("Can't handle O_big in s390_exp_compare"));
850 case O_symbol
: /* X_add_symbol & X_add_number must be equal. */
855 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
856 && (exp1
->X_add_number
== exp2
->X_add_number
);
858 case O_multiply
: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
863 case O_bit_inclusive_or
:
865 case O_bit_exclusive_or
:
877 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
878 && (exp1
->X_op_symbol
== exp2
->X_op_symbol
)
879 && (exp1
->X_add_number
== exp2
->X_add_number
);
885 /* Test for @lit and if its present make an entry in the literal pool and
886 modify the current expression to be an offset into the literal pool. */
887 static elf_suffix_type
888 s390_lit_suffix (str_p
, exp_p
, suffix
)
891 elf_suffix_type suffix
;
893 bfd_reloc_code_real_type reloc
;
897 struct s390_lpe
*lpe
;
901 return suffix
; /* No modification. */
903 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
905 while (ISALNUM (*str
))
908 if (len
!= 4 || strncasecmp (ident
, "lit", 3) != 0
909 || (ident
[3]!='1' && ident
[3]!='2' && ident
[3]!='4' && ident
[3]!='8'))
910 return suffix
; /* no modification */
911 nbytes
= ident
[3] - '0';
913 reloc
= BFD_RELOC_UNUSED
;
914 if (suffix
== ELF_SUFFIX_GOT
)
917 reloc
= BFD_RELOC_390_GOT16
;
918 else if (nbytes
== 4)
919 reloc
= BFD_RELOC_32_GOT_PCREL
;
920 else if (nbytes
== 8)
921 reloc
= BFD_RELOC_390_GOT64
;
923 else if (suffix
== ELF_SUFFIX_PLT
)
926 reloc
= BFD_RELOC_390_PLT32
;
927 else if (nbytes
== 8)
928 reloc
= BFD_RELOC_390_PLT64
;
931 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
932 as_bad (_("Invalid suffix for literal pool entry"));
934 /* Search the pool if the new entry is a duplicate. */
935 if (exp_p
->X_op
== O_big
)
937 /* Special processing for big numbers. */
938 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
940 if (lpe
->ex
.X_op
== O_big
)
942 if (exp_p
->X_add_number
<= 0 && lpe
->ex
.X_add_number
<= 0)
944 if (memcmp (&generic_floating_point_number
, &lpe
->floatnum
,
945 sizeof (FLONUM_TYPE
)) == 0)
948 else if (exp_p
->X_add_number
== lpe
->ex
.X_add_number
)
950 if (memcmp (generic_bignum
, lpe
->bignum
,
951 sizeof (LITTLENUM_TYPE
)*exp_p
->X_add_number
) == 0)
959 /* Processing for 'normal' data types. */
960 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
961 if (lpe
->nbytes
== nbytes
&& lpe
->reloc
== reloc
962 && s390_exp_compare (exp_p
, &lpe
->ex
) != 0)
969 if (lpe_free_list
!= NULL
)
972 lpe_free_list
= lpe_free_list
->next
;
976 lpe
= (struct s390_lpe
*) xmalloc (sizeof (struct s390_lpe
));
981 if (exp_p
->X_op
== O_big
)
983 if (exp_p
->X_add_number
<= 0)
984 lpe
->floatnum
= generic_floating_point_number
;
985 else if (exp_p
->X_add_number
<= 4)
986 memcpy (lpe
->bignum
, generic_bignum
,
987 exp_p
->X_add_number
* sizeof (LITTLENUM_TYPE
));
989 as_bad (_("Big number is too big"));
992 lpe
->nbytes
= nbytes
;
994 /* Literal pool name defined ? */
997 sprintf (tmp_name
, ".L\001%i", lp_count
);
998 lp_sym
= symbol_make (tmp_name
);
1001 /* Make name for literal pool entry. */
1002 sprintf (tmp_name
, ".L\001%i\002%i", lp_count
, lpe_count
);
1004 lpe
->sym
= symbol_make (tmp_name
);
1006 /* Add to literal pool list. */
1008 if (lpe_list_tail
!= NULL
)
1010 lpe_list_tail
->next
= lpe
;
1011 lpe_list_tail
= lpe
;
1014 lpe_list
= lpe_list_tail
= lpe
;
1017 /* Now change exp_p to the offset into the literal pool.
1018 Thats the expression: .L^Ax^By-.L^Ax */
1019 exp_p
->X_add_symbol
= lpe
->sym
;
1020 exp_p
->X_op_symbol
= lp_sym
;
1021 exp_p
->X_op
= O_subtract
;
1022 exp_p
->X_add_number
= 0;
1026 /* We change the suffix type to ELF_SUFFIX_NONE, because
1027 the difference of two local labels is just a number. */
1028 return ELF_SUFFIX_NONE
;
1031 /* Like normal .long/.short/.word, except support @got, etc.
1032 clobbers input_line_pointer, checks end-of-line. */
1034 s390_elf_cons (nbytes
)
1035 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
1038 elf_suffix_type suffix
;
1040 if (is_it_end_of_statement ())
1042 demand_empty_rest_of_line ();
1050 if (exp
.X_op
== O_symbol
1051 && *input_line_pointer
== '@'
1052 && (suffix
= s390_elf_suffix (&input_line_pointer
, &exp
)) != ELF_SUFFIX_NONE
)
1054 bfd_reloc_code_real_type reloc
;
1055 reloc_howto_type
*reloc_howto
;
1061 static bfd_reloc_code_real_type tab2
[] =
1063 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1064 BFD_RELOC_390_GOT16
, /* ELF_SUFFIX_GOT */
1065 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_PLT */
1066 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1067 BFD_RELOC_16_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1068 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTPLT */
1069 BFD_RELOC_390_PLTOFF16
, /* ELF_SUFFIX_PLTOFF */
1070 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GD */
1071 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GOTIE */
1072 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_IE */
1073 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDM */
1074 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDO */
1075 BFD_RELOC_UNUSED
/* ELF_SUFFIX_TLS_LE */
1077 reloc
= tab2
[suffix
];
1079 else if (nbytes
== 4)
1081 static bfd_reloc_code_real_type tab4
[] =
1083 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1084 BFD_RELOC_32_GOT_PCREL
, /* ELF_SUFFIX_GOT */
1085 BFD_RELOC_390_PLT32
, /* ELF_SUFFIX_PLT */
1086 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1087 BFD_RELOC_32_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1088 BFD_RELOC_390_GOTPLT32
, /* ELF_SUFFIX_GOTPLT */
1089 BFD_RELOC_390_PLTOFF32
, /* ELF_SUFFIX_PLTOFF */
1090 BFD_RELOC_390_TLS_GD32
, /* ELF_SUFFIX_TLS_GD */
1091 BFD_RELOC_390_TLS_GOTIE32
, /* ELF_SUFFIX_TLS_GOTIE */
1092 BFD_RELOC_390_TLS_IE32
, /* ELF_SUFFIX_TLS_IE */
1093 BFD_RELOC_390_TLS_LDM32
, /* ELF_SUFFIX_TLS_LDM */
1094 BFD_RELOC_390_TLS_LDO32
, /* ELF_SUFFIX_TLS_LDO */
1095 BFD_RELOC_390_TLS_LE32
/* ELF_SUFFIX_TLS_LE */
1097 reloc
= tab4
[suffix
];
1099 else if (nbytes
== 8)
1101 static bfd_reloc_code_real_type tab8
[] =
1103 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1104 BFD_RELOC_390_GOT64
, /* ELF_SUFFIX_GOT */
1105 BFD_RELOC_390_PLT64
, /* ELF_SUFFIX_PLT */
1106 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1107 BFD_RELOC_390_GOTOFF64
, /* ELF_SUFFIX_GOTOFF */
1108 BFD_RELOC_390_GOTPLT64
, /* ELF_SUFFIX_GOTPLT */
1109 BFD_RELOC_390_PLTOFF64
, /* ELF_SUFFIX_PLTOFF */
1110 BFD_RELOC_390_TLS_GD64
, /* ELF_SUFFIX_TLS_GD */
1111 BFD_RELOC_390_TLS_GOTIE64
, /* ELF_SUFFIX_TLS_GOTIE */
1112 BFD_RELOC_390_TLS_IE64
, /* ELF_SUFFIX_TLS_IE */
1113 BFD_RELOC_390_TLS_LDM64
, /* ELF_SUFFIX_TLS_LDM */
1114 BFD_RELOC_390_TLS_LDO64
, /* ELF_SUFFIX_TLS_LDO */
1115 BFD_RELOC_390_TLS_LE64
/* ELF_SUFFIX_TLS_LE */
1117 reloc
= tab8
[suffix
];
1120 reloc
= BFD_RELOC_UNUSED
;
1122 if (reloc
!= BFD_RELOC_UNUSED
1123 && (reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
)))
1125 size
= bfd_get_reloc_size (reloc_howto
);
1127 as_bad (_("%s relocations do not fit in %d bytes"),
1128 reloc_howto
->name
, nbytes
);
1129 where
= frag_more (nbytes
);
1130 md_number_to_chars (where
, 0, size
);
1131 /* To make fixup_segment do the pc relative conversion the
1132 pcrel parameter on the fix_new_exp call needs to be FALSE. */
1133 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1134 size
, &exp
, FALSE
, reloc
);
1137 as_bad (_("relocation not applicable"));
1140 emit_expr (&exp
, (unsigned int) nbytes
);
1142 while (*input_line_pointer
++ == ',');
1144 input_line_pointer
--; /* Put terminator back into stream. */
1145 demand_empty_rest_of_line ();
1148 /* We need to keep a list of fixups. We can't simply generate them as
1149 we go, because that would require us to first create the frag, and
1150 that would screw up references to ``.''. */
1156 bfd_reloc_code_real_type reloc
;
1159 #define MAX_INSN_FIXUPS (4)
1161 /* This routine is called for each instruction to be assembled. */
1164 md_gather_operands (str
, insn
, opcode
)
1166 unsigned char *insn
;
1167 const struct s390_opcode
*opcode
;
1169 struct s390_fixup fixups
[MAX_INSN_FIXUPS
];
1170 const struct s390_operand
*operand
;
1171 const unsigned char *opindex_ptr
;
1173 elf_suffix_type suffix
;
1174 bfd_reloc_code_real_type reloc
;
1180 while (ISSPACE (*str
))
1186 /* Gather the operands. */
1188 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1192 operand
= s390_operands
+ *opindex_ptr
;
1194 if (skip_optional
&& (operand
->flags
& S390_OPERAND_INDEX
))
1196 /* We do an early skip. For D(X,B) constructions the index
1197 register is skipped (X is optional). For D(L,B) the base
1198 register will be the skipped operand, because L is NOT
1204 /* Gather the operand. */
1205 hold
= input_line_pointer
;
1206 input_line_pointer
= str
;
1208 /* Parse the operand. */
1209 if (! register_name (&ex
))
1212 str
= input_line_pointer
;
1213 input_line_pointer
= hold
;
1215 /* Write the operand to the insn. */
1216 if (ex
.X_op
== O_illegal
)
1217 as_bad (_("illegal operand"));
1218 else if (ex
.X_op
== O_absent
)
1219 as_bad (_("missing operand"));
1220 else if (ex
.X_op
== O_register
|| ex
.X_op
== O_constant
)
1222 s390_lit_suffix (&str
, &ex
, ELF_SUFFIX_NONE
);
1224 if (ex
.X_op
!= O_register
&& ex
.X_op
!= O_constant
)
1226 /* We need to generate a fixup for the
1227 expression returned by s390_lit_suffix. */
1228 if (fc
>= MAX_INSN_FIXUPS
)
1229 as_fatal (_("too many fixups"));
1230 fixups
[fc
].exp
= ex
;
1231 fixups
[fc
].opindex
= *opindex_ptr
;
1232 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
1237 if ((operand
->flags
& S390_OPERAND_INDEX
)
1238 && ex
.X_add_number
== 0
1240 as_warn ("index register specified but zero");
1241 if ((operand
->flags
& S390_OPERAND_BASE
)
1242 && ex
.X_add_number
== 0
1244 as_warn ("base register specified but zero");
1245 s390_insert_operand (insn
, operand
, ex
.X_add_number
, NULL
, 0);
1250 suffix
= s390_elf_suffix (&str
, &ex
);
1251 suffix
= s390_lit_suffix (&str
, &ex
, suffix
);
1252 reloc
= BFD_RELOC_UNUSED
;
1254 if (suffix
== ELF_SUFFIX_GOT
)
1256 if ((operand
->flags
& S390_OPERAND_DISP
) &&
1257 (operand
->bits
== 12))
1258 reloc
= BFD_RELOC_390_GOT12
;
1259 else if ((operand
->flags
& S390_OPERAND_DISP
) &&
1260 (operand
->bits
== 20))
1261 reloc
= BFD_RELOC_390_GOT20
;
1262 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1263 && (operand
->bits
== 16))
1264 reloc
= BFD_RELOC_390_GOT16
;
1265 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1266 && (operand
->bits
== 32))
1267 reloc
= BFD_RELOC_390_GOTENT
;
1269 else if (suffix
== ELF_SUFFIX_PLT
)
1271 if ((operand
->flags
& S390_OPERAND_PCREL
)
1272 && (operand
->bits
== 16))
1273 reloc
= BFD_RELOC_390_PLT16DBL
;
1274 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1275 && (operand
->bits
== 32))
1276 reloc
= BFD_RELOC_390_PLT32DBL
;
1278 else if (suffix
== ELF_SUFFIX_GOTENT
)
1280 if ((operand
->flags
& S390_OPERAND_PCREL
)
1281 && (operand
->bits
== 32))
1282 reloc
= BFD_RELOC_390_GOTENT
;
1284 else if (suffix
== ELF_SUFFIX_GOTOFF
)
1286 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1287 && (operand
->bits
== 16))
1288 reloc
= BFD_RELOC_16_GOTOFF
;
1290 else if (suffix
== ELF_SUFFIX_PLTOFF
)
1292 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1293 && (operand
->bits
== 16))
1294 reloc
= BFD_RELOC_390_PLTOFF16
;
1296 else if (suffix
== ELF_SUFFIX_GOTPLT
)
1298 if ((operand
->flags
& S390_OPERAND_DISP
)
1299 && (operand
->bits
== 12))
1300 reloc
= BFD_RELOC_390_GOTPLT12
;
1301 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1302 && (operand
->bits
== 16))
1303 reloc
= BFD_RELOC_390_GOTPLT16
;
1304 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1305 && (operand
->bits
== 32))
1306 reloc
= BFD_RELOC_390_GOTPLTENT
;
1308 else if (suffix
== ELF_SUFFIX_TLS_GOTIE
)
1310 if ((operand
->flags
& S390_OPERAND_DISP
)
1311 && (operand
->bits
== 12))
1312 reloc
= BFD_RELOC_390_TLS_GOTIE12
;
1313 else if ((operand
->flags
& S390_OPERAND_DISP
)
1314 && (operand
->bits
== 20))
1315 reloc
= BFD_RELOC_390_TLS_GOTIE20
;
1317 else if (suffix
== ELF_SUFFIX_TLS_IE
)
1319 if ((operand
->flags
& S390_OPERAND_PCREL
)
1320 && (operand
->bits
== 32))
1321 reloc
= BFD_RELOC_390_TLS_IEENT
;
1324 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
1325 as_bad (_("invalid operand suffix"));
1326 /* We need to generate a fixup of type 'reloc' for this
1328 if (fc
>= MAX_INSN_FIXUPS
)
1329 as_fatal (_("too many fixups"));
1330 fixups
[fc
].exp
= ex
;
1331 fixups
[fc
].opindex
= *opindex_ptr
;
1332 fixups
[fc
].reloc
= reloc
;
1336 /* Check the next character. The call to expression has advanced
1337 str past any whitespace. */
1338 if (operand
->flags
& S390_OPERAND_DISP
)
1340 /* After a displacement a block in parentheses can start. */
1343 /* Check if parenthesized block can be skipped. If the next
1344 operand is neiter an optional operand nor a base register
1345 then we have a syntax error. */
1346 operand
= s390_operands
+ *(++opindex_ptr
);
1347 if (!(operand
->flags
& (S390_OPERAND_INDEX
|S390_OPERAND_BASE
)))
1348 as_bad (_("syntax error; missing '(' after displacement"));
1350 /* Ok, skip all operands until S390_OPERAND_BASE. */
1351 while (!(operand
->flags
& S390_OPERAND_BASE
))
1352 operand
= s390_operands
+ *(++opindex_ptr
);
1354 /* If there is a next operand it must be separated by a comma. */
1355 if (opindex_ptr
[1] != '\0')
1359 while (opindex_ptr
[1] != '\0')
1361 operand
= s390_operands
+ *(++opindex_ptr
);
1362 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1364 as_bad (_("syntax error; expected ,"));
1374 /* We found an opening parentheses. */
1376 for (f
= str
; *f
!= '\0'; f
++)
1377 if (*f
== ',' || *f
== ')')
1379 /* If there is no comma until the closing parentheses OR
1380 there is a comma right after the opening parentheses,
1381 we have to skip optional operands. */
1382 if (*f
== ',' && f
== str
)
1384 /* comma directly after '(' ? */
1389 skip_optional
= (*f
!= ',');
1392 else if (operand
->flags
& S390_OPERAND_BASE
)
1394 /* After the base register the parenthesed block ends. */
1396 as_bad (_("syntax error; missing ')' after base register"));
1398 /* If there is a next operand it must be separated by a comma. */
1399 if (opindex_ptr
[1] != '\0')
1403 while (opindex_ptr
[1] != '\0')
1405 operand
= s390_operands
+ *(++opindex_ptr
);
1406 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1408 as_bad (_("syntax error; expected ,"));
1418 /* We can find an 'early' closing parentheses in e.g. D(L) instead
1419 of D(L,B). In this case the base register has to be skipped. */
1422 operand
= s390_operands
+ *(++opindex_ptr
);
1424 if (!(operand
->flags
& S390_OPERAND_BASE
))
1425 as_bad (_("syntax error; ')' not allowed here"));
1428 /* If there is a next operand it must be separated by a comma. */
1429 if (opindex_ptr
[1] != '\0')
1433 while (opindex_ptr
[1] != '\0')
1435 operand
= s390_operands
+ *(++opindex_ptr
);
1436 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1438 as_bad (_("syntax error; expected ,"));
1448 while (ISSPACE (*str
))
1451 /* Check for tls instruction marker. */
1452 reloc
= s390_tls_suffix (&str
, &ex
);
1453 if (reloc
!= BFD_RELOC_UNUSED
)
1455 /* We need to generate a fixup of type 'reloc' for this
1457 if (fc
>= MAX_INSN_FIXUPS
)
1458 as_fatal (_("too many fixups"));
1459 fixups
[fc
].exp
= ex
;
1460 fixups
[fc
].opindex
= -1;
1461 fixups
[fc
].reloc
= reloc
;
1469 if ((linefeed
= strchr (str
, '\n')) != NULL
)
1471 as_bad (_("junk at end of line: `%s'"), str
);
1472 if (linefeed
!= NULL
)
1476 /* Write out the instruction. */
1477 f
= frag_more (opcode
->oplen
);
1478 memcpy (f
, insn
, opcode
->oplen
);
1479 dwarf2_emit_insn (opcode
->oplen
);
1481 /* Create any fixups. At this point we do not use a
1482 bfd_reloc_code_real_type, but instead just use the
1483 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1484 handle fixups for any operand type, although that is admittedly
1485 not a very exciting feature. We pick a BFD reloc type in
1487 for (i
= 0; i
< fc
; i
++)
1490 if (fixups
[i
].opindex
< 0)
1492 /* Create tls instruction marker relocation. */
1493 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, opcode
->oplen
,
1494 &fixups
[i
].exp
, 0, fixups
[i
].reloc
);
1498 operand
= s390_operands
+ fixups
[i
].opindex
;
1500 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
1502 reloc_howto_type
*reloc_howto
;
1506 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
1510 size
= bfd_get_reloc_size (reloc_howto
);
1512 if (size
< 1 || size
> 4)
1515 fixP
= fix_new_exp (frag_now
,
1516 f
- frag_now
->fr_literal
+ (operand
->shift
/8),
1517 size
, &fixups
[i
].exp
, reloc_howto
->pc_relative
,
1519 /* Turn off overflow checking in fixup_segment. This is necessary
1520 because fixup_segment will signal an overflow for large 4 byte
1521 quantities for GOT12 relocations. */
1522 if ( fixups
[i
].reloc
== BFD_RELOC_390_GOT12
1523 || fixups
[i
].reloc
== BFD_RELOC_390_GOT20
1524 || fixups
[i
].reloc
== BFD_RELOC_390_GOT16
)
1525 fixP
->fx_no_overflow
= 1;
1528 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4, &fixups
[i
].exp
,
1529 (operand
->flags
& S390_OPERAND_PCREL
) != 0,
1530 ((bfd_reloc_code_real_type
)
1531 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
1536 /* This routine is called for each instruction to be assembled. */
1542 const struct s390_opcode
*opcode
;
1543 unsigned char insn
[6];
1546 /* Get the opcode. */
1547 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1552 /* Look up the opcode in the hash table. */
1553 opcode
= (struct s390_opcode
*) hash_find (s390_opcode_hash
, str
);
1554 if (opcode
== (const struct s390_opcode
*) NULL
)
1556 as_bad (_("Unrecognized opcode: `%s'"), str
);
1559 else if (!(opcode
->modes
& current_mode_mask
))
1561 as_bad ("Opcode %s not available in this mode", str
);
1564 memcpy (insn
, opcode
->opcode
, sizeof (insn
));
1565 md_gather_operands (s
, insn
, opcode
);
1568 #ifndef WORKING_DOT_WORD
1569 /* Handle long and short jumps. We don't support these */
1571 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1573 addressT from_addr
, to_addr
;
1581 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1583 addressT from_addr
, to_addr
;
1593 int ignore ATTRIBUTE_UNUSED
;
1595 /* We don't support putting frags in the BSS segment, we fake it
1596 by marking in_bss, then looking at s_skip for clues. */
1598 subseg_set (bss_section
, 0);
1599 demand_empty_rest_of_line ();
1602 /* Pseudo-op handling. */
1606 int ignore ATTRIBUTE_UNUSED
;
1609 const struct s390_opcode
*opformat
;
1610 unsigned char insn
[6];
1613 /* Get the opcode format. */
1614 s
= input_line_pointer
;
1615 while (*s
!= '\0' && *s
!= ',' && ! ISSPACE (*s
))
1618 as_bad (_("Invalid .insn format\n"));
1621 /* Look up the opcode in the hash table. */
1622 opformat
= (struct s390_opcode
*)
1623 hash_find (s390_opformat_hash
, input_line_pointer
);
1624 if (opformat
== (const struct s390_opcode
*) NULL
)
1626 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer
);
1629 input_line_pointer
= s
;
1631 if (exp
.X_op
== O_constant
)
1633 if ( ( opformat
->oplen
== 6
1634 && (addressT
) exp
.X_add_number
< (1ULL << 48))
1635 || ( opformat
->oplen
== 4
1636 && (addressT
) exp
.X_add_number
< (1ULL << 32))
1637 || ( opformat
->oplen
== 2
1638 && (addressT
) exp
.X_add_number
< (1ULL << 16)))
1639 md_number_to_chars ((char *) insn
, exp
.X_add_number
, opformat
->oplen
);
1641 as_bad (_("Invalid .insn format\n"));
1643 else if (exp
.X_op
== O_big
)
1645 if (exp
.X_add_number
> 0
1646 && opformat
->oplen
== 6
1647 && generic_bignum
[3] == 0)
1649 md_number_to_chars ((char *) insn
, generic_bignum
[2], 2);
1650 md_number_to_chars ((char *) &insn
[2], generic_bignum
[1], 2);
1651 md_number_to_chars ((char *) &insn
[4], generic_bignum
[0], 2);
1654 as_bad (_("Invalid .insn format\n"));
1657 as_bad (_("second operand of .insn not a constant\n"));
1659 if (strcmp (opformat
->name
, "e") != 0 && *input_line_pointer
++ != ',')
1660 as_bad (_("missing comma after insn constant\n"));
1662 if ((s
= strchr (input_line_pointer
, '\n')) != NULL
)
1664 input_line_pointer
= md_gather_operands (input_line_pointer
, insn
,
1668 demand_empty_rest_of_line ();
1671 /* The .byte pseudo-op. This is similar to the normal .byte
1672 pseudo-op, but it can also take a single ASCII string. */
1676 int ignore ATTRIBUTE_UNUSED
;
1678 if (*input_line_pointer
!= '\"')
1684 /* Gather characters. A real double quote is doubled. Unusual
1685 characters are not permitted. */
1686 ++input_line_pointer
;
1691 c
= *input_line_pointer
++;
1695 if (*input_line_pointer
!= '\"')
1697 ++input_line_pointer
;
1700 FRAG_APPEND_1_CHAR (c
);
1703 demand_empty_rest_of_line ();
1706 /* The .ltorg pseudo-op.This emits all literals defined since the last
1707 .ltorg or the invocation of gas. Literals are defined with the
1711 s390_literals (ignore
)
1712 int ignore ATTRIBUTE_UNUSED
;
1714 struct s390_lpe
*lpe
;
1716 if (lp_sym
== NULL
|| lpe_count
== 0)
1717 return; /* Nothing to be done. */
1719 /* Emit symbol for start of literal pool. */
1720 S_SET_SEGMENT (lp_sym
, now_seg
);
1721 S_SET_VALUE (lp_sym
, (valueT
) frag_now_fix ());
1722 lp_sym
->sy_frag
= frag_now
;
1727 lpe_list
= lpe_list
->next
;
1728 S_SET_SEGMENT (lpe
->sym
, now_seg
);
1729 S_SET_VALUE (lpe
->sym
, (valueT
) frag_now_fix ());
1730 lpe
->sym
->sy_frag
= frag_now
;
1732 /* Emit literal pool entry. */
1733 if (lpe
->reloc
!= BFD_RELOC_UNUSED
)
1735 reloc_howto_type
*reloc_howto
=
1736 bfd_reloc_type_lookup (stdoutput
, lpe
->reloc
);
1737 int size
= bfd_get_reloc_size (reloc_howto
);
1740 if (size
> lpe
->nbytes
)
1741 as_bad (_("%s relocations do not fit in %d bytes"),
1742 reloc_howto
->name
, lpe
->nbytes
);
1743 where
= frag_more (lpe
->nbytes
);
1744 md_number_to_chars (where
, 0, size
);
1745 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1746 size
, &lpe
->ex
, reloc_howto
->pc_relative
, lpe
->reloc
);
1750 if (lpe
->ex
.X_op
== O_big
)
1752 if (lpe
->ex
.X_add_number
<= 0)
1753 generic_floating_point_number
= lpe
->floatnum
;
1755 memcpy (generic_bignum
, lpe
->bignum
,
1756 lpe
->ex
.X_add_number
* sizeof (LITTLENUM_TYPE
));
1758 emit_expr (&lpe
->ex
, lpe
->nbytes
);
1761 lpe
->next
= lpe_free_list
;
1762 lpe_free_list
= lpe
;
1764 lpe_list_tail
= NULL
;
1770 /* Turn a string in input_line_pointer into a floating point constant
1771 of type type, and store the appropriate bytes in *litp. The number
1772 of LITTLENUMS emitted is stored in *sizep . An error message is
1773 returned, or NULL on OK. */
1776 md_atof (type
, litp
, sizep
)
1782 LITTLENUM_TYPE words
[4];
1798 return "bad call to md_atof";
1801 t
= atof_ieee (input_line_pointer
, type
, words
);
1803 input_line_pointer
= t
;
1807 for (i
= 0; i
< prec
; i
++)
1809 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
1816 /* Align a section (I don't know why this is machine dependent). */
1819 md_section_align (seg
, addr
)
1823 int align
= bfd_get_section_alignment (stdoutput
, seg
);
1825 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
1828 /* We don't have any form of relaxing. */
1831 md_estimate_size_before_relax (fragp
, seg
)
1832 fragS
*fragp ATTRIBUTE_UNUSED
;
1833 asection
*seg ATTRIBUTE_UNUSED
;
1839 /* Convert a machine dependent frag. We never generate these. */
1842 md_convert_frag (abfd
, sec
, fragp
)
1843 bfd
*abfd ATTRIBUTE_UNUSED
;
1844 asection
*sec ATTRIBUTE_UNUSED
;
1845 fragS
*fragp ATTRIBUTE_UNUSED
;
1851 md_undefined_symbol (name
)
1854 if (*name
== '_' && *(name
+ 1) == 'G'
1855 && strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
1859 if (symbol_find (name
))
1860 as_bad (_("GOT already in symbol table"));
1861 GOT_symbol
= symbol_new (name
, undefined_section
,
1862 (valueT
) 0, &zero_address_frag
);
1869 /* Functions concerning relocs. */
1871 /* The location from which a PC relative jump should be calculated,
1872 given a PC relative reloc. */
1875 md_pcrel_from_section (fixp
, sec
)
1877 segT sec ATTRIBUTE_UNUSED
;
1879 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
1882 /* Here we decide which fixups can be adjusted to make them relative to
1883 the beginning of the section instead of the symbol. Basically we need
1884 to make sure that the dynamic relocations are done correctly, so in
1885 some cases we force the original symbol to be used. */
1887 tc_s390_fix_adjustable (fixP
)
1890 /* Don't adjust references to merge sections. */
1891 if ((S_GET_SEGMENT (fixP
->fx_addsy
)->flags
& SEC_MERGE
) != 0)
1893 /* adjust_reloc_syms doesn't know about the GOT. */
1894 if ( fixP
->fx_r_type
== BFD_RELOC_16_GOTOFF
1895 || fixP
->fx_r_type
== BFD_RELOC_32_GOTOFF
1896 || fixP
->fx_r_type
== BFD_RELOC_390_GOTOFF64
1897 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF16
1898 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF32
1899 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF64
1900 || fixP
->fx_r_type
== BFD_RELOC_390_PLT16DBL
1901 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32
1902 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32DBL
1903 || fixP
->fx_r_type
== BFD_RELOC_390_PLT64
1904 || fixP
->fx_r_type
== BFD_RELOC_390_GOT12
1905 || fixP
->fx_r_type
== BFD_RELOC_390_GOT20
1906 || fixP
->fx_r_type
== BFD_RELOC_390_GOT16
1907 || fixP
->fx_r_type
== BFD_RELOC_32_GOT_PCREL
1908 || fixP
->fx_r_type
== BFD_RELOC_390_GOT64
1909 || fixP
->fx_r_type
== BFD_RELOC_390_GOTENT
1910 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT12
1911 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT16
1912 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT20
1913 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT32
1914 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT64
1915 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLTENT
1916 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LOAD
1917 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GDCALL
1918 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDCALL
1919 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD32
1920 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD64
1921 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE12
1922 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE20
1923 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE32
1924 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE64
1925 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM32
1926 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM64
1927 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE32
1928 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE64
1929 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IEENT
1930 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE32
1931 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE64
1932 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO32
1933 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO64
1934 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPMOD
1935 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPOFF
1936 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_TPOFF
1937 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
1938 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
1943 /* Return true if we must always emit a reloc for a type and false if
1944 there is some hope of resolving it at assembly time. */
1946 tc_s390_force_relocation (fixp
)
1949 /* Ensure we emit a relocation for every reference to the global
1950 offset table or to the procedure link table. */
1951 switch (fixp
->fx_r_type
)
1953 case BFD_RELOC_390_GOT12
:
1954 case BFD_RELOC_390_GOT20
:
1955 case BFD_RELOC_32_GOT_PCREL
:
1956 case BFD_RELOC_32_GOTOFF
:
1957 case BFD_RELOC_390_GOTOFF64
:
1958 case BFD_RELOC_390_PLTOFF16
:
1959 case BFD_RELOC_390_PLTOFF32
:
1960 case BFD_RELOC_390_PLTOFF64
:
1961 case BFD_RELOC_390_GOTPC
:
1962 case BFD_RELOC_390_GOT16
:
1963 case BFD_RELOC_390_GOTPCDBL
:
1964 case BFD_RELOC_390_GOT64
:
1965 case BFD_RELOC_390_GOTENT
:
1966 case BFD_RELOC_390_PLT32
:
1967 case BFD_RELOC_390_PLT16DBL
:
1968 case BFD_RELOC_390_PLT32DBL
:
1969 case BFD_RELOC_390_PLT64
:
1970 case BFD_RELOC_390_GOTPLT12
:
1971 case BFD_RELOC_390_GOTPLT16
:
1972 case BFD_RELOC_390_GOTPLT20
:
1973 case BFD_RELOC_390_GOTPLT32
:
1974 case BFD_RELOC_390_GOTPLT64
:
1975 case BFD_RELOC_390_GOTPLTENT
:
1981 return generic_force_reloc (fixp
);
1984 /* Apply a fixup to the object code. This is called for all the
1985 fixups we generated by the call to fix_new_exp, above. In the call
1986 above we used a reloc code which was the largest legal reloc code
1987 plus the operand index. Here we undo that to recover the operand
1988 index. At this point all symbol values should be fully resolved,
1989 and we attempt to completely resolve the reloc. If we can not do
1990 that, we determine the correct reloc code and put it back in the
1994 md_apply_fix (fixP
, valP
, seg
)
1997 segT seg ATTRIBUTE_UNUSED
;
2000 valueT value
= *valP
;
2002 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
2004 if (fixP
->fx_subsy
!= NULL
)
2005 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2006 "cannot emit relocation %s against subsy symbol %s",
2007 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2008 S_GET_NAME (fixP
->fx_subsy
));
2010 if (fixP
->fx_addsy
!= NULL
)
2013 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
2018 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
2020 const struct s390_operand
*operand
;
2023 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
2024 operand
= &s390_operands
[opindex
];
2028 /* Insert the fully resolved operand value. */
2029 s390_insert_operand ((unsigned char *) where
, operand
,
2030 (offsetT
) value
, fixP
->fx_file
, fixP
->fx_line
);
2034 /* Determine a BFD reloc value based on the operand information.
2035 We are only prepared to turn a few of the operands into
2037 fixP
->fx_offset
= value
;
2038 if (operand
->bits
== 12 && operand
->shift
== 20)
2041 fixP
->fx_where
+= 2;
2042 fixP
->fx_r_type
= BFD_RELOC_390_12
;
2044 else if (operand
->bits
== 12 && operand
->shift
== 36)
2047 fixP
->fx_where
+= 4;
2048 fixP
->fx_r_type
= BFD_RELOC_390_12
;
2050 else if (operand
->bits
== 20 && operand
->shift
== 20)
2053 fixP
->fx_where
+= 2;
2054 fixP
->fx_r_type
= BFD_RELOC_390_20
;
2056 else if (operand
->bits
== 8 && operand
->shift
== 8)
2059 fixP
->fx_where
+= 1;
2060 fixP
->fx_r_type
= BFD_RELOC_8
;
2062 else if (operand
->bits
== 16 && operand
->shift
== 16)
2065 fixP
->fx_where
+= 2;
2066 if (operand
->flags
& S390_OPERAND_PCREL
)
2068 fixP
->fx_r_type
= BFD_RELOC_390_PC16DBL
;
2069 fixP
->fx_offset
+= 2;
2072 fixP
->fx_r_type
= BFD_RELOC_16
;
2074 else if (operand
->bits
== 32 && operand
->shift
== 16
2075 && (operand
->flags
& S390_OPERAND_PCREL
))
2078 fixP
->fx_where
+= 2;
2079 fixP
->fx_offset
+= 2;
2080 fixP
->fx_r_type
= BFD_RELOC_390_PC32DBL
;
2087 /* Use expr_symbol_where to see if this is an expression
2089 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
2090 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2091 _("unresolved expression that must be resolved"));
2093 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2094 _("unsupported relocation type"));
2101 switch (fixP
->fx_r_type
)
2107 md_number_to_chars (where
, value
, 1);
2109 case BFD_RELOC_390_12
:
2110 case BFD_RELOC_390_GOT12
:
2111 case BFD_RELOC_390_GOTPLT12
:
2116 mop
= bfd_getb16 ((unsigned char *) where
);
2117 mop
|= (unsigned short) (value
& 0xfff);
2118 bfd_putb16 ((bfd_vma
) mop
, (unsigned char *) where
);
2122 case BFD_RELOC_390_20
:
2123 case BFD_RELOC_390_GOT20
:
2124 case BFD_RELOC_390_GOTPLT20
:
2128 mop
= bfd_getb32 ((unsigned char *) where
);
2129 mop
|= (unsigned int) ((value
& 0xfff) << 8 |
2130 (value
& 0xff000) >> 12);
2131 bfd_putb32 ((bfd_vma
) mop
, (unsigned char *) where
);
2136 case BFD_RELOC_GPREL16
:
2137 case BFD_RELOC_16_GOT_PCREL
:
2138 case BFD_RELOC_16_GOTOFF
:
2140 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2141 "cannot emit PC relative %s relocation%s%s",
2142 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2143 fixP
->fx_addsy
!= NULL
? " against " : "",
2144 (fixP
->fx_addsy
!= NULL
2145 ? S_GET_NAME (fixP
->fx_addsy
)
2148 md_number_to_chars (where
, value
, 2);
2150 case BFD_RELOC_390_GOT16
:
2151 case BFD_RELOC_390_PLTOFF16
:
2152 case BFD_RELOC_390_GOTPLT16
:
2154 md_number_to_chars (where
, value
, 2);
2156 case BFD_RELOC_390_PC16DBL
:
2157 case BFD_RELOC_390_PLT16DBL
:
2160 md_number_to_chars (where
, (offsetT
) value
>> 1, 2);
2165 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2167 fixP
->fx_r_type
= BFD_RELOC_32
;
2169 md_number_to_chars (where
, value
, 4);
2171 case BFD_RELOC_32_PCREL
:
2172 case BFD_RELOC_32_BASEREL
:
2173 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2175 md_number_to_chars (where
, value
, 4);
2177 case BFD_RELOC_32_GOT_PCREL
:
2178 case BFD_RELOC_390_PLTOFF32
:
2179 case BFD_RELOC_390_PLT32
:
2180 case BFD_RELOC_390_GOTPLT32
:
2182 md_number_to_chars (where
, value
, 4);
2184 case BFD_RELOC_390_PC32DBL
:
2185 case BFD_RELOC_390_PLT32DBL
:
2186 case BFD_RELOC_390_GOTPCDBL
:
2187 case BFD_RELOC_390_GOTENT
:
2188 case BFD_RELOC_390_GOTPLTENT
:
2191 md_number_to_chars (where
, (offsetT
) value
>> 1, 4);
2194 case BFD_RELOC_32_GOTOFF
:
2196 md_number_to_chars (where
, value
, sizeof (int));
2199 case BFD_RELOC_390_GOTOFF64
:
2201 md_number_to_chars (where
, value
, 8);
2204 case BFD_RELOC_390_GOT64
:
2205 case BFD_RELOC_390_PLTOFF64
:
2206 case BFD_RELOC_390_PLT64
:
2207 case BFD_RELOC_390_GOTPLT64
:
2209 md_number_to_chars (where
, value
, 8);
2214 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2216 fixP
->fx_r_type
= BFD_RELOC_64
;
2218 md_number_to_chars (where
, value
, 8);
2221 case BFD_RELOC_64_PCREL
:
2222 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2224 md_number_to_chars (where
, value
, 8);
2227 case BFD_RELOC_VTABLE_INHERIT
:
2228 case BFD_RELOC_VTABLE_ENTRY
:
2232 case BFD_RELOC_390_TLS_LOAD
:
2233 case BFD_RELOC_390_TLS_GDCALL
:
2234 case BFD_RELOC_390_TLS_LDCALL
:
2235 case BFD_RELOC_390_TLS_GD32
:
2236 case BFD_RELOC_390_TLS_GD64
:
2237 case BFD_RELOC_390_TLS_GOTIE12
:
2238 case BFD_RELOC_390_TLS_GOTIE20
:
2239 case BFD_RELOC_390_TLS_GOTIE32
:
2240 case BFD_RELOC_390_TLS_GOTIE64
:
2241 case BFD_RELOC_390_TLS_LDM32
:
2242 case BFD_RELOC_390_TLS_LDM64
:
2243 case BFD_RELOC_390_TLS_IE32
:
2244 case BFD_RELOC_390_TLS_IE64
:
2245 case BFD_RELOC_390_TLS_LE32
:
2246 case BFD_RELOC_390_TLS_LE64
:
2247 case BFD_RELOC_390_TLS_LDO32
:
2248 case BFD_RELOC_390_TLS_LDO64
:
2249 case BFD_RELOC_390_TLS_DTPMOD
:
2250 case BFD_RELOC_390_TLS_DTPOFF
:
2251 case BFD_RELOC_390_TLS_TPOFF
:
2252 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2253 /* Fully resolved at link time. */
2255 case BFD_RELOC_390_TLS_IEENT
:
2256 /* Fully resolved at link time. */
2257 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2263 const char *reloc_name
= bfd_get_reloc_code_name (fixP
->fx_r_type
);
2265 if (reloc_name
!= NULL
)
2266 fprintf (stderr
, "Gas failure, reloc type %s\n", reloc_name
);
2268 fprintf (stderr
, "Gas failure, reloc type #%i\n", fixP
->fx_r_type
);
2274 fixP
->fx_offset
= value
;
2278 /* Generate a reloc for a fixup. */
2281 tc_gen_reloc (seg
, fixp
)
2282 asection
*seg ATTRIBUTE_UNUSED
;
2285 bfd_reloc_code_real_type code
;
2288 code
= fixp
->fx_r_type
;
2289 if (GOT_symbol
&& fixp
->fx_addsy
== GOT_symbol
)
2291 if ( (s390_arch_size
== 32 && code
== BFD_RELOC_32_PCREL
)
2292 || (s390_arch_size
== 64 && code
== BFD_RELOC_64_PCREL
))
2293 code
= BFD_RELOC_390_GOTPC
;
2294 if (code
== BFD_RELOC_390_PC32DBL
)
2295 code
= BFD_RELOC_390_GOTPCDBL
;
2298 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
2299 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
2300 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2301 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2302 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2303 if (reloc
->howto
== NULL
)
2305 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2306 _("cannot represent relocation type %s"),
2307 bfd_get_reloc_code_name (code
));
2308 /* Set howto to a garbage value so that we can keep going. */
2309 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
2310 assert (reloc
->howto
!= NULL
);
2312 reloc
->addend
= fixp
->fx_offset
;
2318 s390_cfi_frame_initial_instructions ()
2320 cfi_add_CFA_def_cfa (15, s390_arch_size
== 64 ? 160 : 96);
2324 tc_s390_regname_to_dw2regnum (char *regname
)
2328 if (regname
[0] != 'c' && regname
[0] != 'a')
2330 regnum
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, regname
);
2331 if (regname
[0] == 'f' && regnum
!= -1)
2334 else if (strcmp (regname
, "ap") == 0)
2336 else if (strcmp (regname
, "cc") == 0)