1 /* tc-s390.c -- Assemble for the S390
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3 2009, 2010 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 3, 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 /* If no -march option was given default to the highest available CPU.
42 Since with S/390 a newer CPU always supports everything from its
43 predecessors this will accept every valid asm input. */
44 static unsigned int current_cpu
= S390_OPCODE_MAXCPU
- 1;
45 static unsigned int current_mode_mask
= 0;
47 /* Whether to use user friendly register names. Default is TRUE. */
48 #ifndef TARGET_REG_NAMES_P
49 #define TARGET_REG_NAMES_P TRUE
52 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
54 /* Set to TRUE if we want to warn about zero base/index registers. */
55 static bfd_boolean warn_areg_zero
= FALSE
;
57 /* Generic assembler global variables which must be defined by all
60 const char comment_chars
[] = "#";
62 /* Characters which start a comment at the beginning of a line. */
63 const char line_comment_chars
[] = "#";
65 /* Characters which may be used to separate multiple commands on a
67 const char line_separator_chars
[] = ";";
69 /* Characters which are used to indicate an exponent in a floating
71 const char EXP_CHARS
[] = "eE";
73 /* Characters which mean that a number is a floating point constant,
75 const char FLT_CHARS
[] = "dD";
77 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
78 int s390_cie_data_alignment
;
80 /* The target specific pseudo-ops which we support. */
82 /* Define the prototypes for the pseudo-ops */
83 static void s390_byte (int);
84 static void s390_elf_cons (int);
85 static void s390_bss (int);
86 static void s390_insn (int);
87 static void s390_literals (int);
89 const pseudo_typeS md_pseudo_table
[] =
91 { "align", s_align_bytes
, 0 },
92 /* Pseudo-ops which must be defined. */
93 { "bss", s390_bss
, 0 },
94 { "insn", s390_insn
, 0 },
95 /* Pseudo-ops which must be overridden. */
96 { "byte", s390_byte
, 0 },
97 { "short", s390_elf_cons
, 2 },
98 { "long", s390_elf_cons
, 4 },
99 { "quad", s390_elf_cons
, 8 },
100 { "ltorg", s390_literals
, 0 },
101 { "string", stringer
, 8 + 1 },
106 /* Structure to hold information about predefined registers. */
113 /* List of registers that are pre-defined:
115 Each access register has a predefined name of the form:
116 a<reg_num> which has the value <reg_num>.
118 Each control register has a predefined name of the form:
119 c<reg_num> which has the value <reg_num>.
121 Each general register has a predefined name of the form:
122 r<reg_num> which has the value <reg_num>.
124 Each floating point register a has predefined name of the form:
125 f<reg_num> which has the value <reg_num>.
127 There are individual registers as well:
131 The table is sorted. Suitable for searching by a binary search. */
133 static const struct pd_reg pre_defined_registers
[] =
135 { "a0", 0 }, /* Access registers */
152 { "c0", 0 }, /* Control registers */
169 { "f0", 0 }, /* Floating point registers */
186 { "lit", 13 }, /* Pointer to literal pool */
188 { "r0", 0 }, /* General purpose registers */
205 { "sp", 15 }, /* Stack pointer */
209 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
211 /* Given NAME, find the register number associated with that name, return
212 the integer value associated with the given name or -1 on failure. */
215 reg_name_search (const struct pd_reg
*regs
, int regcount
, const char *name
)
217 int middle
, low
, high
;
225 middle
= (low
+ high
) / 2;
226 cmp
= strcasecmp (name
, regs
[middle
].name
);
232 return regs
[middle
].value
;
241 * Summary of register_name().
243 * in: Input_line_pointer points to 1st char of operand.
245 * out: A expressionS.
246 * The operand may have been a register: in this case, X_op == O_register,
247 * X_add_number is set to the register number, and truth is returned.
248 * Input_line_pointer->(next non-blank) char after operand, or is in its
253 register_name (expressionS
*expressionP
)
260 /* Find the spelling of the operand. */
261 start
= name
= input_line_pointer
;
262 if (name
[0] == '%' && ISALPHA (name
[1]))
263 name
= ++input_line_pointer
;
267 c
= get_symbol_end ();
268 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
270 /* Put back the delimiting char. */
271 *input_line_pointer
= c
;
273 /* Look to see if it's in the register table. */
276 expressionP
->X_op
= O_register
;
277 expressionP
->X_add_number
= reg_number
;
279 /* Make the rest nice. */
280 expressionP
->X_add_symbol
= NULL
;
281 expressionP
->X_op_symbol
= NULL
;
285 /* Reset the line as if we had not done anything. */
286 input_line_pointer
= start
;
290 /* Local variables. */
292 /* Opformat hash table. */
293 static struct hash_control
*s390_opformat_hash
;
295 /* Opcode hash table. */
296 static struct hash_control
*s390_opcode_hash
;
298 /* Flags to set in the elf header */
299 static flagword s390_flags
= 0;
301 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
303 #ifndef WORKING_DOT_WORD
304 int md_short_jump_size
= 4;
305 int md_long_jump_size
= 4;
308 const char *md_shortopts
= "A:m:kVQ:";
309 struct option md_longopts
[] = {
310 {NULL
, no_argument
, NULL
, 0}
312 size_t md_longopts_size
= sizeof (md_longopts
);
314 /* Initialize the default opcode arch and word size from the default
315 architecture name if not specified by an option. */
317 init_default_arch (void)
319 if (strcmp (default_arch
, "s390") == 0)
321 if (s390_arch_size
== 0)
324 else if (strcmp (default_arch
, "s390x") == 0)
326 if (s390_arch_size
== 0)
330 as_fatal (_("Invalid default architecture, broken assembler."));
332 if (current_mode_mask
== 0)
334 /* Default to z/Architecture mode if the CPU supports it. */
335 if (current_cpu
< S390_OPCODE_Z900
)
336 current_mode_mask
= 1 << S390_OPCODE_ESA
;
338 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
342 /* Called by TARGET_FORMAT. */
344 s390_target_format (void)
346 /* We don't get a chance to initialize anything before we're called,
347 so handle that now. */
348 init_default_arch ();
350 return s390_arch_size
== 64 ? "elf64-s390" : "elf32-s390";
354 md_parse_option (int c
, char *arg
)
358 /* -k: Ignore for FreeBSD compatibility. */
362 if (arg
!= NULL
&& strcmp (arg
, "regnames") == 0)
365 else if (arg
!= NULL
&& strcmp (arg
, "no-regnames") == 0)
368 else if (arg
!= NULL
&& strcmp (arg
, "warn-areg-zero") == 0)
369 warn_areg_zero
= TRUE
;
371 else if (arg
!= NULL
&& strcmp (arg
, "31") == 0)
374 else if (arg
!= NULL
&& strcmp (arg
, "64") == 0)
377 else if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
378 current_mode_mask
= 1 << S390_OPCODE_ESA
;
380 else if (arg
!= NULL
&& strcmp (arg
, "zarch") == 0)
381 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
383 else if (arg
!= NULL
&& strncmp (arg
, "arch=", 5) == 0)
385 if (strcmp (arg
+ 5, "g5") == 0)
386 current_cpu
= S390_OPCODE_G5
;
387 else if (strcmp (arg
+ 5, "g6") == 0)
388 current_cpu
= S390_OPCODE_G6
;
389 else if (strcmp (arg
+ 5, "z900") == 0)
390 current_cpu
= S390_OPCODE_Z900
;
391 else if (strcmp (arg
+ 5, "z990") == 0)
392 current_cpu
= S390_OPCODE_Z990
;
393 else if (strcmp (arg
+ 5, "z9-109") == 0)
394 current_cpu
= S390_OPCODE_Z9_109
;
395 else if (strcmp (arg
+ 5, "z9-ec") == 0)
396 current_cpu
= S390_OPCODE_Z9_EC
;
397 else if (strcmp (arg
+ 5, "z10") == 0)
398 current_cpu
= S390_OPCODE_Z10
;
399 else if (strcmp (arg
+ 5, "z196") == 0)
400 current_cpu
= S390_OPCODE_Z196
;
401 else if (strcmp (arg
+ 5, "all") == 0)
402 current_cpu
= S390_OPCODE_MAXCPU
- 1;
405 as_bad (_("invalid switch -m%s"), arg
);
412 as_bad (_("invalid switch -m%s"), arg
);
418 /* Option -A is deprecated. Still available for compatibility. */
419 if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
420 current_cpu
= S390_OPCODE_G5
;
421 else if (arg
!= NULL
&& strcmp (arg
, "esame") == 0)
422 current_cpu
= S390_OPCODE_Z900
;
424 as_bad (_("invalid architecture -A%s"), arg
);
427 /* -V: SVR4 argument to print version ID. */
432 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
433 should be emitted or not. FIXME: Not implemented. */
445 md_show_usage (FILE *stream
)
447 fprintf (stream
, _("\
449 -mregnames Allow symbolic names for registers\n\
450 -mwarn-areg-zero Warn about zero base/index registers\n\
451 -mno-regnames Do not allow symbolic names for registers\n\
452 -m31 Set file format to 31 bit format\n\
453 -m64 Set file format to 64 bit format\n"));
454 fprintf (stream
, _("\
455 -V print assembler version number\n\
456 -Qy, -Qn ignored\n"));
459 /* This function is called when the assembler starts up. It is called
460 after the options have been parsed and the output file has been
466 register const struct s390_opcode
*op
;
467 const struct s390_opcode
*op_end
;
468 bfd_boolean dup_insn
= FALSE
;
471 /* Give a warning if the combination -m64-bit and -Aesa is used. */
472 if (s390_arch_size
== 64 && current_cpu
< S390_OPCODE_Z900
)
473 as_warn (_("The 64 bit file format is used without esame instructions."));
475 s390_cie_data_alignment
= -s390_arch_size
/ 8;
477 /* Set the ELF flags if desired. */
479 bfd_set_private_flags (stdoutput
, s390_flags
);
481 /* Insert the opcode formats into a hash table. */
482 s390_opformat_hash
= hash_new ();
484 op_end
= s390_opformats
+ s390_num_opformats
;
485 for (op
= s390_opformats
; op
< op_end
; op
++)
487 retval
= hash_insert (s390_opformat_hash
, op
->name
, (void *) op
);
488 if (retval
!= (const char *) NULL
)
490 as_bad (_("Internal assembler error for instruction format %s"),
496 /* Insert the opcodes into a hash table. */
497 s390_opcode_hash
= hash_new ();
499 op_end
= s390_opcodes
+ s390_num_opcodes
;
500 for (op
= s390_opcodes
; op
< op_end
; op
++)
502 while (op
< op_end
- 1 && strcmp(op
->name
, op
[1].name
) == 0)
504 if (op
->min_cpu
<= current_cpu
&& (op
->modes
& current_mode_mask
))
509 if (op
->min_cpu
<= current_cpu
&& (op
->modes
& current_mode_mask
))
511 retval
= hash_insert (s390_opcode_hash
, op
->name
, (void *) op
);
512 if (retval
!= (const char *) NULL
)
514 as_bad (_("Internal assembler error for instruction %s"),
520 while (op
< op_end
- 1 && strcmp (op
->name
, op
[1].name
) == 0)
527 record_alignment (text_section
, 2);
528 record_alignment (data_section
, 2);
529 record_alignment (bss_section
, 2);
533 /* Called after all assembly has been done. */
537 if (s390_arch_size
== 64)
538 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_64
);
540 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_31
);
543 /* Insert an operand value into an instruction. */
546 s390_insert_operand (unsigned char *insn
,
547 const struct s390_operand
*operand
,
555 if (operand
->flags
& (S390_OPERAND_SIGNED
|S390_OPERAND_PCREL
))
559 max
= ((offsetT
) 1 << (operand
->bits
- 1)) - 1;
560 min
= - ((offsetT
) 1 << (operand
->bits
- 1));
561 /* Halve PCREL operands. */
562 if (operand
->flags
& S390_OPERAND_PCREL
)
564 /* Check for underflow / overflow. */
565 if (val
< min
|| val
> max
)
568 _("operand out of range (%s not between %ld and %ld)");
571 if (operand
->flags
& S390_OPERAND_PCREL
)
577 sprint_value (buf
, val
);
578 if (file
== (char *) NULL
)
579 as_bad (err
, buf
, (int) min
, (int) max
);
581 as_bad_where (file
, line
, err
, buf
, (int) min
, (int) max
);
584 /* val is ok, now restrict it to operand->bits bits. */
585 uval
= (addressT
) val
& ((((addressT
) 1 << (operand
->bits
-1)) << 1) - 1);
586 /* val is restrict, now check for special case. */
587 if (operand
->bits
== 20 && operand
->shift
== 20)
588 uval
= (uval
>> 12) | ((uval
& 0xfff) << 8);
594 max
= (((addressT
) 1 << (operand
->bits
- 1)) << 1) - 1;
596 uval
= (addressT
) val
;
597 /* Length x in an instructions has real length x+1. */
598 if (operand
->flags
& S390_OPERAND_LENGTH
)
600 /* Check for underflow / overflow. */
601 if (uval
< min
|| uval
> max
)
603 if (operand
->flags
& S390_OPERAND_LENGTH
)
610 as_bad_value_out_of_range (_("operand"), uval
, (offsetT
) min
, (offsetT
) max
, file
, line
);
616 /* Insert fragments of the operand byte for byte. */
617 offset
= operand
->shift
+ operand
->bits
;
618 uval
<<= (-offset
) & 7;
619 insn
+= (offset
- 1) / 8;
631 bfd_reloc_code_real_type reloc
;
634 /* Parse tls marker and return the desired relocation. */
635 static bfd_reloc_code_real_type
636 s390_tls_suffix (char **str_p
, expressionS
*exp_p
)
638 static struct map_tls mapping
[] =
640 { "tls_load", 8, BFD_RELOC_390_TLS_LOAD
},
641 { "tls_gdcall", 10, BFD_RELOC_390_TLS_GDCALL
},
642 { "tls_ldcall", 10, BFD_RELOC_390_TLS_LDCALL
},
643 { NULL
, 0, BFD_RELOC_UNUSED
}
653 return BFD_RELOC_UNUSED
;
656 while (ISIDNUM (*str
))
660 return BFD_RELOC_UNUSED
;
662 orig_line
= input_line_pointer
;
663 input_line_pointer
= str
;
665 str
= input_line_pointer
;
666 if (&input_line_pointer
!= str_p
)
667 input_line_pointer
= orig_line
;
669 if (exp_p
->X_op
!= O_symbol
)
670 return BFD_RELOC_UNUSED
;
672 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
673 if (len
== ptr
->length
674 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
676 /* Found a matching tls suffix. */
680 return BFD_RELOC_UNUSED
;
683 /* Structure used to hold suffixes. */
694 ELF_SUFFIX_TLS_GOTIE
,
706 elf_suffix_type suffix
;
710 /* Parse @got/@plt/@gotoff. and return the desired relocation. */
711 static elf_suffix_type
712 s390_elf_suffix (char **str_p
, expressionS
*exp_p
)
714 static struct map_bfd mapping
[] =
716 { "got", 3, ELF_SUFFIX_GOT
},
717 { "got12", 5, ELF_SUFFIX_GOT
},
718 { "plt", 3, ELF_SUFFIX_PLT
},
719 { "gotent", 6, ELF_SUFFIX_GOTENT
},
720 { "gotoff", 6, ELF_SUFFIX_GOTOFF
},
721 { "gotplt", 6, ELF_SUFFIX_GOTPLT
},
722 { "pltoff", 6, ELF_SUFFIX_PLTOFF
},
723 { "tlsgd", 5, ELF_SUFFIX_TLS_GD
},
724 { "gotntpoff", 9, ELF_SUFFIX_TLS_GOTIE
},
725 { "indntpoff", 9, ELF_SUFFIX_TLS_IE
},
726 { "tlsldm", 6, ELF_SUFFIX_TLS_LDM
},
727 { "dtpoff", 6, ELF_SUFFIX_TLS_LDO
},
728 { "ntpoff", 6, ELF_SUFFIX_TLS_LE
},
729 { NULL
, 0, ELF_SUFFIX_NONE
}
738 return ELF_SUFFIX_NONE
;
741 while (ISALNUM (*str
))
745 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
746 if (len
== ptr
->length
747 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
749 if (exp_p
->X_add_number
!= 0)
750 as_warn (_("identifier+constant@%s means identifier@%s+constant"),
751 ptr
->string
, ptr
->string
);
752 /* Now check for identifier@suffix+constant. */
753 if (*str
== '-' || *str
== '+')
755 char *orig_line
= input_line_pointer
;
758 input_line_pointer
= str
;
759 expression (&new_exp
);
761 switch (new_exp
.X_op
)
763 case O_constant
: /* X_add_number (a constant expression). */
764 exp_p
->X_add_number
+= new_exp
.X_add_number
;
765 str
= input_line_pointer
;
767 case O_symbol
: /* X_add_symbol + X_add_number. */
768 /* this case is used for e.g. xyz@PLT+.Label. */
769 exp_p
->X_add_number
+= new_exp
.X_add_number
;
770 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
772 str
= input_line_pointer
;
774 case O_uminus
: /* (- X_add_symbol) + X_add_number. */
775 /* this case is used for e.g. xyz@PLT-.Label. */
776 exp_p
->X_add_number
+= new_exp
.X_add_number
;
777 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
778 exp_p
->X_op
= O_subtract
;
779 str
= input_line_pointer
;
785 /* If s390_elf_suffix has not been called with
786 &input_line_pointer as first parameter, we have
787 clobbered the input_line_pointer. We have to
789 if (&input_line_pointer
!= str_p
)
790 input_line_pointer
= orig_line
;
796 return BFD_RELOC_UNUSED
;
799 /* Structure used to hold a literal pool entry. */
802 struct s390_lpe
*next
;
804 FLONUM_TYPE floatnum
; /* used if X_op == O_big && X_add_number <= 0 */
805 LITTLENUM_TYPE bignum
[4]; /* used if X_op == O_big && X_add_number > 0 */
807 bfd_reloc_code_real_type reloc
;
811 static struct s390_lpe
*lpe_free_list
= NULL
;
812 static struct s390_lpe
*lpe_list
= NULL
;
813 static struct s390_lpe
*lpe_list_tail
= NULL
;
814 static symbolS
*lp_sym
= NULL
;
815 static int lp_count
= 0;
816 static int lpe_count
= 0;
819 s390_exp_compare (expressionS
*exp1
, expressionS
*exp2
)
821 if (exp1
->X_op
!= exp2
->X_op
)
826 case O_constant
: /* X_add_number must be equal. */
828 return exp1
->X_add_number
== exp2
->X_add_number
;
831 as_bad (_("Can't handle O_big in s390_exp_compare"));
833 case O_symbol
: /* X_add_symbol & X_add_number must be equal. */
838 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
839 && (exp1
->X_add_number
== exp2
->X_add_number
);
841 case O_multiply
: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
846 case O_bit_inclusive_or
:
848 case O_bit_exclusive_or
:
860 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
861 && (exp1
->X_op_symbol
== exp2
->X_op_symbol
)
862 && (exp1
->X_add_number
== exp2
->X_add_number
);
868 /* Test for @lit and if its present make an entry in the literal pool and
869 modify the current expression to be an offset into the literal pool. */
870 static elf_suffix_type
871 s390_lit_suffix (char **str_p
, expressionS
*exp_p
, elf_suffix_type suffix
)
873 bfd_reloc_code_real_type reloc
;
877 struct s390_lpe
*lpe
;
881 return suffix
; /* No modification. */
883 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
885 while (ISALNUM (*str
))
888 if (len
!= 4 || strncasecmp (ident
, "lit", 3) != 0
889 || (ident
[3]!='1' && ident
[3]!='2' && ident
[3]!='4' && ident
[3]!='8'))
890 return suffix
; /* no modification */
891 nbytes
= ident
[3] - '0';
893 reloc
= BFD_RELOC_UNUSED
;
894 if (suffix
== ELF_SUFFIX_GOT
)
897 reloc
= BFD_RELOC_390_GOT16
;
898 else if (nbytes
== 4)
899 reloc
= BFD_RELOC_32_GOT_PCREL
;
900 else if (nbytes
== 8)
901 reloc
= BFD_RELOC_390_GOT64
;
903 else if (suffix
== ELF_SUFFIX_PLT
)
906 reloc
= BFD_RELOC_390_PLT32
;
907 else if (nbytes
== 8)
908 reloc
= BFD_RELOC_390_PLT64
;
911 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
912 as_bad (_("Invalid suffix for literal pool entry"));
914 /* Search the pool if the new entry is a duplicate. */
915 if (exp_p
->X_op
== O_big
)
917 /* Special processing for big numbers. */
918 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
920 if (lpe
->ex
.X_op
== O_big
)
922 if (exp_p
->X_add_number
<= 0 && lpe
->ex
.X_add_number
<= 0)
924 if (memcmp (&generic_floating_point_number
, &lpe
->floatnum
,
925 sizeof (FLONUM_TYPE
)) == 0)
928 else if (exp_p
->X_add_number
== lpe
->ex
.X_add_number
)
930 if (memcmp (generic_bignum
, lpe
->bignum
,
931 sizeof (LITTLENUM_TYPE
)*exp_p
->X_add_number
) == 0)
939 /* Processing for 'normal' data types. */
940 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
941 if (lpe
->nbytes
== nbytes
&& lpe
->reloc
== reloc
942 && s390_exp_compare (exp_p
, &lpe
->ex
) != 0)
949 if (lpe_free_list
!= NULL
)
952 lpe_free_list
= lpe_free_list
->next
;
956 lpe
= (struct s390_lpe
*) xmalloc (sizeof (struct s390_lpe
));
961 if (exp_p
->X_op
== O_big
)
963 if (exp_p
->X_add_number
<= 0)
964 lpe
->floatnum
= generic_floating_point_number
;
965 else if (exp_p
->X_add_number
<= 4)
966 memcpy (lpe
->bignum
, generic_bignum
,
967 exp_p
->X_add_number
* sizeof (LITTLENUM_TYPE
));
969 as_bad (_("Big number is too big"));
972 lpe
->nbytes
= nbytes
;
974 /* Literal pool name defined ? */
977 sprintf (tmp_name
, ".L\001%i", lp_count
);
978 lp_sym
= symbol_make (tmp_name
);
981 /* Make name for literal pool entry. */
982 sprintf (tmp_name
, ".L\001%i\002%i", lp_count
, lpe_count
);
984 lpe
->sym
= symbol_make (tmp_name
);
986 /* Add to literal pool list. */
988 if (lpe_list_tail
!= NULL
)
990 lpe_list_tail
->next
= lpe
;
994 lpe_list
= lpe_list_tail
= lpe
;
997 /* Now change exp_p to the offset into the literal pool.
998 Thats the expression: .L^Ax^By-.L^Ax */
999 exp_p
->X_add_symbol
= lpe
->sym
;
1000 exp_p
->X_op_symbol
= lp_sym
;
1001 exp_p
->X_op
= O_subtract
;
1002 exp_p
->X_add_number
= 0;
1006 /* We change the suffix type to ELF_SUFFIX_NONE, because
1007 the difference of two local labels is just a number. */
1008 return ELF_SUFFIX_NONE
;
1011 /* Like normal .long/.short/.word, except support @got, etc.
1012 clobbers input_line_pointer, checks end-of-line. */
1014 s390_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long */)
1017 elf_suffix_type suffix
;
1019 if (is_it_end_of_statement ())
1021 demand_empty_rest_of_line ();
1029 if (exp
.X_op
== O_symbol
1030 && *input_line_pointer
== '@'
1031 && (suffix
= s390_elf_suffix (&input_line_pointer
, &exp
)) != ELF_SUFFIX_NONE
)
1033 bfd_reloc_code_real_type reloc
;
1034 reloc_howto_type
*reloc_howto
;
1040 static bfd_reloc_code_real_type tab2
[] =
1042 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1043 BFD_RELOC_390_GOT16
, /* ELF_SUFFIX_GOT */
1044 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_PLT */
1045 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1046 BFD_RELOC_16_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1047 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTPLT */
1048 BFD_RELOC_390_PLTOFF16
, /* ELF_SUFFIX_PLTOFF */
1049 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GD */
1050 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GOTIE */
1051 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_IE */
1052 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDM */
1053 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDO */
1054 BFD_RELOC_UNUSED
/* ELF_SUFFIX_TLS_LE */
1056 reloc
= tab2
[suffix
];
1058 else if (nbytes
== 4)
1060 static bfd_reloc_code_real_type tab4
[] =
1062 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1063 BFD_RELOC_32_GOT_PCREL
, /* ELF_SUFFIX_GOT */
1064 BFD_RELOC_390_PLT32
, /* ELF_SUFFIX_PLT */
1065 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1066 BFD_RELOC_32_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1067 BFD_RELOC_390_GOTPLT32
, /* ELF_SUFFIX_GOTPLT */
1068 BFD_RELOC_390_PLTOFF32
, /* ELF_SUFFIX_PLTOFF */
1069 BFD_RELOC_390_TLS_GD32
, /* ELF_SUFFIX_TLS_GD */
1070 BFD_RELOC_390_TLS_GOTIE32
, /* ELF_SUFFIX_TLS_GOTIE */
1071 BFD_RELOC_390_TLS_IE32
, /* ELF_SUFFIX_TLS_IE */
1072 BFD_RELOC_390_TLS_LDM32
, /* ELF_SUFFIX_TLS_LDM */
1073 BFD_RELOC_390_TLS_LDO32
, /* ELF_SUFFIX_TLS_LDO */
1074 BFD_RELOC_390_TLS_LE32
/* ELF_SUFFIX_TLS_LE */
1076 reloc
= tab4
[suffix
];
1078 else if (nbytes
== 8)
1080 static bfd_reloc_code_real_type tab8
[] =
1082 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1083 BFD_RELOC_390_GOT64
, /* ELF_SUFFIX_GOT */
1084 BFD_RELOC_390_PLT64
, /* ELF_SUFFIX_PLT */
1085 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1086 BFD_RELOC_390_GOTOFF64
, /* ELF_SUFFIX_GOTOFF */
1087 BFD_RELOC_390_GOTPLT64
, /* ELF_SUFFIX_GOTPLT */
1088 BFD_RELOC_390_PLTOFF64
, /* ELF_SUFFIX_PLTOFF */
1089 BFD_RELOC_390_TLS_GD64
, /* ELF_SUFFIX_TLS_GD */
1090 BFD_RELOC_390_TLS_GOTIE64
, /* ELF_SUFFIX_TLS_GOTIE */
1091 BFD_RELOC_390_TLS_IE64
, /* ELF_SUFFIX_TLS_IE */
1092 BFD_RELOC_390_TLS_LDM64
, /* ELF_SUFFIX_TLS_LDM */
1093 BFD_RELOC_390_TLS_LDO64
, /* ELF_SUFFIX_TLS_LDO */
1094 BFD_RELOC_390_TLS_LE64
/* ELF_SUFFIX_TLS_LE */
1096 reloc
= tab8
[suffix
];
1099 reloc
= BFD_RELOC_UNUSED
;
1101 if (reloc
!= BFD_RELOC_UNUSED
1102 && (reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
)))
1104 size
= bfd_get_reloc_size (reloc_howto
);
1106 as_bad (_("%s relocations do not fit in %d bytes"),
1107 reloc_howto
->name
, nbytes
);
1108 where
= frag_more (nbytes
);
1109 md_number_to_chars (where
, 0, size
);
1110 /* To make fixup_segment do the pc relative conversion the
1111 pcrel parameter on the fix_new_exp call needs to be FALSE. */
1112 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1113 size
, &exp
, FALSE
, reloc
);
1116 as_bad (_("relocation not applicable"));
1119 emit_expr (&exp
, (unsigned int) nbytes
);
1121 while (*input_line_pointer
++ == ',');
1123 input_line_pointer
--; /* Put terminator back into stream. */
1124 demand_empty_rest_of_line ();
1127 /* We need to keep a list of fixups. We can't simply generate them as
1128 we go, because that would require us to first create the frag, and
1129 that would screw up references to ``.''. */
1135 bfd_reloc_code_real_type reloc
;
1138 #define MAX_INSN_FIXUPS (4)
1140 /* This routine is called for each instruction to be assembled. */
1143 md_gather_operands (char *str
,
1144 unsigned char *insn
,
1145 const struct s390_opcode
*opcode
)
1147 struct s390_fixup fixups
[MAX_INSN_FIXUPS
];
1148 const struct s390_operand
*operand
;
1149 const unsigned char *opindex_ptr
;
1151 elf_suffix_type suffix
;
1152 bfd_reloc_code_real_type reloc
;
1157 while (ISSPACE (*str
))
1162 /* Gather the operands. */
1164 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1168 operand
= s390_operands
+ *opindex_ptr
;
1170 if (skip_optional
&& (operand
->flags
& S390_OPERAND_INDEX
))
1172 /* We do an early skip. For D(X,B) constructions the index
1173 register is skipped (X is optional). For D(L,B) the base
1174 register will be the skipped operand, because L is NOT
1180 /* Gather the operand. */
1181 hold
= input_line_pointer
;
1182 input_line_pointer
= str
;
1184 /* Parse the operand. */
1185 if (! register_name (&ex
))
1188 str
= input_line_pointer
;
1189 input_line_pointer
= hold
;
1191 /* Write the operand to the insn. */
1192 if (ex
.X_op
== O_illegal
)
1193 as_bad (_("illegal operand"));
1194 else if (ex
.X_op
== O_absent
)
1196 /* No operands, check if all operands can be skipped. */
1197 while (*opindex_ptr
!= 0 && operand
->flags
& S390_OPERAND_OPTIONAL
)
1199 if (operand
->flags
& S390_OPERAND_DISP
)
1201 /* An optional displacement makes the whole D(X,B)
1202 D(L,B) or D(B) block optional. */
1204 operand
= s390_operands
+ *(++opindex_ptr
);
1205 } while (!(operand
->flags
& S390_OPERAND_BASE
));
1207 operand
= s390_operands
+ *(++opindex_ptr
);
1209 if (opindex_ptr
[0] == '\0')
1211 as_bad (_("missing operand"));
1213 else if (ex
.X_op
== O_register
|| ex
.X_op
== O_constant
)
1215 s390_lit_suffix (&str
, &ex
, ELF_SUFFIX_NONE
);
1217 if (ex
.X_op
!= O_register
&& ex
.X_op
!= O_constant
)
1219 /* We need to generate a fixup for the
1220 expression returned by s390_lit_suffix. */
1221 if (fc
>= MAX_INSN_FIXUPS
)
1222 as_fatal (_("too many fixups"));
1223 fixups
[fc
].exp
= ex
;
1224 fixups
[fc
].opindex
= *opindex_ptr
;
1225 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
1230 if ((operand
->flags
& S390_OPERAND_INDEX
)
1231 && ex
.X_add_number
== 0
1233 as_warn (_("index register specified but zero"));
1234 if ((operand
->flags
& S390_OPERAND_BASE
)
1235 && ex
.X_add_number
== 0
1237 as_warn (_("base register specified but zero"));
1238 s390_insert_operand (insn
, operand
, ex
.X_add_number
, NULL
, 0);
1243 suffix
= s390_elf_suffix (&str
, &ex
);
1244 suffix
= s390_lit_suffix (&str
, &ex
, suffix
);
1245 reloc
= BFD_RELOC_UNUSED
;
1247 if (suffix
== ELF_SUFFIX_GOT
)
1249 if ((operand
->flags
& S390_OPERAND_DISP
) &&
1250 (operand
->bits
== 12))
1251 reloc
= BFD_RELOC_390_GOT12
;
1252 else if ((operand
->flags
& S390_OPERAND_DISP
) &&
1253 (operand
->bits
== 20))
1254 reloc
= BFD_RELOC_390_GOT20
;
1255 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1256 && (operand
->bits
== 16))
1257 reloc
= BFD_RELOC_390_GOT16
;
1258 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1259 && (operand
->bits
== 32))
1260 reloc
= BFD_RELOC_390_GOTENT
;
1262 else if (suffix
== ELF_SUFFIX_PLT
)
1264 if ((operand
->flags
& S390_OPERAND_PCREL
)
1265 && (operand
->bits
== 16))
1266 reloc
= BFD_RELOC_390_PLT16DBL
;
1267 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1268 && (operand
->bits
== 32))
1269 reloc
= BFD_RELOC_390_PLT32DBL
;
1271 else if (suffix
== ELF_SUFFIX_GOTENT
)
1273 if ((operand
->flags
& S390_OPERAND_PCREL
)
1274 && (operand
->bits
== 32))
1275 reloc
= BFD_RELOC_390_GOTENT
;
1277 else if (suffix
== ELF_SUFFIX_GOTOFF
)
1279 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1280 && (operand
->bits
== 16))
1281 reloc
= BFD_RELOC_16_GOTOFF
;
1283 else if (suffix
== ELF_SUFFIX_PLTOFF
)
1285 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1286 && (operand
->bits
== 16))
1287 reloc
= BFD_RELOC_390_PLTOFF16
;
1289 else if (suffix
== ELF_SUFFIX_GOTPLT
)
1291 if ((operand
->flags
& S390_OPERAND_DISP
)
1292 && (operand
->bits
== 12))
1293 reloc
= BFD_RELOC_390_GOTPLT12
;
1294 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1295 && (operand
->bits
== 16))
1296 reloc
= BFD_RELOC_390_GOTPLT16
;
1297 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1298 && (operand
->bits
== 32))
1299 reloc
= BFD_RELOC_390_GOTPLTENT
;
1301 else if (suffix
== ELF_SUFFIX_TLS_GOTIE
)
1303 if ((operand
->flags
& S390_OPERAND_DISP
)
1304 && (operand
->bits
== 12))
1305 reloc
= BFD_RELOC_390_TLS_GOTIE12
;
1306 else if ((operand
->flags
& S390_OPERAND_DISP
)
1307 && (operand
->bits
== 20))
1308 reloc
= BFD_RELOC_390_TLS_GOTIE20
;
1310 else if (suffix
== ELF_SUFFIX_TLS_IE
)
1312 if ((operand
->flags
& S390_OPERAND_PCREL
)
1313 && (operand
->bits
== 32))
1314 reloc
= BFD_RELOC_390_TLS_IEENT
;
1317 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
1318 as_bad (_("invalid operand suffix"));
1319 /* We need to generate a fixup of type 'reloc' for this
1321 if (fc
>= MAX_INSN_FIXUPS
)
1322 as_fatal (_("too many fixups"));
1323 fixups
[fc
].exp
= ex
;
1324 fixups
[fc
].opindex
= *opindex_ptr
;
1325 fixups
[fc
].reloc
= reloc
;
1329 /* Check the next character. The call to expression has advanced
1330 str past any whitespace. */
1331 if (operand
->flags
& S390_OPERAND_DISP
)
1333 /* After a displacement a block in parentheses can start. */
1336 /* Check if parenthesized block can be skipped. If the next
1337 operand is neiter an optional operand nor a base register
1338 then we have a syntax error. */
1339 operand
= s390_operands
+ *(++opindex_ptr
);
1340 if (!(operand
->flags
& (S390_OPERAND_INDEX
|S390_OPERAND_BASE
)))
1341 as_bad (_("syntax error; missing '(' after displacement"));
1343 /* Ok, skip all operands until S390_OPERAND_BASE. */
1344 while (!(operand
->flags
& S390_OPERAND_BASE
))
1345 operand
= s390_operands
+ *(++opindex_ptr
);
1347 /* If there is a next operand it must be separated by a comma. */
1348 if (opindex_ptr
[1] != '\0')
1352 while (opindex_ptr
[1] != '\0')
1354 operand
= s390_operands
+ *(++opindex_ptr
);
1355 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1357 as_bad (_("syntax error; expected ,"));
1367 /* We found an opening parentheses. */
1369 for (f
= str
; *f
!= '\0'; f
++)
1370 if (*f
== ',' || *f
== ')')
1372 /* If there is no comma until the closing parentheses OR
1373 there is a comma right after the opening parentheses,
1374 we have to skip optional operands. */
1375 if (*f
== ',' && f
== str
)
1377 /* comma directly after '(' ? */
1382 skip_optional
= (*f
!= ',');
1385 else if (operand
->flags
& S390_OPERAND_BASE
)
1387 /* After the base register the parenthesed block ends. */
1389 as_bad (_("syntax error; missing ')' after base register"));
1391 /* If there is a next operand it must be separated by a comma. */
1392 if (opindex_ptr
[1] != '\0')
1396 while (opindex_ptr
[1] != '\0')
1398 operand
= s390_operands
+ *(++opindex_ptr
);
1399 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1401 as_bad (_("syntax error; expected ,"));
1411 /* We can find an 'early' closing parentheses in e.g. D(L) instead
1412 of D(L,B). In this case the base register has to be skipped. */
1415 operand
= s390_operands
+ *(++opindex_ptr
);
1417 if (!(operand
->flags
& S390_OPERAND_BASE
))
1418 as_bad (_("syntax error; ')' not allowed here"));
1421 /* If there is a next operand it must be separated by a comma. */
1422 if (opindex_ptr
[1] != '\0')
1426 while (opindex_ptr
[1] != '\0')
1428 operand
= s390_operands
+ *(++opindex_ptr
);
1429 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1431 as_bad (_("syntax error; expected ,"));
1441 while (ISSPACE (*str
))
1444 /* Check for tls instruction marker. */
1445 reloc
= s390_tls_suffix (&str
, &ex
);
1446 if (reloc
!= BFD_RELOC_UNUSED
)
1448 /* We need to generate a fixup of type 'reloc' for this
1450 if (fc
>= MAX_INSN_FIXUPS
)
1451 as_fatal (_("too many fixups"));
1452 fixups
[fc
].exp
= ex
;
1453 fixups
[fc
].opindex
= -1;
1454 fixups
[fc
].reloc
= reloc
;
1462 if ((linefeed
= strchr (str
, '\n')) != NULL
)
1464 as_bad (_("junk at end of line: `%s'"), str
);
1465 if (linefeed
!= NULL
)
1469 /* Write out the instruction. */
1470 f
= frag_more (opcode
->oplen
);
1471 memcpy (f
, insn
, opcode
->oplen
);
1472 dwarf2_emit_insn (opcode
->oplen
);
1474 /* Create any fixups. At this point we do not use a
1475 bfd_reloc_code_real_type, but instead just use the
1476 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1477 handle fixups for any operand type, although that is admittedly
1478 not a very exciting feature. We pick a BFD reloc type in
1480 for (i
= 0; i
< fc
; i
++)
1483 if (fixups
[i
].opindex
< 0)
1485 /* Create tls instruction marker relocation. */
1486 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, opcode
->oplen
,
1487 &fixups
[i
].exp
, 0, fixups
[i
].reloc
);
1491 operand
= s390_operands
+ fixups
[i
].opindex
;
1493 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
1495 reloc_howto_type
*reloc_howto
;
1499 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
1503 size
= bfd_get_reloc_size (reloc_howto
);
1505 if (size
< 1 || size
> 4)
1508 fixP
= fix_new_exp (frag_now
,
1509 f
- frag_now
->fr_literal
+ (operand
->shift
/8),
1510 size
, &fixups
[i
].exp
, reloc_howto
->pc_relative
,
1512 /* Turn off overflow checking in fixup_segment. This is necessary
1513 because fixup_segment will signal an overflow for large 4 byte
1514 quantities for GOT12 relocations. */
1515 if ( fixups
[i
].reloc
== BFD_RELOC_390_GOT12
1516 || fixups
[i
].reloc
== BFD_RELOC_390_GOT20
1517 || fixups
[i
].reloc
== BFD_RELOC_390_GOT16
)
1518 fixP
->fx_no_overflow
= 1;
1521 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4, &fixups
[i
].exp
,
1522 (operand
->flags
& S390_OPERAND_PCREL
) != 0,
1523 ((bfd_reloc_code_real_type
)
1524 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
1529 /* This routine is called for each instruction to be assembled. */
1532 md_assemble (char *str
)
1534 const struct s390_opcode
*opcode
;
1535 unsigned char insn
[6];
1538 /* Get the opcode. */
1539 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1544 /* Look up the opcode in the hash table. */
1545 opcode
= (struct s390_opcode
*) hash_find (s390_opcode_hash
, str
);
1546 if (opcode
== (const struct s390_opcode
*) NULL
)
1548 as_bad (_("Unrecognized opcode: `%s'"), str
);
1551 else if (!(opcode
->modes
& current_mode_mask
))
1553 as_bad (_("Opcode %s not available in this mode"), str
);
1556 memcpy (insn
, opcode
->opcode
, sizeof (insn
));
1557 md_gather_operands (s
, insn
, opcode
);
1560 #ifndef WORKING_DOT_WORD
1561 /* Handle long and short jumps. We don't support these */
1563 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1565 addressT from_addr
, to_addr
;
1573 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1575 addressT from_addr
, to_addr
;
1584 s390_bss (int ignore ATTRIBUTE_UNUSED
)
1586 /* We don't support putting frags in the BSS segment, we fake it
1587 by marking in_bss, then looking at s_skip for clues. */
1589 subseg_set (bss_section
, 0);
1590 demand_empty_rest_of_line ();
1593 /* Pseudo-op handling. */
1596 s390_insn (int ignore ATTRIBUTE_UNUSED
)
1599 const struct s390_opcode
*opformat
;
1600 unsigned char insn
[6];
1603 /* Get the opcode format. */
1604 s
= input_line_pointer
;
1605 while (*s
!= '\0' && *s
!= ',' && ! ISSPACE (*s
))
1608 as_bad (_("Invalid .insn format\n"));
1611 /* Look up the opcode in the hash table. */
1612 opformat
= (struct s390_opcode
*)
1613 hash_find (s390_opformat_hash
, input_line_pointer
);
1614 if (opformat
== (const struct s390_opcode
*) NULL
)
1616 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer
);
1619 input_line_pointer
= s
;
1621 if (exp
.X_op
== O_constant
)
1623 if ( ( opformat
->oplen
== 6
1624 && (addressT
) exp
.X_add_number
< (1ULL << 48))
1625 || ( opformat
->oplen
== 4
1626 && (addressT
) exp
.X_add_number
< (1ULL << 32))
1627 || ( opformat
->oplen
== 2
1628 && (addressT
) exp
.X_add_number
< (1ULL << 16)))
1629 md_number_to_chars ((char *) insn
, exp
.X_add_number
, opformat
->oplen
);
1631 as_bad (_("Invalid .insn format\n"));
1633 else if (exp
.X_op
== O_big
)
1635 if (exp
.X_add_number
> 0
1636 && opformat
->oplen
== 6
1637 && generic_bignum
[3] == 0)
1639 md_number_to_chars ((char *) insn
, generic_bignum
[2], 2);
1640 md_number_to_chars ((char *) &insn
[2], generic_bignum
[1], 2);
1641 md_number_to_chars ((char *) &insn
[4], generic_bignum
[0], 2);
1644 as_bad (_("Invalid .insn format\n"));
1647 as_bad (_("second operand of .insn not a constant\n"));
1649 if (strcmp (opformat
->name
, "e") != 0 && *input_line_pointer
++ != ',')
1650 as_bad (_("missing comma after insn constant\n"));
1652 if ((s
= strchr (input_line_pointer
, '\n')) != NULL
)
1654 input_line_pointer
= md_gather_operands (input_line_pointer
, insn
,
1658 demand_empty_rest_of_line ();
1661 /* The .byte pseudo-op. This is similar to the normal .byte
1662 pseudo-op, but it can also take a single ASCII string. */
1665 s390_byte (int ignore ATTRIBUTE_UNUSED
)
1667 if (*input_line_pointer
!= '\"')
1673 /* Gather characters. A real double quote is doubled. Unusual
1674 characters are not permitted. */
1675 ++input_line_pointer
;
1680 c
= *input_line_pointer
++;
1684 if (*input_line_pointer
!= '\"')
1686 ++input_line_pointer
;
1689 FRAG_APPEND_1_CHAR (c
);
1692 demand_empty_rest_of_line ();
1695 /* The .ltorg pseudo-op.This emits all literals defined since the last
1696 .ltorg or the invocation of gas. Literals are defined with the
1700 s390_literals (int ignore ATTRIBUTE_UNUSED
)
1702 struct s390_lpe
*lpe
;
1704 if (lp_sym
== NULL
|| lpe_count
== 0)
1705 return; /* Nothing to be done. */
1707 /* Emit symbol for start of literal pool. */
1708 S_SET_SEGMENT (lp_sym
, now_seg
);
1709 S_SET_VALUE (lp_sym
, (valueT
) frag_now_fix ());
1710 lp_sym
->sy_frag
= frag_now
;
1715 lpe_list
= lpe_list
->next
;
1716 S_SET_SEGMENT (lpe
->sym
, now_seg
);
1717 S_SET_VALUE (lpe
->sym
, (valueT
) frag_now_fix ());
1718 lpe
->sym
->sy_frag
= frag_now
;
1720 /* Emit literal pool entry. */
1721 if (lpe
->reloc
!= BFD_RELOC_UNUSED
)
1723 reloc_howto_type
*reloc_howto
=
1724 bfd_reloc_type_lookup (stdoutput
, lpe
->reloc
);
1725 int size
= bfd_get_reloc_size (reloc_howto
);
1728 if (size
> lpe
->nbytes
)
1729 as_bad (_("%s relocations do not fit in %d bytes"),
1730 reloc_howto
->name
, lpe
->nbytes
);
1731 where
= frag_more (lpe
->nbytes
);
1732 md_number_to_chars (where
, 0, size
);
1733 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1734 size
, &lpe
->ex
, reloc_howto
->pc_relative
, lpe
->reloc
);
1738 if (lpe
->ex
.X_op
== O_big
)
1740 if (lpe
->ex
.X_add_number
<= 0)
1741 generic_floating_point_number
= lpe
->floatnum
;
1743 memcpy (generic_bignum
, lpe
->bignum
,
1744 lpe
->ex
.X_add_number
* sizeof (LITTLENUM_TYPE
));
1746 emit_expr (&lpe
->ex
, lpe
->nbytes
);
1749 lpe
->next
= lpe_free_list
;
1750 lpe_free_list
= lpe
;
1752 lpe_list_tail
= NULL
;
1759 md_atof (int type
, char *litp
, int *sizep
)
1761 return ieee_md_atof (type
, litp
, sizep
, TRUE
);
1764 /* Align a section (I don't know why this is machine dependent). */
1767 md_section_align (asection
*seg
, valueT addr
)
1769 int align
= bfd_get_section_alignment (stdoutput
, seg
);
1771 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
1774 /* We don't have any form of relaxing. */
1777 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
1778 asection
*seg ATTRIBUTE_UNUSED
)
1784 /* Convert a machine dependent frag. We never generate these. */
1787 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
1788 asection
*sec ATTRIBUTE_UNUSED
,
1789 fragS
*fragp ATTRIBUTE_UNUSED
)
1795 md_undefined_symbol (char *name
)
1797 if (*name
== '_' && *(name
+ 1) == 'G'
1798 && strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
1802 if (symbol_find (name
))
1803 as_bad (_("GOT already in symbol table"));
1804 GOT_symbol
= symbol_new (name
, undefined_section
,
1805 (valueT
) 0, &zero_address_frag
);
1812 /* Functions concerning relocs. */
1814 /* The location from which a PC relative jump should be calculated,
1815 given a PC relative reloc. */
1818 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
1820 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
1823 /* Here we decide which fixups can be adjusted to make them relative to
1824 the beginning of the section instead of the symbol. Basically we need
1825 to make sure that the dynamic relocations are done correctly, so in
1826 some cases we force the original symbol to be used. */
1828 tc_s390_fix_adjustable (fixS
*fixP
)
1830 /* Don't adjust references to merge sections. */
1831 if ((S_GET_SEGMENT (fixP
->fx_addsy
)->flags
& SEC_MERGE
) != 0)
1833 /* adjust_reloc_syms doesn't know about the GOT. */
1834 if ( fixP
->fx_r_type
== BFD_RELOC_16_GOTOFF
1835 || fixP
->fx_r_type
== BFD_RELOC_32_GOTOFF
1836 || fixP
->fx_r_type
== BFD_RELOC_390_GOTOFF64
1837 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF16
1838 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF32
1839 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF64
1840 || fixP
->fx_r_type
== BFD_RELOC_390_PLT16DBL
1841 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32
1842 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32DBL
1843 || fixP
->fx_r_type
== BFD_RELOC_390_PLT64
1844 || fixP
->fx_r_type
== BFD_RELOC_390_GOT12
1845 || fixP
->fx_r_type
== BFD_RELOC_390_GOT20
1846 || fixP
->fx_r_type
== BFD_RELOC_390_GOT16
1847 || fixP
->fx_r_type
== BFD_RELOC_32_GOT_PCREL
1848 || fixP
->fx_r_type
== BFD_RELOC_390_GOT64
1849 || fixP
->fx_r_type
== BFD_RELOC_390_GOTENT
1850 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT12
1851 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT16
1852 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT20
1853 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT32
1854 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT64
1855 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLTENT
1856 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LOAD
1857 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GDCALL
1858 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDCALL
1859 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD32
1860 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD64
1861 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE12
1862 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE20
1863 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE32
1864 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE64
1865 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM32
1866 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM64
1867 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE32
1868 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE64
1869 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IEENT
1870 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE32
1871 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE64
1872 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO32
1873 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO64
1874 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPMOD
1875 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPOFF
1876 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_TPOFF
1877 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
1878 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
1883 /* Return true if we must always emit a reloc for a type and false if
1884 there is some hope of resolving it at assembly time. */
1886 tc_s390_force_relocation (struct fix
*fixp
)
1888 /* Ensure we emit a relocation for every reference to the global
1889 offset table or to the procedure link table. */
1890 switch (fixp
->fx_r_type
)
1892 case BFD_RELOC_390_GOT12
:
1893 case BFD_RELOC_390_GOT20
:
1894 case BFD_RELOC_32_GOT_PCREL
:
1895 case BFD_RELOC_32_GOTOFF
:
1896 case BFD_RELOC_390_GOTOFF64
:
1897 case BFD_RELOC_390_PLTOFF16
:
1898 case BFD_RELOC_390_PLTOFF32
:
1899 case BFD_RELOC_390_PLTOFF64
:
1900 case BFD_RELOC_390_GOTPC
:
1901 case BFD_RELOC_390_GOT16
:
1902 case BFD_RELOC_390_GOTPCDBL
:
1903 case BFD_RELOC_390_GOT64
:
1904 case BFD_RELOC_390_GOTENT
:
1905 case BFD_RELOC_390_PLT32
:
1906 case BFD_RELOC_390_PLT16DBL
:
1907 case BFD_RELOC_390_PLT32DBL
:
1908 case BFD_RELOC_390_PLT64
:
1909 case BFD_RELOC_390_GOTPLT12
:
1910 case BFD_RELOC_390_GOTPLT16
:
1911 case BFD_RELOC_390_GOTPLT20
:
1912 case BFD_RELOC_390_GOTPLT32
:
1913 case BFD_RELOC_390_GOTPLT64
:
1914 case BFD_RELOC_390_GOTPLTENT
:
1920 return generic_force_reloc (fixp
);
1923 /* Apply a fixup to the object code. This is called for all the
1924 fixups we generated by the call to fix_new_exp, above. In the call
1925 above we used a reloc code which was the largest legal reloc code
1926 plus the operand index. Here we undo that to recover the operand
1927 index. At this point all symbol values should be fully resolved,
1928 and we attempt to completely resolve the reloc. If we can not do
1929 that, we determine the correct reloc code and put it back in the
1933 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
1936 valueT value
= *valP
;
1938 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
1940 if (fixP
->fx_subsy
!= NULL
)
1941 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1942 _("cannot emit relocation %s against subsy symbol %s"),
1943 bfd_get_reloc_code_name (fixP
->fx_r_type
),
1944 S_GET_NAME (fixP
->fx_subsy
));
1946 if (fixP
->fx_addsy
!= NULL
)
1949 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
1954 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
1956 const struct s390_operand
*operand
;
1959 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
1960 operand
= &s390_operands
[opindex
];
1964 /* Insert the fully resolved operand value. */
1965 s390_insert_operand ((unsigned char *) where
, operand
,
1966 (offsetT
) value
, fixP
->fx_file
, fixP
->fx_line
);
1970 /* Determine a BFD reloc value based on the operand information.
1971 We are only prepared to turn a few of the operands into
1973 fixP
->fx_offset
= value
;
1974 if (operand
->bits
== 12 && operand
->shift
== 20)
1977 fixP
->fx_where
+= 2;
1978 fixP
->fx_r_type
= BFD_RELOC_390_12
;
1980 else if (operand
->bits
== 12 && operand
->shift
== 36)
1983 fixP
->fx_where
+= 4;
1984 fixP
->fx_r_type
= BFD_RELOC_390_12
;
1986 else if (operand
->bits
== 20 && operand
->shift
== 20)
1989 fixP
->fx_where
+= 2;
1990 fixP
->fx_r_type
= BFD_RELOC_390_20
;
1992 else if (operand
->bits
== 8 && operand
->shift
== 8)
1995 fixP
->fx_where
+= 1;
1996 fixP
->fx_r_type
= BFD_RELOC_8
;
1998 else if (operand
->bits
== 16 && operand
->shift
== 16)
2001 fixP
->fx_where
+= 2;
2002 if (operand
->flags
& S390_OPERAND_PCREL
)
2004 fixP
->fx_r_type
= BFD_RELOC_390_PC16DBL
;
2005 fixP
->fx_offset
+= 2;
2008 fixP
->fx_r_type
= BFD_RELOC_16
;
2010 else if (operand
->bits
== 32 && operand
->shift
== 16
2011 && (operand
->flags
& S390_OPERAND_PCREL
))
2014 fixP
->fx_where
+= 2;
2015 fixP
->fx_offset
+= 2;
2016 fixP
->fx_r_type
= BFD_RELOC_390_PC32DBL
;
2023 /* Use expr_symbol_where to see if this is an expression
2025 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
2026 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2027 _("unresolved expression that must be resolved"));
2029 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2030 _("unsupported relocation type"));
2037 switch (fixP
->fx_r_type
)
2043 md_number_to_chars (where
, value
, 1);
2045 case BFD_RELOC_390_12
:
2046 case BFD_RELOC_390_GOT12
:
2047 case BFD_RELOC_390_GOTPLT12
:
2052 mop
= bfd_getb16 ((unsigned char *) where
);
2053 mop
|= (unsigned short) (value
& 0xfff);
2054 bfd_putb16 ((bfd_vma
) mop
, (unsigned char *) where
);
2058 case BFD_RELOC_390_20
:
2059 case BFD_RELOC_390_GOT20
:
2060 case BFD_RELOC_390_GOTPLT20
:
2064 mop
= bfd_getb32 ((unsigned char *) where
);
2065 mop
|= (unsigned int) ((value
& 0xfff) << 8 |
2066 (value
& 0xff000) >> 12);
2067 bfd_putb32 ((bfd_vma
) mop
, (unsigned char *) where
);
2072 case BFD_RELOC_GPREL16
:
2073 case BFD_RELOC_16_GOT_PCREL
:
2074 case BFD_RELOC_16_GOTOFF
:
2076 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2077 _("cannot emit PC relative %s relocation%s%s"),
2078 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2079 fixP
->fx_addsy
!= NULL
? " against " : "",
2080 (fixP
->fx_addsy
!= NULL
2081 ? S_GET_NAME (fixP
->fx_addsy
)
2084 md_number_to_chars (where
, value
, 2);
2086 case BFD_RELOC_390_GOT16
:
2087 case BFD_RELOC_390_PLTOFF16
:
2088 case BFD_RELOC_390_GOTPLT16
:
2090 md_number_to_chars (where
, value
, 2);
2092 case BFD_RELOC_390_PC16DBL
:
2093 case BFD_RELOC_390_PLT16DBL
:
2096 md_number_to_chars (where
, (offsetT
) value
>> 1, 2);
2101 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2103 fixP
->fx_r_type
= BFD_RELOC_32
;
2105 md_number_to_chars (where
, value
, 4);
2107 case BFD_RELOC_32_PCREL
:
2108 case BFD_RELOC_32_BASEREL
:
2109 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2111 md_number_to_chars (where
, value
, 4);
2113 case BFD_RELOC_32_GOT_PCREL
:
2114 case BFD_RELOC_390_PLTOFF32
:
2115 case BFD_RELOC_390_PLT32
:
2116 case BFD_RELOC_390_GOTPLT32
:
2118 md_number_to_chars (where
, value
, 4);
2120 case BFD_RELOC_390_PC32DBL
:
2121 case BFD_RELOC_390_PLT32DBL
:
2122 case BFD_RELOC_390_GOTPCDBL
:
2123 case BFD_RELOC_390_GOTENT
:
2124 case BFD_RELOC_390_GOTPLTENT
:
2127 md_number_to_chars (where
, (offsetT
) value
>> 1, 4);
2130 case BFD_RELOC_32_GOTOFF
:
2132 md_number_to_chars (where
, value
, sizeof (int));
2135 case BFD_RELOC_390_GOTOFF64
:
2137 md_number_to_chars (where
, value
, 8);
2140 case BFD_RELOC_390_GOT64
:
2141 case BFD_RELOC_390_PLTOFF64
:
2142 case BFD_RELOC_390_PLT64
:
2143 case BFD_RELOC_390_GOTPLT64
:
2145 md_number_to_chars (where
, value
, 8);
2150 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2152 fixP
->fx_r_type
= BFD_RELOC_64
;
2154 md_number_to_chars (where
, value
, 8);
2157 case BFD_RELOC_64_PCREL
:
2158 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2160 md_number_to_chars (where
, value
, 8);
2163 case BFD_RELOC_VTABLE_INHERIT
:
2164 case BFD_RELOC_VTABLE_ENTRY
:
2168 case BFD_RELOC_390_TLS_LOAD
:
2169 case BFD_RELOC_390_TLS_GDCALL
:
2170 case BFD_RELOC_390_TLS_LDCALL
:
2171 case BFD_RELOC_390_TLS_GD32
:
2172 case BFD_RELOC_390_TLS_GD64
:
2173 case BFD_RELOC_390_TLS_GOTIE12
:
2174 case BFD_RELOC_390_TLS_GOTIE20
:
2175 case BFD_RELOC_390_TLS_GOTIE32
:
2176 case BFD_RELOC_390_TLS_GOTIE64
:
2177 case BFD_RELOC_390_TLS_LDM32
:
2178 case BFD_RELOC_390_TLS_LDM64
:
2179 case BFD_RELOC_390_TLS_IE32
:
2180 case BFD_RELOC_390_TLS_IE64
:
2181 case BFD_RELOC_390_TLS_LE32
:
2182 case BFD_RELOC_390_TLS_LE64
:
2183 case BFD_RELOC_390_TLS_LDO32
:
2184 case BFD_RELOC_390_TLS_LDO64
:
2185 case BFD_RELOC_390_TLS_DTPMOD
:
2186 case BFD_RELOC_390_TLS_DTPOFF
:
2187 case BFD_RELOC_390_TLS_TPOFF
:
2188 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2189 /* Fully resolved at link time. */
2191 case BFD_RELOC_390_TLS_IEENT
:
2192 /* Fully resolved at link time. */
2193 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2199 const char *reloc_name
= bfd_get_reloc_code_name (fixP
->fx_r_type
);
2201 if (reloc_name
!= NULL
)
2202 as_fatal (_("Gas failure, reloc type %s\n"), reloc_name
);
2204 as_fatal (_("Gas failure, reloc type #%i\n"), fixP
->fx_r_type
);
2208 fixP
->fx_offset
= value
;
2212 /* Generate a reloc for a fixup. */
2215 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
2217 bfd_reloc_code_real_type code
;
2220 code
= fixp
->fx_r_type
;
2221 if (GOT_symbol
&& fixp
->fx_addsy
== GOT_symbol
)
2223 if ( (s390_arch_size
== 32 && code
== BFD_RELOC_32_PCREL
)
2224 || (s390_arch_size
== 64 && code
== BFD_RELOC_64_PCREL
))
2225 code
= BFD_RELOC_390_GOTPC
;
2226 if (code
== BFD_RELOC_390_PC32DBL
)
2227 code
= BFD_RELOC_390_GOTPCDBL
;
2230 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
2231 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
2232 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2233 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2234 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2235 if (reloc
->howto
== NULL
)
2237 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2238 _("cannot represent relocation type %s"),
2239 bfd_get_reloc_code_name (code
));
2240 /* Set howto to a garbage value so that we can keep going. */
2241 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
2242 gas_assert (reloc
->howto
!= NULL
);
2244 reloc
->addend
= fixp
->fx_offset
;
2250 s390_cfi_frame_initial_instructions (void)
2252 cfi_add_CFA_def_cfa (15, s390_arch_size
== 64 ? 160 : 96);
2256 tc_s390_regname_to_dw2regnum (char *regname
)
2260 if (regname
[0] != 'c' && regname
[0] != 'a')
2262 regnum
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, regname
);
2263 if (regname
[0] == 'f' && regnum
!= -1)
2266 else if (strcmp (regname
, "ap") == 0)
2268 else if (strcmp (regname
, "cc") == 0)
2274 s390_elf_final_processing (void)
2276 if (s390_arch_size
== 32 && (current_mode_mask
& (1 << S390_OPCODE_ZARCH
)))
2277 elf_elfheader (stdoutput
)->e_flags
|= EF_S390_HIGH_GPRS
;