1 /* tc-s390.c -- Assemble for the S390
2 Copyright 2000, 2001 Free Software Foundation, Inc.
3 Contributed by Martin Schwidefsky (schwidefsky@de.ibm.com).
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "safe-ctype.h"
26 #include "struc-symbol.h"
28 #include "opcode/s390.h"
31 /* The default architecture. */
33 #define DEFAULT_ARCH "s390"
35 static char *default_arch = DEFAULT_ARCH;
36 /* Either 32 or 64, selects file format. */
37 static int s390_arch_size;
38 /* Current architecture. Start with the smallest instruction set. */
39 static enum s390_opcode_arch_val current_architecture = S390_OPCODE_ESA;
40 static int current_arch_mask = 1 << S390_OPCODE_ESA;
41 static int current_arch_requested = 0;
43 /* Whether to use user friendly register names. Default is true. */
44 #ifndef TARGET_REG_NAMES_P
45 #define TARGET_REG_NAMES_P true
48 static boolean reg_names_p = TARGET_REG_NAMES_P;
50 /* Set to TRUE if we want to warn about zero base/index registers. */
51 static boolean warn_areg_zero = FALSE;
53 /* Generic assembler global variables which must be defined by all
56 const char comment_chars[] = "#";
58 /* Characters which start a comment at the beginning of a line. */
59 const char line_comment_chars[] = "#";
61 /* Characters which may be used to separate multiple commands on a
63 const char line_separator_chars[] = ";";
65 /* Characters which are used to indicate an exponent in a floating
67 const char EXP_CHARS[] = "eE";
69 /* Characters which mean that a number is a floating point constant,
71 const char FLT_CHARS[] = "dD";
73 /* The target specific pseudo-ops which we support. */
75 /* Define the prototypes for the pseudo-ops */
76 static void s390_byte PARAMS ((int));
77 static void s390_elf_cons PARAMS ((int));
78 static void s390_bss PARAMS ((int));
79 static void s390_insn PARAMS ((int));
80 static void s390_literals PARAMS ((int));
82 const pseudo_typeS md_pseudo_table[] =
84 { "align", s_align_bytes, 0 },
85 /* Pseudo-ops which must be defined. */
86 { "bss", s390_bss, 0 },
87 { "insn", s390_insn, 0 },
88 /* Pseudo-ops which must be overridden. */
89 { "byte", s390_byte, 0 },
90 { "short", s390_elf_cons, 2 },
91 { "long", s390_elf_cons, 4 },
92 { "quad", s390_elf_cons, 8 },
93 { "ltorg", s390_literals, 0 },
94 { "string", stringer, 2 },
99 /* Structure to hold information about predefined registers. */
106 /* List of registers that are pre-defined:
108 Each access register has a predefined name of the form:
109 a<reg_num> which has the value <reg_num>.
111 Each control register has a predefined name of the form:
112 c<reg_num> which has the value <reg_num>.
114 Each general register has a predefined name of the form:
115 r<reg_num> which has the value <reg_num>.
117 Each floating point register a has predefined name of the form:
118 f<reg_num> which has the value <reg_num>.
120 There are individual registers as well:
124 The table is sorted. Suitable for searching by a binary search. */
126 static const struct pd_reg pre_defined_registers[] =
128 { "a0", 0 }, /* Access registers */
145 { "c0", 0 }, /* Control registers */
162 { "f0", 0 }, /* Floating point registers */
179 { "lit", 13 }, /* Pointer to literal pool */
181 { "r0", 0 }, /* General purpose registers */
198 { "sp", 15 }, /* Stack pointer */
202 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
204 static int reg_name_search
205 PARAMS ((const struct pd_reg *, int, const char *));
206 static boolean register_name PARAMS ((expressionS *));
207 static void init_default_arch PARAMS ((void));
208 static void s390_insert_operand
209 PARAMS ((unsigned char *, const struct s390_operand *, offsetT, char *,
211 static char *md_gather_operands
212 PARAMS ((char *, unsigned char *, const struct s390_opcode *));
214 /* Given NAME, find the register number associated with that name, return
215 the integer value associated with the given name or -1 on failure. */
218 reg_name_search (regs, regcount, name)
219 const struct pd_reg *regs;
223 int middle, low, high;
231 middle = (low + high) / 2;
232 cmp = strcasecmp (name, regs[middle].name);
238 return regs[middle].value;
247 * Summary of register_name().
249 * in: Input_line_pointer points to 1st char of operand.
251 * out: A expressionS.
252 * The operand may have been a register: in this case, X_op == O_register,
253 * X_add_number is set to the register number, and truth is returned.
254 * Input_line_pointer->(next non-blank) char after operand, or is in its
259 register_name (expressionP)
260 expressionS *expressionP;
267 /* Find the spelling of the operand. */
268 start = name = input_line_pointer;
269 if (name[0] == '%' && ISALPHA (name[1]))
270 name = ++input_line_pointer;
274 c = get_symbol_end ();
275 reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name);
277 /* Put back the delimiting char. */
278 *input_line_pointer = c;
280 /* Look to see if it's in the register table. */
283 expressionP->X_op = O_register;
284 expressionP->X_add_number = reg_number;
286 /* Make the rest nice. */
287 expressionP->X_add_symbol = NULL;
288 expressionP->X_op_symbol = NULL;
292 /* Reset the line as if we had not done anything. */
293 input_line_pointer = start;
297 /* Local variables. */
299 /* Opformat hash table. */
300 static struct hash_control *s390_opformat_hash;
302 /* Opcode hash table. */
303 static struct hash_control *s390_opcode_hash;
305 /* Flags to set in the elf header */
306 static flagword s390_flags = 0;
308 symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
310 #ifndef WORKING_DOT_WORD
311 const int md_short_jump_size = 4;
312 const int md_long_jump_size = 4;
315 CONST char *md_shortopts = "A:m:kVQ:";
316 struct option md_longopts[] = {
317 {NULL, no_argument, NULL, 0}
319 size_t md_longopts_size = sizeof (md_longopts);
321 /* Initialize the default opcode arch and word size from the default
322 architecture name. */
326 if (current_arch_requested)
329 if (strcmp (default_arch, "s390") == 0)
332 current_architecture = S390_OPCODE_ESA;
334 else if (strcmp (default_arch, "s390x") == 0)
337 current_architecture = S390_OPCODE_ESAME;
340 as_fatal ("Invalid default architecture, broken assembler.");
341 current_arch_mask = 1 << current_architecture;
344 /* Called by TARGET_FORMAT. */
346 s390_target_format ()
348 /* We don't get a chance to initialize anything before we're called,
349 so handle that now. */
350 if (! s390_arch_size)
351 init_default_arch ();
353 return s390_arch_size == 64 ? "elf64-s390" : "elf32-s390";
357 md_parse_option (c, arg)
363 /* -k: Ignore for FreeBSD compatibility. */
367 if (arg != NULL && strcmp (arg, "regnames") == 0)
370 else if (arg != NULL && strcmp (arg, "no-regnames") == 0)
373 else if (arg != NULL && strcmp (arg, "warn-areg-zero") == 0)
374 warn_areg_zero = TRUE;
378 as_bad (_("invalid switch -m%s"), arg);
384 if (arg != NULL && strcmp (arg, "esa") == 0)
386 current_architecture = S390_OPCODE_ESA;
389 else if (arg != NULL && strcmp (arg, "esame") == 0)
391 current_architecture = S390_OPCODE_ESAME;
395 as_bad ("invalid architecture -A%s", arg);
396 current_arch_mask = 1 << current_architecture;
397 current_arch_requested = 1;
400 /* -V: SVR4 argument to print version ID. */
405 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
406 should be emitted or not. FIXME: Not implemented. */
418 md_show_usage (stream)
421 fprintf (stream, _("\
423 -mregnames Allow symbolic names for registers\n\
424 -mwarn-areg-zero Warn about zero base/index registers\n\
425 -mno-regnames Do not allow symbolic names for registers\n"));
426 fprintf (stream, _("\
427 -V print assembler version number\n\
428 -Qy, -Qn ignored\n"));
431 /* This function is called when the assembler starts up. It is called
432 after the options have been parsed and the output file has been
438 register const struct s390_opcode *op;
439 const struct s390_opcode *op_end;
440 boolean dup_insn = false;
443 /* Set the ELF flags if desired. */
445 bfd_set_private_flags (stdoutput, s390_flags);
447 /* Insert the opcode formats into a hash table. */
448 s390_opformat_hash = hash_new ();
450 op_end = s390_opformats + s390_num_opformats;
451 for (op = s390_opformats; op < op_end; op++)
453 retval = hash_insert (s390_opformat_hash, op->name, (PTR) op);
454 if (retval != (const char *) NULL)
456 as_bad (_("Internal assembler error for instruction format %s"),
462 /* Insert the opcodes into a hash table. */
463 s390_opcode_hash = hash_new ();
465 op_end = s390_opcodes + s390_num_opcodes;
466 for (op = s390_opcodes; op < op_end; op++)
468 retval = hash_insert (s390_opcode_hash, op->name, (PTR) op);
469 if (retval != (const char *) NULL)
471 as_bad (_("Internal assembler error for instruction %s"), op->name);
479 record_alignment (text_section, 2);
480 record_alignment (data_section, 2);
481 record_alignment (bss_section, 2);
485 /* Called after all assembly has been done. */
489 if (s390_arch_size == 64)
490 bfd_set_arch_mach (stdoutput, bfd_arch_s390, bfd_mach_s390_esame);
492 bfd_set_arch_mach (stdoutput, bfd_arch_s390, bfd_mach_s390_esa);
496 s390_align_code (fragP, count)
500 /* We use nop pattern 0x0707. */
503 memset (fragP->fr_literal + fragP->fr_fix, 0x07, count);
504 fragP->fr_var = count;
508 /* Insert an operand value into an instruction. */
511 s390_insert_operand (insn, operand, val, file, line)
513 const struct s390_operand *operand;
521 if (operand->flags & (S390_OPERAND_SIGNED|S390_OPERAND_PCREL))
525 max = ((offsetT) 1 << (operand->bits - 1)) - 1;
526 min = - ((offsetT) 1 << (operand->bits - 1));
527 /* Halve PCREL operands. */
528 if (operand->flags & S390_OPERAND_PCREL)
530 /* Check for underflow / overflow. */
531 if (val < min || val > max)
534 "operand out of range (%s not between %ld and %ld)";
537 if (operand->flags & S390_OPERAND_PCREL)
543 sprint_value (buf, val);
544 if (file == (char *) NULL)
545 as_bad (err, buf, (int) min, (int) max);
547 as_bad_where (file, line, err, buf, (int) min, (int) max);
550 /* val is ok, now restrict it to operand->bits bits. */
551 uval = (addressT) val & ((((addressT) 1 << (operand->bits-1)) << 1) - 1);
557 max = (((addressT) 1 << (operand->bits - 1))<<1) - 1;
559 uval = (addressT) val;
560 /* Length x in an instructions has real length x+1. */
561 if (operand->flags & S390_OPERAND_LENGTH)
563 /* Check for underflow / overflow. */
564 if (uval < min || uval > max)
567 "operand out of range (%s not between %ld and %ld)";
570 if (operand->flags & S390_OPERAND_LENGTH)
576 sprint_value (buf, uval);
577 if (file == (char *) NULL)
578 as_bad (err, buf, (int) min, (int) max);
580 as_bad_where (file, line, err, buf, (int) min, (int) max);
585 /* Insert fragments of the operand byte for byte. */
586 offset = operand->shift + operand->bits;
587 uval <<= (-offset) & 7;
588 insn += (offset - 1)/8;
596 /* Structure used to hold suffixes. */
610 elf_suffix_type suffix;
613 static elf_suffix_type s390_elf_suffix PARAMS ((char **, expressionS *));
614 static int s390_exp_compare PARAMS ((expressionS *exp1, expressionS *exp2));
615 static elf_suffix_type s390_lit_suffix
616 PARAMS ((char **, expressionS *, elf_suffix_type));
619 /* Parse @got/@plt/@gotoff. and return the desired relocation. */
620 static elf_suffix_type
621 s390_elf_suffix (str_p, exp_p)
625 static struct map_bfd mapping[] =
627 { "got", 3, ELF_SUFFIX_GOT },
628 { "got12", 5, ELF_SUFFIX_GOT },
629 { "plt", 3, ELF_SUFFIX_PLT },
630 { "gotent", 6, ELF_SUFFIX_GOTENT },
631 { NULL, 0, ELF_SUFFIX_NONE }
640 return ELF_SUFFIX_NONE;
643 while (ISALNUM (*str))
647 for (ptr = &mapping[0]; ptr->length > 0; ptr++)
648 if (len == ptr->length
649 && strncasecmp (ident, ptr->string, ptr->length) == 0)
651 if (exp_p->X_add_number != 0)
652 as_warn (_("identifier+constant@%s means identifier@%s+constant"),
653 ptr->string, ptr->string);
654 /* Now check for identifier@suffix+constant. */
655 if (*str == '-' || *str == '+')
657 char *orig_line = input_line_pointer;
660 input_line_pointer = str;
661 expression (&new_exp);
663 switch (new_exp.X_op)
665 case O_constant: /* X_add_number (a constant expression). */
666 exp_p->X_add_number += new_exp.X_add_number;
667 str = input_line_pointer;
669 case O_symbol: /* X_add_symbol + X_add_number. */
670 /* this case is used for e.g. xyz@PLT+.Label. */
671 exp_p->X_add_number += new_exp.X_add_number;
672 exp_p->X_op_symbol = new_exp.X_add_symbol;
674 str = input_line_pointer;
676 case O_uminus: /* (- X_add_symbol) + X_add_number. */
677 /* this case is used for e.g. xyz@PLT-.Label. */
678 exp_p->X_add_number += new_exp.X_add_number;
679 exp_p->X_op_symbol = new_exp.X_add_symbol;
680 exp_p->X_op = O_subtract;
681 str = input_line_pointer;
687 /* If s390_elf_suffix has not been called with
688 &input_line_pointer as first parameter, we have
689 clobbered the input_line_pointer. We have to
691 if (&input_line_pointer != str_p)
692 input_line_pointer = orig_line;
698 return BFD_RELOC_UNUSED;
701 /* Structure used to hold a literal pool entry. */
704 struct s390_lpe *next;
706 FLONUM_TYPE floatnum; /* used if X_op == O_big && X_add_number <= 0 */
707 LITTLENUM_TYPE bignum[4]; /* used if X_op == O_big && X_add_number > 0 */
709 bfd_reloc_code_real_type reloc;
713 static struct s390_lpe *lpe_free_list = NULL;
714 static struct s390_lpe *lpe_list = NULL;
715 static struct s390_lpe *lpe_list_tail = NULL;
716 static symbolS *lp_sym = NULL;
717 static int lp_count = 0;
718 static int lpe_count = 0;
721 s390_exp_compare(exp1, exp2)
725 if (exp1->X_op != exp2->X_op)
730 case O_constant: /* X_add_number must be equal. */
732 return exp1->X_add_number == exp2->X_add_number;
735 as_bad (_("Can't handle O_big in s390_exp_compare"));
737 case O_symbol: /* X_add_symbol & X_add_number must be equal. */
742 return (exp1->X_add_symbol == exp2->X_add_symbol)
743 && (exp1->X_add_number == exp2->X_add_number);
745 case O_multiply: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
750 case O_bit_inclusive_or:
752 case O_bit_exclusive_or:
764 return (exp1->X_add_symbol == exp2->X_add_symbol)
765 && (exp1->X_op_symbol == exp2->X_op_symbol)
766 && (exp1->X_add_number == exp2->X_add_number);
772 /* Test for @lit and if its present make an entry in the literal pool and
773 modify the current expression to be an offset into the literal pool. */
774 static elf_suffix_type
775 s390_lit_suffix (str_p, exp_p, suffix)
778 elf_suffix_type suffix;
780 bfd_reloc_code_real_type reloc;
784 struct s390_lpe *lpe;
788 return suffix; /* No modification. */
790 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
792 while (ISALNUM (*str))
795 if (len != 4 || strncasecmp (ident, "lit", 3) != 0
796 || (ident[3]!='1' && ident[3]!='2' && ident[3]!='4' && ident[3]!='8'))
797 return suffix; /* no modification */
798 nbytes = ident[3] - '0';
800 reloc = BFD_RELOC_UNUSED;
801 if (suffix == ELF_SUFFIX_GOT)
804 reloc = BFD_RELOC_390_GOT16;
805 else if (nbytes == 4)
806 reloc = BFD_RELOC_32_GOT_PCREL;
807 else if (nbytes == 8)
808 reloc = BFD_RELOC_390_GOT64;
810 else if (suffix == ELF_SUFFIX_PLT)
813 reloc = BFD_RELOC_390_PLT32;
814 else if (nbytes == 8)
815 reloc = BFD_RELOC_390_PLT64;
818 if (suffix != ELF_SUFFIX_NONE && reloc == BFD_RELOC_UNUSED)
819 as_bad (_("Invalid suffix for literal pool entry"));
821 /* Search the pool if the new entry is a duplicate. */
822 if (exp_p->X_op == O_big)
824 /* Special processing for big numbers. */
825 for (lpe = lpe_list; lpe != NULL; lpe = lpe->next)
827 if (lpe->ex.X_op == O_big)
829 if (exp_p->X_add_number <= 0 && lpe->ex.X_add_number <= 0)
831 if (memcmp (&generic_floating_point_number, &lpe->floatnum,
832 sizeof (FLONUM_TYPE)) == 0)
835 else if (exp_p->X_add_number == lpe->ex.X_add_number)
837 if (memcmp (generic_bignum, lpe->bignum,
838 sizeof (LITTLENUM_TYPE)*exp_p->X_add_number) == 0)
846 /* Processing for 'normal' data types. */
847 for (lpe = lpe_list; lpe != NULL; lpe = lpe->next)
848 if (lpe->nbytes == nbytes && lpe->reloc == reloc
849 && s390_exp_compare(exp_p, &lpe->ex) != 0)
856 if (lpe_free_list != NULL)
859 lpe_free_list = lpe_free_list->next;
863 lpe = (struct s390_lpe *) xmalloc(sizeof (struct s390_lpe));
868 if (exp_p->X_op == O_big)
870 if (exp_p->X_add_number <= 0)
871 lpe->floatnum = generic_floating_point_number;
872 else if (exp_p->X_add_number <= 4)
873 memcpy (lpe->bignum, generic_bignum,
874 exp_p->X_add_number*sizeof (LITTLENUM_TYPE));
876 as_bad (_("Big number is too big"));
879 lpe->nbytes = nbytes;
881 /* Literal pool name defined ? */
884 sprintf (tmp_name, ".L\001%i", lp_count);
885 lp_sym = symbol_make(tmp_name);
888 /* Make name for literal pool entry. */
889 sprintf (tmp_name, ".L\001%i\002%i", lp_count, lpe_count);
891 lpe->sym = symbol_make(tmp_name);
893 /* Add to literal pool list. */
895 if (lpe_list_tail != NULL)
897 lpe_list_tail->next = lpe;
901 lpe_list = lpe_list_tail = lpe;
904 /* Now change exp_p to the offset into the literal pool.
905 Thats the expression: .L^Ax^By-.L^Ax */
906 exp_p->X_add_symbol = lpe->sym;
907 exp_p->X_op_symbol = lp_sym;
908 exp_p->X_op = O_subtract;
909 exp_p->X_add_number = 0;
913 /* We change the suffix type to ELF_SUFFIX_NONE, because
914 the difference of two local labels is just a number. */
915 return ELF_SUFFIX_NONE;
918 /* Like normal .long/.short/.word, except support @got, etc.
919 clobbers input_line_pointer, checks end-of-line. */
921 s390_elf_cons (nbytes)
922 register int nbytes; /* 1=.byte, 2=.word, 4=.long */
925 elf_suffix_type suffix;
927 if (is_it_end_of_statement ())
929 demand_empty_rest_of_line ();
937 if (exp.X_op == O_symbol
938 && *input_line_pointer == '@'
939 && (suffix = s390_elf_suffix (&input_line_pointer, &exp)) != ELF_SUFFIX_NONE)
941 bfd_reloc_code_real_type reloc;
942 reloc_howto_type *reloc_howto;
946 if (nbytes == 2 && suffix == ELF_SUFFIX_GOT)
947 reloc = BFD_RELOC_390_GOT16;
948 else if (nbytes == 4 && suffix == ELF_SUFFIX_GOT)
949 reloc = BFD_RELOC_32_GOT_PCREL;
950 else if (nbytes == 8 && suffix == ELF_SUFFIX_GOT)
951 reloc = BFD_RELOC_390_GOT64;
952 else if (nbytes == 4 && suffix == ELF_SUFFIX_PLT)
953 reloc = BFD_RELOC_390_PLT32;
954 else if (nbytes == 8 && suffix == ELF_SUFFIX_PLT)
955 reloc = BFD_RELOC_390_PLT64;
957 reloc = BFD_RELOC_UNUSED;
959 if (reloc != BFD_RELOC_UNUSED)
961 reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc);
962 size = bfd_get_reloc_size (reloc_howto);
964 as_bad (_("%s relocations do not fit in %d bytes"),
965 reloc_howto->name, nbytes);
966 where = frag_more (nbytes);
967 md_number_to_chars (where, 0, size);
968 /* To make fixup_segment do the pc relative conversion the
969 pcrel parameter on the fix_new_exp call needs to be false. */
970 fix_new_exp (frag_now, where - frag_now->fr_literal,
971 size, &exp, false, reloc);
974 as_bad (_("relocation not applicable"));
977 emit_expr (&exp, (unsigned int) nbytes);
979 while (*input_line_pointer++ == ',');
981 input_line_pointer--; /* Put terminator back into stream. */
982 demand_empty_rest_of_line ();
985 /* We need to keep a list of fixups. We can't simply generate them as
986 we go, because that would require us to first create the frag, and
987 that would screw up references to ``.''. */
993 bfd_reloc_code_real_type reloc;
996 #define MAX_INSN_FIXUPS (4)
998 /* This routine is called for each instruction to be assembled. */
1001 md_gather_operands (str, insn, opcode)
1003 unsigned char *insn;
1004 const struct s390_opcode *opcode;
1006 struct s390_fixup fixups[MAX_INSN_FIXUPS];
1007 const struct s390_operand *operand;
1008 const unsigned char *opindex_ptr;
1009 elf_suffix_type suffix;
1010 bfd_reloc_code_real_type reloc;
1016 while (ISSPACE (*str)) str++;
1021 /* Gather the operands. */
1023 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1028 operand = s390_operands + *opindex_ptr;
1030 if (skip_optional && (operand->flags & S390_OPERAND_INDEX))
1032 /* We do an early skip. For D(X,B) constructions the index
1033 register is skipped (X is optional). For D(L,B) the base
1034 register will be the skipped operand, because L is NOT
1040 /* Gather the operand. */
1041 hold = input_line_pointer;
1042 input_line_pointer = str;
1044 if (! register_name (&ex)) /* parse the operand */
1047 str = input_line_pointer;
1048 input_line_pointer = hold;
1050 /* Write the operand to the insn. */
1051 if (ex.X_op == O_illegal)
1052 as_bad (_("illegal operand"));
1053 else if (ex.X_op == O_absent)
1054 as_bad (_("missing operand"));
1055 else if (ex.X_op == O_register || ex.X_op == O_constant)
1057 s390_lit_suffix (&str, &ex, ELF_SUFFIX_NONE);
1059 if (ex.X_op != O_register && ex.X_op != O_constant)
1061 /* We need to generate a fixup for the
1062 expression returned by s390_lit_suffix. */
1063 if (fc >= MAX_INSN_FIXUPS)
1064 as_fatal (_("too many fixups"));
1065 fixups[fc].exp = ex;
1066 fixups[fc].opindex = *opindex_ptr;
1067 fixups[fc].reloc = BFD_RELOC_UNUSED;
1072 if ((operand->flags & S390_OPERAND_INDEX)
1073 && ex.X_add_number == 0
1074 && warn_areg_zero == TRUE)
1075 as_warn ("index register specified but zero");
1076 if ((operand->flags & S390_OPERAND_BASE)
1077 && ex.X_add_number == 0
1078 && warn_areg_zero == TRUE)
1079 as_warn ("base register specified but zero");
1080 s390_insert_operand (insn, operand, ex.X_add_number, NULL, 0);
1085 suffix = s390_elf_suffix (&str, &ex);
1086 suffix = s390_lit_suffix (&str, &ex, suffix);
1087 reloc = BFD_RELOC_UNUSED;
1089 if (suffix == ELF_SUFFIX_GOT)
1091 if (operand->flags & S390_OPERAND_DISP)
1092 reloc = BFD_RELOC_390_GOT12;
1093 else if ((operand->flags & S390_OPERAND_SIGNED)
1094 && (operand->bits == 16))
1095 reloc = BFD_RELOC_390_GOT16;
1096 else if ((operand->flags & S390_OPERAND_PCREL)
1097 && (operand->bits == 32))
1098 reloc = BFD_RELOC_390_GOTENT;
1100 else if (suffix == ELF_SUFFIX_PLT)
1102 if ((operand->flags & S390_OPERAND_PCREL)
1103 && (operand->bits == 16))
1104 reloc = BFD_RELOC_390_PLT16DBL;
1105 else if ((operand->flags & S390_OPERAND_PCREL)
1106 && (operand->bits == 32))
1107 reloc = BFD_RELOC_390_PLT32DBL;
1109 else if (suffix == ELF_SUFFIX_GOTENT)
1111 if ((operand->flags & S390_OPERAND_PCREL)
1112 && (operand->bits == 32))
1113 reloc = BFD_RELOC_390_GOTENT;
1116 if (suffix != ELF_SUFFIX_NONE && reloc == BFD_RELOC_UNUSED)
1117 as_bad (_("invalid operand suffix"));
1118 /* We need to generate a fixup of type 'reloc' for this
1120 if (fc >= MAX_INSN_FIXUPS)
1121 as_fatal (_("too many fixups"));
1122 fixups[fc].exp = ex;
1123 fixups[fc].opindex = *opindex_ptr;
1124 fixups[fc].reloc = reloc;
1128 /* Check the next character. The call to expression has advanced
1129 str past any whitespace. */
1130 if (operand->flags & S390_OPERAND_DISP)
1132 /* After a displacement a block in parentheses can start. */
1135 /* Check if parethesed block can be skipped. If the next
1136 operand is neiter an optional operand nor a base register
1137 then we have a syntax error. */
1138 operand = s390_operands + *(++opindex_ptr);
1139 if (!(operand->flags & (S390_OPERAND_INDEX|S390_OPERAND_BASE)))
1140 as_bad (_("syntax error; missing '(' after displacement"));
1142 /* Ok, skip all operands until S390_OPERAND_BASE. */
1143 while (!(operand->flags & S390_OPERAND_BASE))
1144 operand = s390_operands + *(++opindex_ptr);
1146 /* If there is a next operand it must be seperated by a comma. */
1147 if (opindex_ptr[1] != '\0')
1150 as_bad (_("syntax error; expected ,"));
1155 /* We found an opening parentheses. */
1157 for (f = str; *f != '\0'; f++)
1158 if (*f == ',' || *f == ')')
1160 /* If there is no comma until the closing parentheses OR
1161 there is a comma right after the opening parentheses,
1162 we have to skip optional operands. */
1163 if (*f == ',' && f == str)
1165 /* comma directly after '(' ? */
1170 skip_optional = (*f != ',');
1173 else if (operand->flags & S390_OPERAND_BASE)
1175 /* After the base register the parenthesed block ends. */
1177 as_bad (_("syntax error; missing ')' after base register"));
1179 /* If there is a next operand it must be seperated by a comma. */
1180 if (opindex_ptr[1] != '\0')
1183 as_bad (_("syntax error; expected ,"));
1188 /* We can find an 'early' closing parentheses in e.g. D(L) instead
1189 of D(L,B). In this case the base register has to be skipped. */
1192 operand = s390_operands + *(++opindex_ptr);
1194 if (!(operand->flags & S390_OPERAND_BASE))
1195 as_bad (_("syntax error; ')' not allowed here"));
1198 /* If there is a next operand it must be seperated by a comma. */
1199 if (opindex_ptr[1] != '\0')
1202 as_bad (_("syntax error; expected ,"));
1207 while (ISSPACE (*str))
1214 if ((linefeed = strchr (str, '\n')) != NULL)
1216 as_bad (_("junk at end of line: `%s'"), str);
1217 if (linefeed != NULL)
1221 /* Write out the instruction. */
1222 f = frag_more (opcode->oplen);
1223 memcpy (f, insn, opcode->oplen);
1225 /* Create any fixups. At this point we do not use a
1226 bfd_reloc_code_real_type, but instead just use the
1227 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1228 handle fixups for any operand type, although that is admittedly
1229 not a very exciting feature. We pick a BFD reloc type in
1231 for (i = 0; i < fc; i++)
1233 operand = s390_operands + fixups[i].opindex;
1235 if (fixups[i].reloc != BFD_RELOC_UNUSED)
1237 reloc_howto_type *reloc_howto;
1241 reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
1245 size = bfd_get_reloc_size (reloc_howto);
1247 if (size < 1 || size > 4)
1250 fixP = fix_new_exp (frag_now,
1251 f - frag_now->fr_literal + (operand->shift/8),
1252 size, &fixups[i].exp, reloc_howto->pc_relative,
1254 /* Turn off overflow checking in fixup_segment. This is necessary
1255 because fixup_segment will signal an overflow for large 4 byte
1256 quantities for GOT12 relocations. */
1257 if ( fixups[i].reloc == BFD_RELOC_390_GOT12
1258 || fixups[i].reloc == BFD_RELOC_390_GOT16)
1259 fixP->fx_no_overflow = 1;
1262 fix_new_exp (frag_now, f - frag_now->fr_literal, 4, &fixups[i].exp,
1263 (operand->flags & S390_OPERAND_PCREL) != 0,
1264 ((bfd_reloc_code_real_type)
1265 (fixups[i].opindex + (int) BFD_RELOC_UNUSED)));
1270 /* This routine is called for each instruction to be assembled. */
1276 const struct s390_opcode *opcode;
1277 unsigned char insn[6];
1280 /* Get the opcode. */
1281 for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
1286 /* Look up the opcode in the hash table. */
1287 opcode = (struct s390_opcode *) hash_find (s390_opcode_hash, str);
1288 if (opcode == (const struct s390_opcode *) NULL)
1290 as_bad (_("Unrecognized opcode: `%s'"), str);
1293 else if (!(opcode->architecture & current_arch_mask))
1295 as_bad ("Opcode %s not available in this architecture", str);
1299 memcpy (insn, opcode->opcode, sizeof (insn));
1300 md_gather_operands (s, insn, opcode);
1303 #ifndef WORKING_DOT_WORD
1304 /* Handle long and short jumps. We don't support these */
1306 md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
1308 addressT from_addr, to_addr;
1316 md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
1318 addressT from_addr, to_addr;
1328 int ignore ATTRIBUTE_UNUSED;
1330 /* We don't support putting frags in the BSS segment, we fake it
1331 by marking in_bss, then looking at s_skip for clues. */
1333 subseg_set (bss_section, 0);
1334 demand_empty_rest_of_line ();
1337 /* Pseudo-op handling. */
1341 int ignore ATTRIBUTE_UNUSED;
1344 const struct s390_opcode *opformat;
1345 unsigned char insn[6];
1348 /* Get the opcode format. */
1349 s = input_line_pointer;
1350 while (*s != '\0' && *s != ',' && ! ISSPACE (*s))
1353 as_bad (_("Invalid .insn format\n"));
1356 /* Look up the opcode in the hash table. */
1357 opformat = (struct s390_opcode *)
1358 hash_find (s390_opformat_hash, input_line_pointer);
1359 if (opformat == (const struct s390_opcode *) NULL)
1361 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer);
1364 input_line_pointer = s;
1366 if (exp.X_op == O_constant)
1368 if ( ((opformat->oplen == 6) && (exp.X_op > 0) && (exp.X_op < (1ULL << 48)))
1369 || ((opformat->oplen == 4) && (exp.X_op > 0) && (exp.X_op < (1ULL << 32)))
1370 || ((opformat->oplen == 2) && (exp.X_op > 0) && (exp.X_op < (1ULL << 16))))
1371 md_number_to_chars (insn, exp.X_add_number, opformat->oplen);
1373 as_bad (_("Invalid .insn format\n"));
1375 else if (exp.X_op == O_big)
1377 if (exp.X_add_number > 0
1378 && opformat->oplen == 6
1379 && generic_bignum[3] == 0)
1381 md_number_to_chars (insn, generic_bignum[2], 2);
1382 md_number_to_chars (&insn[2], generic_bignum[1], 2);
1383 md_number_to_chars (&insn[4], generic_bignum[0], 2);
1386 as_bad (_("Invalid .insn format\n"));
1389 as_bad (_("second operand of .insn not a constant\n"));
1391 if (strcmp (opformat->name, "e") != 0 && *input_line_pointer++ != ',')
1392 as_bad (_("missing comma after insn constant\n"));
1394 if ((s = strchr (input_line_pointer, '\n')) != NULL)
1396 input_line_pointer = md_gather_operands (input_line_pointer, insn,
1400 demand_empty_rest_of_line ();
1403 /* The .byte pseudo-op. This is similar to the normal .byte
1404 pseudo-op, but it can also take a single ASCII string. */
1408 int ignore ATTRIBUTE_UNUSED;
1410 if (*input_line_pointer != '\"')
1416 /* Gather characters. A real double quote is doubled. Unusual
1417 characters are not permitted. */
1418 ++input_line_pointer;
1423 c = *input_line_pointer++;
1427 if (*input_line_pointer != '\"')
1429 ++input_line_pointer;
1432 FRAG_APPEND_1_CHAR (c);
1435 demand_empty_rest_of_line ();
1438 /* The .ltorg pseudo-op.This emits all literals defined since the last
1439 .ltorg or the invocation of gas. Literals are defined with the
1443 s390_literals (ignore)
1444 int ignore ATTRIBUTE_UNUSED;
1446 struct s390_lpe *lpe;
1448 if (lp_sym == NULL || lpe_count == 0)
1449 return; /* nothing to be done */
1451 /* Emit symbol for start of literal pool. */
1452 S_SET_SEGMENT (lp_sym, now_seg);
1453 S_SET_VALUE (lp_sym, (valueT) frag_now_fix ());
1454 lp_sym->sy_frag = frag_now;
1459 lpe_list = lpe_list->next;
1460 S_SET_SEGMENT (lpe->sym, now_seg);
1461 S_SET_VALUE (lpe->sym, (valueT) frag_now_fix ());
1462 lpe->sym->sy_frag = frag_now;
1464 /* Emit literal pool entry. */
1465 if (lpe->reloc != BFD_RELOC_UNUSED)
1467 reloc_howto_type *reloc_howto =
1468 bfd_reloc_type_lookup (stdoutput, lpe->reloc);
1469 int size = bfd_get_reloc_size (reloc_howto);
1472 if (size > lpe->nbytes)
1473 as_bad (_("%s relocations do not fit in %d bytes"),
1474 reloc_howto->name, lpe->nbytes);
1475 where = frag_more (lpe->nbytes);
1476 md_number_to_chars (where, 0, size);
1477 fix_new_exp (frag_now, where - frag_now->fr_literal,
1478 size, &lpe->ex, reloc_howto->pc_relative, lpe->reloc);
1482 if (lpe->ex.X_op == O_big)
1484 if (lpe->ex.X_add_number <= 0)
1485 generic_floating_point_number = lpe->floatnum;
1487 memcpy (generic_bignum, lpe->bignum,
1488 lpe->ex.X_add_number*sizeof (LITTLENUM_TYPE));
1490 emit_expr (&lpe->ex, lpe->nbytes);
1493 lpe->next = lpe_free_list;
1494 lpe_free_list = lpe;
1496 lpe_list_tail = NULL;
1502 /* Turn a string in input_line_pointer into a floating point constant
1503 of type type, and store the appropriate bytes in *litp. The number
1504 of LITTLENUMS emitted is stored in *sizep . An error message is
1505 returned, or NULL on OK. */
1508 md_atof (type, litp, sizep)
1514 LITTLENUM_TYPE words[4];
1530 return "bad call to md_atof";
1533 t = atof_ieee (input_line_pointer, type, words);
1535 input_line_pointer = t;
1539 for (i = 0; i < prec; i++)
1541 md_number_to_chars (litp, (valueT) words[i], 2);
1548 /* Align a section (I don't know why this is machine dependent). */
1551 md_section_align (seg, addr)
1555 int align = bfd_get_section_alignment (stdoutput, seg);
1557 return ((addr + (1 << align) - 1) & (-1 << align));
1560 /* We don't have any form of relaxing. */
1563 md_estimate_size_before_relax (fragp, seg)
1564 fragS *fragp ATTRIBUTE_UNUSED;
1565 asection *seg ATTRIBUTE_UNUSED;
1571 /* Convert a machine dependent frag. We never generate these. */
1574 md_convert_frag (abfd, sec, fragp)
1575 bfd *abfd ATTRIBUTE_UNUSED;
1576 asection *sec ATTRIBUTE_UNUSED;
1577 fragS *fragp ATTRIBUTE_UNUSED;
1583 md_undefined_symbol (name)
1586 if (*name == '_' && *(name+1) == 'G'
1587 && strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
1591 if (symbol_find (name))
1592 as_bad (_("GOT already in symbol table"));
1593 GOT_symbol = symbol_new (name, undefined_section,
1594 (valueT) 0, &zero_address_frag);
1601 /* Functions concerning relocs. */
1603 /* The location from which a PC relative jump should be calculated,
1604 given a PC relative reloc. */
1607 md_pcrel_from_section (fixp, sec)
1609 segT sec ATTRIBUTE_UNUSED;
1611 return fixp->fx_frag->fr_address + fixp->fx_where;
1614 /* Here we decide which fixups can be adjusted to make them relative to
1615 the beginning of the section instead of the symbol. Basically we need
1616 to make sure that the dynamic relocations are done correctly, so in
1617 some cases we force the original symbol to be used. */
1619 tc_s390_fix_adjustable(fixP)
1622 /* Prevent all adjustments to global symbols. */
1623 if (S_IS_EXTERN (fixP->fx_addsy))
1625 if (S_IS_WEAK (fixP->fx_addsy))
1627 /* adjust_reloc_syms doesn't know about the GOT. */
1628 if ( fixP->fx_r_type == BFD_RELOC_32_GOTOFF
1629 || fixP->fx_r_type == BFD_RELOC_390_PLT16DBL
1630 || fixP->fx_r_type == BFD_RELOC_390_PLT32
1631 || fixP->fx_r_type == BFD_RELOC_390_PLT32DBL
1632 || fixP->fx_r_type == BFD_RELOC_390_PLT64
1633 || fixP->fx_r_type == BFD_RELOC_390_GOT12
1634 || fixP->fx_r_type == BFD_RELOC_390_GOT16
1635 || fixP->fx_r_type == BFD_RELOC_32_GOT_PCREL
1636 || fixP->fx_r_type == BFD_RELOC_390_GOT64
1637 || fixP->fx_r_type == BFD_RELOC_390_GOTENT
1638 || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
1639 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
1644 /* Return true if we must always emit a reloc for a type and false if
1645 there is some hope of resolving it a assembly time. */
1647 tc_s390_force_relocation (fixp)
1650 /* Ensure we emit a relocation for every reference to the global
1651 offset table or to the procedure link table. */
1652 switch (fixp->fx_r_type)
1654 case BFD_RELOC_390_GOT12:
1655 case BFD_RELOC_32_GOT_PCREL:
1656 case BFD_RELOC_32_GOTOFF:
1657 case BFD_RELOC_390_GOTPC:
1658 case BFD_RELOC_390_GOT16:
1659 case BFD_RELOC_390_GOTPCDBL:
1660 case BFD_RELOC_390_GOT64:
1661 case BFD_RELOC_390_GOTENT:
1662 case BFD_RELOC_390_PLT32:
1663 case BFD_RELOC_390_PLT16DBL:
1664 case BFD_RELOC_390_PLT32DBL:
1665 case BFD_RELOC_390_PLT64:
1666 case BFD_RELOC_VTABLE_INHERIT:
1667 case BFD_RELOC_VTABLE_ENTRY:
1674 /* Apply a fixup to the object code. This is called for all the
1675 fixups we generated by the call to fix_new_exp, above. In the call
1676 above we used a reloc code which was the largest legal reloc code
1677 plus the operand index. Here we undo that to recover the operand
1678 index. At this point all symbol values should be fully resolved,
1679 and we attempt to completely resolve the reloc. If we can not do
1680 that, we determine the correct reloc code and put it back in the
1684 md_apply_fix3 (fixP, valP, seg)
1690 valueT value = * valP;
1692 where = fixP->fx_frag->fr_literal + fixP->fx_where;
1694 if (fixP->fx_subsy != NULL)
1696 if ((fixP->fx_addsy != NULL
1697 && S_GET_SEGMENT (fixP->fx_addsy) == S_GET_SEGMENT (fixP->fx_subsy)
1698 && SEG_NORMAL (S_GET_SEGMENT (fixP->fx_addsy)))
1699 || (S_GET_SEGMENT (fixP->fx_subsy) == absolute_section))
1700 value += S_GET_VALUE (fixP->fx_subsy);
1701 if (!S_IS_DEFINED (fixP->fx_subsy))
1702 as_bad_where (fixP->fx_file, fixP->fx_line,
1703 _("unresolved fx_subsy symbol that must be resolved"));
1704 value -= S_GET_VALUE(fixP->fx_subsy);
1706 if (S_GET_SEGMENT (fixP->fx_subsy) == seg && ! fixP->fx_pcrel)
1707 value += MD_PCREL_FROM_SECTION (fixP, seg);
1710 if (fixP->fx_addsy != NULL)
1712 if ((fixP->fx_subsy != NULL
1713 && S_GET_SEGMENT (fixP->fx_addsy) == S_GET_SEGMENT (fixP->fx_subsy)
1714 && SEG_NORMAL (S_GET_SEGMENT(fixP->fx_addsy)))
1715 || (S_GET_SEGMENT (fixP->fx_addsy) == seg
1716 && fixP->fx_pcrel && TC_RELOC_RTSYM_LOC_FIXUP (fixP))
1718 && S_GET_SEGMENT (fixP->fx_addsy) == absolute_section)
1719 || (S_GET_SEGMENT (fixP->fx_addsy) != undefined_section
1720 && !bfd_is_com_section (S_GET_SEGMENT (fixP->fx_addsy))
1721 && TC_FIX_ADJUSTABLE(fixP)))
1722 value -= S_GET_VALUE (fixP->fx_addsy);
1725 value += fixP->fx_frag->fr_address + fixP->fx_where;
1730 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
1732 const struct s390_operand *operand;
1735 opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
1736 operand = &s390_operands[opindex];
1740 /* Insert the fully resolved operand value. */
1741 s390_insert_operand (where, operand, (offsetT) value,
1742 fixP->fx_file, fixP->fx_line);
1746 /* Determine a BFD reloc value based on the operand information.
1747 We are only prepared to turn a few of the operands into
1749 fixP->fx_offset = value;
1750 if (operand->bits == 12 && operand->shift == 20)
1753 fixP->fx_where += 2;
1754 fixP->fx_r_type = BFD_RELOC_390_12;
1756 else if (operand->bits == 12 && operand->shift == 36)
1759 fixP->fx_where += 4;
1760 fixP->fx_r_type = BFD_RELOC_390_12;
1762 else if (operand->bits == 8 && operand->shift == 8)
1765 fixP->fx_where += 1;
1766 fixP->fx_r_type = BFD_RELOC_8;
1768 else if (operand->bits == 16 && operand->shift == 16)
1771 fixP->fx_where += 2;
1772 if (operand->flags & S390_OPERAND_PCREL)
1774 fixP->fx_r_type = BFD_RELOC_390_PC16DBL;
1775 fixP->fx_offset += 2;
1778 fixP->fx_r_type = BFD_RELOC_16;
1780 else if (operand->bits == 32 && operand->shift == 16
1781 && (operand->flags & S390_OPERAND_PCREL))
1784 fixP->fx_where += 2;
1785 fixP->fx_offset += 2;
1786 fixP->fx_r_type = BFD_RELOC_390_PC32DBL;
1793 /* Use expr_symbol_where to see if this is an expression
1795 if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline))
1796 as_bad_where (fixP->fx_file, fixP->fx_line,
1797 _("unresolved expression that must be resolved"));
1799 as_bad_where (fixP->fx_file, fixP->fx_line,
1800 _("unsupported relocation type"));
1807 switch (fixP->fx_r_type)
1813 md_number_to_chars (where, value, 1);
1815 case BFD_RELOC_390_12:
1816 case BFD_RELOC_390_GOT12:
1821 mop = bfd_getb16 ((unsigned char *) where);
1822 mop |= (unsigned short) (value & 0xfff);
1823 bfd_putb16 ((bfd_vma) mop, (unsigned char *) where);
1828 case BFD_RELOC_GPREL16:
1829 case BFD_RELOC_16_GOT_PCREL:
1830 case BFD_RELOC_16_GOTOFF:
1832 as_bad_where (fixP->fx_file, fixP->fx_line,
1833 "cannot emit PC relative %s relocation%s%s",
1834 bfd_get_reloc_code_name (fixP->fx_r_type),
1835 fixP->fx_addsy != NULL ? " against " : "",
1836 (fixP->fx_addsy != NULL
1837 ? S_GET_NAME (fixP->fx_addsy)
1840 md_number_to_chars (where, value, 2);
1842 case BFD_RELOC_390_GOT16:
1844 md_number_to_chars (where, value, 2);
1846 case BFD_RELOC_390_PC16DBL:
1847 case BFD_RELOC_390_PLT16DBL:
1850 md_number_to_chars (where, (offsetT) value >> 1, 2);
1855 fixP->fx_r_type = BFD_RELOC_32_PCREL;
1857 fixP->fx_r_type = BFD_RELOC_32;
1859 md_number_to_chars (where, value, 4);
1861 case BFD_RELOC_32_PCREL:
1862 case BFD_RELOC_32_BASEREL:
1863 fixP->fx_r_type = BFD_RELOC_32_PCREL;
1865 md_number_to_chars (where, value, 4);
1867 case BFD_RELOC_32_GOT_PCREL:
1868 case BFD_RELOC_390_PLT32:
1870 md_number_to_chars (where, value, 4);
1872 case BFD_RELOC_390_PC32DBL:
1873 case BFD_RELOC_390_PLT32DBL:
1874 case BFD_RELOC_390_GOTPCDBL:
1875 case BFD_RELOC_390_GOTENT:
1878 md_number_to_chars (where, (offsetT) value >> 1, 4);
1881 case BFD_RELOC_32_GOTOFF:
1883 md_number_to_chars (where, value, sizeof (int));
1886 case BFD_RELOC_390_GOT64:
1887 case BFD_RELOC_390_PLT64:
1889 md_number_to_chars (where, value, 8);
1894 fixP->fx_r_type = BFD_RELOC_64_PCREL;
1896 fixP->fx_r_type = BFD_RELOC_64;
1898 md_number_to_chars (where, value, 8);
1901 case BFD_RELOC_64_PCREL:
1902 fixP->fx_r_type = BFD_RELOC_64_PCREL;
1904 md_number_to_chars (where, value, 8);
1907 case BFD_RELOC_VTABLE_INHERIT:
1908 case BFD_RELOC_VTABLE_ENTRY:
1914 const char *reloc_name = bfd_get_reloc_code_name (fixP->fx_r_type);
1916 if (reloc_name != NULL)
1917 fprintf (stderr, "Gas failure, reloc type %s\n", reloc_name);
1919 fprintf (stderr, "Gas failure, reloc type #%i\n", fixP->fx_r_type);
1925 fixP->fx_offset = value;
1929 /* Generate a reloc for a fixup. */
1932 tc_gen_reloc (seg, fixp)
1933 asection *seg ATTRIBUTE_UNUSED;
1936 bfd_reloc_code_real_type code;
1939 code = fixp->fx_r_type;
1940 if (GOT_symbol && fixp->fx_addsy == GOT_symbol)
1942 if ( (s390_arch_size == 32 && code == BFD_RELOC_32_PCREL)
1943 || (s390_arch_size == 64 && code == BFD_RELOC_64_PCREL))
1944 code = BFD_RELOC_390_GOTPC;
1945 if (code == BFD_RELOC_390_PC32DBL)
1946 code = BFD_RELOC_390_GOTPCDBL;
1949 reloc = (arelent *) xmalloc (sizeof (arelent));
1950 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
1951 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1952 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
1953 reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
1954 if (reloc->howto == NULL)
1956 as_bad_where (fixp->fx_file, fixp->fx_line,
1957 _("cannot represent relocation type %s"),
1958 bfd_get_reloc_code_name (code));
1959 /* Set howto to a garbage value so that we can keep going. */
1960 reloc->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
1961 assert (reloc->howto != NULL);
1963 reloc->addend = fixp->fx_offset;