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
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 /* Generic assembler global variables which must be defined by all
53 const char comment_chars[] = "#";
55 /* Characters which start a comment at the beginning of a line. */
56 const char line_comment_chars[] = "#";
58 /* Characters which may be used to separate multiple commands on a
60 const char line_separator_chars[] = ";";
62 /* Characters which are used to indicate an exponent in a floating
64 const char EXP_CHARS[] = "eE";
66 /* Characters which mean that a number is a floating point constant,
68 const char FLT_CHARS[] = "dD";
70 /* The target specific pseudo-ops which we support. */
72 /* Define the prototypes for the pseudo-ops */
73 static void s390_byte PARAMS ((int));
74 static void s390_elf_cons PARAMS ((int));
75 static void s390_bss PARAMS ((int));
76 static void s390_insn PARAMS ((int));
77 static void s390_literals PARAMS ((int));
79 const pseudo_typeS md_pseudo_table[] =
81 { "align", s_align_bytes, 0 },
82 /* Pseudo-ops which must be defined. */
83 { "bss", s390_bss, 0 },
84 { "insn", s390_insn, 0 },
85 /* Pseudo-ops which must be overridden. */
86 { "byte", s390_byte, 0 },
87 { "short", s390_elf_cons, 2 },
88 { "long", s390_elf_cons, 4 },
89 { "quad", s390_elf_cons, 8 },
90 { "ltorg", s390_literals, 0 },
91 { "string", stringer, 2 },
96 /* Structure to hold information about predefined registers. */
103 /* List of registers that are pre-defined:
105 Each access register has a predefined name of the form:
106 a<reg_num> which has the value <reg_num>.
108 Each control register has a predefined name of the form:
109 c<reg_num> which has the value <reg_num>.
111 Each general register has a predefined name of the form:
112 r<reg_num> which has the value <reg_num>.
114 Each floating point register a has predefined name of the form:
115 f<reg_num> which has the value <reg_num>.
117 There are individual registers as well:
121 The table is sorted. Suitable for searching by a binary search. */
123 static const struct pd_reg pre_defined_registers[] =
125 { "a0", 0 }, /* Access registers */
142 { "c0", 0 }, /* Control registers */
159 { "f0", 0 }, /* Floating point registers */
176 { "lit", 13 }, /* Pointer to literal pool */
178 { "r0", 0 }, /* General purpose registers */
195 { "sp", 15 }, /* Stack pointer */
199 #define REG_NAME_CNT (sizeof(pre_defined_registers) / sizeof(struct pd_reg))
201 /* Given NAME, find the register number associated with that name, return
202 the integer value associated with the given name or -1 on failure. */
205 reg_name_search (regs, regcount, name)
206 const struct pd_reg *regs;
210 int middle, low, high;
218 middle = (low + high) / 2;
219 cmp = strcasecmp (name, regs[middle].name);
225 return regs[middle].value;
234 * Summary of register_name().
236 * in: Input_line_pointer points to 1st char of operand.
238 * out: A expressionS.
239 * The operand may have been a register: in this case, X_op == O_register,
240 * X_add_number is set to the register number, and truth is returned.
241 * Input_line_pointer->(next non-blank) char after operand, or is in its
246 register_name (expressionP)
247 expressionS *expressionP;
254 /* Find the spelling of the operand */
255 start = name = input_line_pointer;
256 if (name[0] == '%' && isalpha (name[1]))
257 name = ++input_line_pointer;
261 c = get_symbol_end ();
262 reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name);
264 /* look to see if it's in the register table */
267 expressionP->X_op = O_register;
268 expressionP->X_add_number = reg_number;
270 /* make the rest nice */
271 expressionP->X_add_symbol = NULL;
272 expressionP->X_op_symbol = NULL;
273 *input_line_pointer = c; /* put back the delimiting char */
278 /* reset the line as if we had not done anything */
279 *input_line_pointer = c; /* put back the delimiting char */
280 input_line_pointer = start; /* reset input_line pointer */
285 /* Local variables. */
287 /* Opformat hash table. */
288 static struct hash_control *s390_opformat_hash;
290 /* Opcode hash table. */
291 static struct hash_control *s390_opcode_hash;
293 /* Flags to set in the elf header */
294 static flagword s390_flags = 0;
296 symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
298 #ifndef WORKING_DOT_WORD
299 const int md_short_jump_size = 4;
300 const int md_long_jump_size = 4;
303 CONST char *md_shortopts = "A:m:kVQ:";
304 struct option md_longopts[] = {
305 {NULL, no_argument, NULL, 0}
307 size_t md_longopts_size = sizeof(md_longopts);
309 /* Initialize the default opcode arch and word size from the default
310 architecture name. */
314 if (current_arch_requested)
317 if (strcmp(default_arch, "s390") == 0)
320 current_architecture = S390_OPCODE_ESA;
322 else if (strcmp(default_arch, "s390x") == 0)
325 current_architecture = S390_OPCODE_ESAME;
328 as_fatal ("Invalid default architecture, broken assembler.");
329 current_arch_mask = 1 << current_architecture;
332 /* Called by TARGET_FORMAT. */
334 s390_target_format ()
336 /* We don't get a chance to initialize anything before we're called,
337 so handle that now. */
338 if (! s390_arch_size)
339 init_default_arch ();
341 return s390_arch_size == 64 ? "elf64-s390" : "elf32-s390";
345 md_parse_option (c, arg)
351 /* -k: Ignore for FreeBSD compatibility. */
355 if (arg != NULL && strcmp (arg, "regnames") == 0)
358 else if (arg != NULL && strcmp (arg, "no-regnames") == 0)
363 as_bad (_("invalid switch -m%s"), arg);
369 if (arg != NULL && strcmp (arg, "esa") == 0)
371 current_architecture = S390_OPCODE_ESA;
374 else if (arg != NULL && strcmp (arg, "esame") == 0)
376 current_architecture = S390_OPCODE_ESAME;
380 as_bad ("invalid architecture -A%s", arg);
381 current_arch_mask = 1 << current_architecture;
382 current_arch_requested = 1;
385 /* -V: SVR4 argument to print version ID. */
390 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
391 should be emitted or not. FIXME: Not implemented. */
403 md_show_usage (stream)
406 fprintf (stream, _("\
408 -mregnames \tAllow symbolic names for registers\n\
409 -mno-regnames\tDo not allow symbolic names for registers\n"));
410 fprintf (stream, _("\
411 -V \tprint assembler version number\n\
412 -Qy, -Qn \tignored\n"));
415 /* This function is called when the assembler starts up. It is called
416 after the options have been parsed and the output file has been
422 register const struct s390_opcode *op;
423 const struct s390_opcode *op_end;
424 boolean dup_insn = false;
427 /* Set the ELF flags if desired. */
429 bfd_set_private_flags (stdoutput, s390_flags);
431 /* Insert the opcode formats into a hash table. */
432 s390_opformat_hash = hash_new ();
434 op_end = s390_opformats + s390_num_opformats;
435 for (op = s390_opformats; op < op_end; op++)
437 retval = hash_insert (s390_opformat_hash, op->name, (PTR) op);
438 if (retval != (const char *) NULL)
440 as_bad (_("Internal assembler error for instruction format %s"),
446 /* Insert the opcodes into a hash table. */
447 s390_opcode_hash = hash_new ();
449 op_end = s390_opcodes + s390_num_opcodes;
450 for (op = s390_opcodes; op < op_end; op++)
452 retval = hash_insert (s390_opcode_hash, op->name, (PTR) op);
453 if (retval != (const char *) NULL)
455 as_bad (_("Internal assembler error for instruction %s"), op->name);
463 record_alignment (text_section, 2);
464 record_alignment (data_section, 2);
465 record_alignment (bss_section, 2);
469 /* Called after all assembly has been done. */
473 if (s390_arch_size == 64)
474 bfd_set_arch_mach (stdoutput, bfd_arch_s390, bfd_mach_s390_esame);
476 bfd_set_arch_mach (stdoutput, bfd_arch_s390, bfd_mach_s390_esa);
480 s390_align_code (fragP, count)
484 /* We use nop pattern 0x0707. */
487 memset(fragP->fr_literal + fragP->fr_fix, 0x07, count);
488 fragP->fr_var = count;
492 /* Insert an operand value into an instruction. */
495 s390_insert_operand (insn, operand, val, file, line)
497 const struct s390_operand *operand;
505 if (operand->flags & (S390_OPERAND_SIGNED|S390_OPERAND_PCREL))
509 max = ((offsetT) 1 << (operand->bits - 1)) - 1;
510 min = - ((offsetT) 1 << (operand->bits - 1));
511 /* Halve PCREL operands. */
512 if (operand->flags & S390_OPERAND_PCREL)
514 /* Check for underflow / overflow. */
515 if (val < min || val > max)
518 "operand out of range (%s not between %ld and %ld)";
521 if (operand->flags & S390_OPERAND_PCREL)
527 sprint_value (buf, val);
528 if (file == (char *) NULL)
529 as_bad (err, buf, (int) min, (int) max);
531 as_bad_where (file, line, err, buf, (int) min, (int) max);
534 /* val is ok, now restrict it to operand->bits bits. */
535 uval = (addressT) val & ((((addressT) 1 << (operand->bits-1)) << 1) - 1);
541 max = (((addressT) 1 << (operand->bits - 1))<<1) - 1;
543 uval = (addressT) val;
544 /* Length x in an instructions has real length x+1. */
545 if (operand->flags & S390_OPERAND_LENGTH)
547 /* Check for underflow / overflow. */
548 if (uval < min || uval > max)
551 "operand out of range (%s not between %ld and %ld)";
554 if (operand->flags & S390_OPERAND_LENGTH)
560 sprint_value (buf, uval);
561 if (file == (char *) NULL)
562 as_bad (err, buf, (int) min, (int) max);
564 as_bad_where (file, line, err, buf, (int) min, (int) max);
569 /* Insert fragments of the operand byte for byte. */
570 offset = operand->shift + operand->bits;
571 uval <<= (-offset) & 7;
572 insn += (offset - 1)/8;
580 /* Structure used to hold suffixes. */
594 elf_suffix_type suffix;
597 /* Parse @got/@plt/@gotoff. and return the desired relocation. */
598 static elf_suffix_type
599 s390_elf_suffix (str_p, exp_p)
603 static struct map_bfd mapping[] =
605 { "got", 3, ELF_SUFFIX_GOT },
606 { "got12", 5, ELF_SUFFIX_GOT },
607 { "plt", 3, ELF_SUFFIX_PLT },
608 { "gotent", 6, ELF_SUFFIX_GOTENT },
609 { NULL, 0, ELF_SUFFIX_NONE }
618 return ELF_SUFFIX_NONE;
621 while (isalnum(*str))
625 for (ptr = &mapping[0]; ptr->length > 0; ptr++)
626 if (len == ptr->length &&
627 strncasecmp(ident, ptr->string, ptr->length) == 0)
629 if (exp_p->X_add_number != 0)
630 as_warn (_("identifier+constant@%s means identifier@%s+constant"),
631 ptr->string, ptr->string);
632 /* Now check for identifier@suffix+constant. */
633 if (*str == '-' || *str == '+')
635 char *orig_line = input_line_pointer;
638 input_line_pointer = str;
639 expression (&new_exp);
641 switch (new_exp.X_op)
643 case O_constant: /* X_add_number (a constant expression). */
644 exp_p->X_add_number += new_exp.X_add_number;
645 str = input_line_pointer;
647 case O_symbol: /* X_add_symbol + X_add_number. */
648 /* this case is used for e.g. xyz@PLT+.Label. */
649 exp_p->X_add_number += new_exp.X_add_number;
650 exp_p->X_op_symbol = new_exp.X_add_symbol;
652 str = input_line_pointer;
654 case O_uminus: /* (- X_add_symbol) + X_add_number. */
655 /* this case is used for e.g. xyz@PLT-.Label. */
656 exp_p->X_add_number += new_exp.X_add_number;
657 exp_p->X_op_symbol = new_exp.X_add_symbol;
658 exp_p->X_op = O_subtract;
659 str = input_line_pointer;
665 /* If s390_elf_suffix has not been called with
666 &input_line_pointer as first parameter, we have
667 clobbered the input_line_pointer. We have to
669 if (&input_line_pointer != str_p)
670 input_line_pointer = orig_line;
676 return BFD_RELOC_UNUSED;
679 /* Structure used to hold a literal pool entry. */
682 struct s390_lpe *next;
684 FLONUM_TYPE floatnum; /* used if X_op == O_big && X_add_number <= 0 */
685 LITTLENUM_TYPE bignum[4]; /* used if X_op == O_big && X_add_number > 0 */
687 bfd_reloc_code_real_type reloc;
691 static struct s390_lpe *lpe_free_list = NULL;
692 static struct s390_lpe *lpe_list = NULL;
693 static struct s390_lpe *lpe_list_tail = NULL;
694 static symbolS *lp_sym = NULL;
695 static int lp_count = 0;
696 static int lpe_count = 0;
699 s390_exp_compare(exp1, exp2)
703 if (exp1->X_op != exp2->X_op)
708 case O_constant: /* X_add_number must be equal. */
710 return exp1->X_add_number == exp2->X_add_number;
713 as_bad(_("Can't handle O_big in s390_exp_compare"));
715 case O_symbol: /* X_add_symbol & X_add_number must be equal. */
720 return (exp1->X_add_symbol == exp2->X_add_symbol) &&
721 (exp1->X_add_number == exp2->X_add_number);
723 case O_multiply: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
728 case O_bit_inclusive_or:
730 case O_bit_exclusive_or:
742 return (exp1->X_add_symbol == exp2->X_add_symbol) &&
743 (exp1->X_op_symbol == exp2->X_op_symbol) &&
744 (exp1->X_add_number == exp2->X_add_number);
750 /* Test for @lit and if its present make an entry in the literal pool and
751 modify the current expression to be an offset into the literal pool. */
752 static elf_suffix_type
753 s390_lit_suffix (str_p, exp_p, suffix)
756 elf_suffix_type suffix;
758 bfd_reloc_code_real_type reloc;
762 struct s390_lpe *lpe;
766 return suffix; /* No modification. */
768 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
770 while (isalnum(*str))
773 if (len != 4 || strncasecmp(ident, "lit", 3) != 0 ||
774 (ident[3]!='1' && ident[3]!='2' && ident[3]!='4' && ident[3]!='8'))
775 return suffix; /* no modification */
776 nbytes = ident[3] - '0';
778 reloc = BFD_RELOC_UNUSED;
779 if (suffix == ELF_SUFFIX_GOT)
782 reloc = BFD_RELOC_390_GOT16;
783 else if (nbytes == 4)
784 reloc = BFD_RELOC_32_GOT_PCREL;
785 else if (nbytes == 8)
786 reloc = BFD_RELOC_390_GOT64;
788 else if (suffix == ELF_SUFFIX_PLT)
791 reloc = BFD_RELOC_390_PLT32;
792 else if (nbytes == 8)
793 reloc = BFD_RELOC_390_PLT64;
796 if (suffix != ELF_SUFFIX_NONE && reloc == BFD_RELOC_UNUSED)
797 as_bad (_("Invalid suffix for literal pool entry"));
799 /* Search the pool if the new entry is a duplicate. */
800 if (exp_p->X_op == O_big)
802 /* Special processing for big numbers. */
803 for (lpe = lpe_list; lpe != NULL; lpe = lpe->next)
805 if (lpe->ex.X_op == O_big)
807 if (exp_p->X_add_number <= 0 && lpe->ex.X_add_number <= 0)
809 if (memcmp (&generic_floating_point_number, &lpe->floatnum,
810 sizeof (FLONUM_TYPE)) == 0)
813 else if (exp_p->X_add_number == lpe->ex.X_add_number)
815 if (memcmp (generic_bignum, lpe->bignum,
816 sizeof (LITTLENUM_TYPE)*exp_p->X_add_number) == 0)
824 /* Processing for 'normal' data types. */
825 for (lpe = lpe_list; lpe != NULL; lpe = lpe->next)
826 if (lpe->nbytes == nbytes && lpe->reloc == reloc &&
827 s390_exp_compare(exp_p, &lpe->ex) != 0)
834 if (lpe_free_list != NULL)
837 lpe_free_list = lpe_free_list->next;
841 lpe = (struct s390_lpe *) xmalloc(sizeof(struct s390_lpe));
846 if (exp_p->X_op == O_big)
848 if (exp_p->X_add_number <= 0)
849 lpe->floatnum = generic_floating_point_number;
850 else if (exp_p->X_add_number <= 4)
851 memcpy (lpe->bignum, generic_bignum,
852 exp_p->X_add_number*sizeof(LITTLENUM_TYPE));
854 as_bad (_("Big number is too big"));
857 lpe->nbytes = nbytes;
859 /* Literal pool name defined ? */
862 sprintf(tmp_name, ".L\001%i", lp_count);
863 lp_sym = symbol_make(tmp_name);
866 /* Make name for literal pool entry. */
867 sprintf(tmp_name, ".L\001%i\002%i", lp_count, lpe_count);
869 lpe->sym = symbol_make(tmp_name);
871 /* Add to literal pool list. */
873 if (lpe_list_tail != NULL)
875 lpe_list_tail->next = lpe;
879 lpe_list = lpe_list_tail = lpe;
882 /* Now change exp_p to the offset into the literal pool.
883 Thats the expression: .L^Ax^By-.L^Ax */
884 exp_p->X_add_symbol = lpe->sym;
885 exp_p->X_op_symbol = lp_sym;
886 exp_p->X_op = O_subtract;
887 exp_p->X_add_number = 0;
891 /* We change the suffix type to ELF_SUFFIX_NONE, because
892 the difference of two local labels is just a number. */
893 return ELF_SUFFIX_NONE;
896 /* Like normal .long/.short/.word, except support @got, etc.
897 clobbers input_line_pointer, checks end-of-line. */
899 s390_elf_cons (nbytes)
900 register int nbytes; /* 1=.byte, 2=.word, 4=.long */
903 elf_suffix_type suffix;
905 if (is_it_end_of_statement ())
907 demand_empty_rest_of_line ();
915 if (exp.X_op == O_symbol
916 && *input_line_pointer == '@'
917 && (suffix = s390_elf_suffix (&input_line_pointer, &exp)) != ELF_SUFFIX_NONE)
919 bfd_reloc_code_real_type reloc;
920 reloc_howto_type *reloc_howto;
924 if (nbytes == 2 && suffix == ELF_SUFFIX_GOT)
925 reloc = BFD_RELOC_390_GOT16;
926 else if (nbytes == 4 && suffix == ELF_SUFFIX_GOT)
927 reloc = BFD_RELOC_32_GOT_PCREL;
928 else if (nbytes == 8 && suffix == ELF_SUFFIX_GOT)
929 reloc = BFD_RELOC_390_GOT64;
930 else if (nbytes == 4 && suffix == ELF_SUFFIX_PLT)
931 reloc = BFD_RELOC_390_PLT32;
932 else if (nbytes == 8 && suffix == ELF_SUFFIX_PLT)
933 reloc = BFD_RELOC_390_PLT64;
935 reloc = BFD_RELOC_UNUSED;
937 if (reloc != BFD_RELOC_UNUSED)
939 reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc);
940 size = bfd_get_reloc_size (reloc_howto);
942 as_bad (_("%s relocations do not fit in %d bytes"),
943 reloc_howto->name, nbytes);
944 where = frag_more(nbytes);
945 md_number_to_chars (where, 0, size);
946 fix_new_exp (frag_now, where - frag_now->fr_literal,
947 size, &exp, reloc_howto->pc_relative, reloc);
950 as_bad (_("relocation not applicable"));
953 emit_expr (&exp, (unsigned int) nbytes);
955 while (*input_line_pointer++ == ',');
957 input_line_pointer--; /* Put terminator back into stream. */
958 demand_empty_rest_of_line ();
961 /* We need to keep a list of fixups. We can't simply generate them as
962 we go, because that would require us to first create the frag, and
963 that would screw up references to ``.''. */
969 bfd_reloc_code_real_type reloc;
972 #define MAX_INSN_FIXUPS (4)
974 /* This routine is called for each instruction to be assembled. */
977 md_gather_operands (str, insn, opcode)
980 const struct s390_opcode *opcode;
982 struct s390_fixup fixups[MAX_INSN_FIXUPS];
983 const struct s390_operand *operand;
984 const unsigned char *opindex_ptr;
985 elf_suffix_type suffix;
986 bfd_reloc_code_real_type reloc;
992 while (isspace(*str)) str++;
997 /* Gather the operands. */
999 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1004 operand = s390_operands + *opindex_ptr;
1006 if (skip_optional && (operand->flags & S390_OPERAND_INDEX))
1008 /* We do an early skip. For D(X,B) constructions the index
1009 register is skipped (X is optional). For D(L,B) the base
1010 register will be the skipped operand, because L is NOT
1016 /* Gather the operand. */
1017 hold = input_line_pointer;
1018 input_line_pointer = str;
1020 if (! register_name (&ex)) /* parse the operand */
1023 str = input_line_pointer;
1024 input_line_pointer = hold;
1026 /* Write the operand to the insn. */
1027 if (ex.X_op == O_illegal)
1028 as_bad (_("illegal operand"));
1029 else if (ex.X_op == O_absent)
1030 as_bad (_("missing operand"));
1031 else if (ex.X_op == O_register || ex.X_op == O_constant)
1033 s390_lit_suffix (&str, &ex, ELF_SUFFIX_NONE);
1035 if (ex.X_op != O_register && ex.X_op != O_constant)
1037 /* We need to generate a fixup for the
1038 expression returned by s390_lit_suffix. */
1039 if (fc >= MAX_INSN_FIXUPS)
1040 as_fatal (_("too many fixups"));
1041 fixups[fc].exp = ex;
1042 fixups[fc].opindex = *opindex_ptr;
1043 fixups[fc].reloc = BFD_RELOC_UNUSED;
1048 if ((operand->flags & S390_OPERAND_INDEX) && ex.X_add_number == 0)
1049 as_warn("index register specified but zero");
1050 if ((operand->flags & S390_OPERAND_BASE) && ex.X_add_number == 0)
1051 as_warn("base register specified but zero");
1052 s390_insert_operand (insn, operand, ex.X_add_number, NULL, 0);
1057 suffix = s390_elf_suffix (&str, &ex);
1058 suffix = s390_lit_suffix (&str, &ex, suffix);
1059 reloc = BFD_RELOC_UNUSED;
1061 if (suffix == ELF_SUFFIX_GOT)
1063 if (operand->flags & S390_OPERAND_DISP)
1064 reloc = BFD_RELOC_390_GOT12;
1065 else if ((operand->flags & S390_OPERAND_SIGNED) &&
1066 (operand->bits == 16))
1067 reloc = BFD_RELOC_390_GOT16;
1068 else if ((operand->flags & S390_OPERAND_PCREL) &&
1069 (operand->bits == 32))
1070 reloc = BFD_RELOC_390_GOTENT;
1072 else if (suffix == ELF_SUFFIX_PLT)
1074 if ((operand->flags & S390_OPERAND_PCREL) &&
1075 (operand->bits == 16))
1076 reloc = BFD_RELOC_390_PLT16DBL;
1077 else if ((operand->flags & S390_OPERAND_PCREL) &&
1078 (operand->bits == 32))
1079 reloc = BFD_RELOC_390_PLT32DBL;
1081 else if (suffix == ELF_SUFFIX_GOTENT)
1083 if ((operand->flags & S390_OPERAND_PCREL) &&
1084 (operand->bits == 32))
1085 reloc = BFD_RELOC_390_GOTENT;
1088 if (suffix != ELF_SUFFIX_NONE && reloc == BFD_RELOC_UNUSED)
1089 as_bad (_("invalid operand suffix"));
1090 /* We need to generate a fixup of type 'reloc' for this
1092 if (fc >= MAX_INSN_FIXUPS)
1093 as_fatal (_("too many fixups"));
1094 fixups[fc].exp = ex;
1095 fixups[fc].opindex = *opindex_ptr;
1096 fixups[fc].reloc = reloc;
1100 /* Check the next character. The call to expression has advanced
1101 str past any whitespace. */
1102 if (operand->flags & S390_OPERAND_DISP)
1104 /* After a displacement a block in parentheses can start. */
1107 /* Check if parethesed block can be skipped. If the next
1108 operand is neiter an optional operand nor a base register
1109 then we have a syntax error. */
1110 operand = s390_operands + *(++opindex_ptr);
1111 if (!(operand->flags & (S390_OPERAND_INDEX|S390_OPERAND_BASE)))
1112 as_bad (_("syntax error; missing '(' after displacement"));
1114 /* Ok, skip all operands until S390_OPERAND_BASE. */
1115 while (!(operand->flags & S390_OPERAND_BASE))
1116 operand = s390_operands + *(++opindex_ptr);
1118 /* If there is a next operand it must be seperated by a comma. */
1119 if (opindex_ptr[1] != '\0')
1122 as_bad(_("syntax error; expected ,"));
1127 /* We found an opening parentheses. */
1129 for (f = str; *f != '\0'; f++)
1130 if (*f == ',' || *f == ')')
1132 /* If there is no comma until the closing parentheses OR
1133 there is a comma right after the opening parentheses,
1134 we have to skip optional operands. */
1135 if (*f == ',' && f == str)
1137 /* comma directly after '(' ? */
1142 skip_optional = (*f != ',');
1145 else if (operand->flags & S390_OPERAND_BASE)
1147 /* After the base register the parenthesed block ends. */
1149 as_bad (_("syntax error; missing ')' after base register"));
1151 /* If there is a next operand it must be seperated by a comma. */
1152 if (opindex_ptr[1] != '\0')
1155 as_bad (_("syntax error; expected ,"));
1160 /* We can find an 'early' closing parentheses in e.g. D(L) instead
1161 of D(L,B). In this case the base register has to be skipped. */
1164 operand = s390_operands + *(++opindex_ptr);
1166 if (!(operand->flags & S390_OPERAND_BASE))
1167 as_bad (_("syntax error; ')' not allowed here"));
1170 /* If there is a next operand it must be seperated by a comma. */
1171 if (opindex_ptr[1] != '\0')
1174 as_bad(_("syntax error; expected ,"));
1179 while (isspace (*str))
1186 if ((linefeed = strchr(str, '\n')) != NULL)
1188 as_bad (_("junk at end of line: `%s'"), str);
1189 if (linefeed != NULL)
1193 /* Write out the instruction. */
1194 f = frag_more (opcode->oplen);
1195 memcpy (f, insn, opcode->oplen);
1197 /* Create any fixups. At this point we do not use a
1198 bfd_reloc_code_real_type, but instead just use the
1199 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1200 handle fixups for any operand type, although that is admittedly
1201 not a very exciting feature. We pick a BFD reloc type in
1203 for (i = 0; i < fc; i++)
1205 operand = s390_operands + fixups[i].opindex;
1207 if (fixups[i].reloc != BFD_RELOC_UNUSED)
1209 reloc_howto_type *reloc_howto;
1213 reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
1217 size = bfd_get_reloc_size (reloc_howto);
1219 if (size < 1 || size > 4)
1222 fixP = fix_new_exp (frag_now,
1223 f - frag_now->fr_literal + (operand->shift/8),
1224 size, &fixups[i].exp, reloc_howto->pc_relative,
1226 /* Turn off overflow checking in fixup_segment. This is necessary
1227 because fixup_segment will signal an overflow for large 4 byte
1228 quantities for GOT12 relocations. */
1229 if (fixups[i].reloc == BFD_RELOC_390_GOT12 ||
1230 fixups[i].reloc == BFD_RELOC_390_GOT16)
1231 fixP->fx_no_overflow = 1;
1234 fix_new_exp (frag_now, f - frag_now->fr_literal, 4, &fixups[i].exp,
1235 (operand->flags & S390_OPERAND_PCREL) != 0,
1236 ((bfd_reloc_code_real_type)
1237 (fixups[i].opindex + (int) BFD_RELOC_UNUSED)));
1242 /* This routine is called for each instruction to be assembled. */
1248 const struct s390_opcode *opcode;
1249 unsigned char insn[6];
1252 /* Get the opcode. */
1253 for (s = str; *s != '\0' && ! isspace (*s); s++)
1258 /* Look up the opcode in the hash table. */
1259 opcode = (struct s390_opcode *) hash_find (s390_opcode_hash, str);
1260 if (opcode == (const struct s390_opcode *) NULL)
1262 as_bad (_("Unrecognized opcode: `%s'"), str);
1265 else if (!(opcode->architecture & current_arch_mask))
1267 as_bad("Opcode %s not available in this architecture", str);
1271 memcpy (insn, opcode->opcode, sizeof(insn));
1272 md_gather_operands (s, insn, opcode);
1275 #ifndef WORKING_DOT_WORD
1276 /* Handle long and short jumps. We don't support these */
1278 md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
1280 addressT from_addr, to_addr;
1288 md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
1290 addressT from_addr, to_addr;
1300 int ignore ATTRIBUTE_UNUSED;
1302 /* We don't support putting frags in the BSS segment, we fake it
1303 by marking in_bss, then looking at s_skip for clues. */
1305 subseg_set (bss_section, 0);
1306 demand_empty_rest_of_line ();
1309 /* Pseudo-op handling. */
1313 int ignore ATTRIBUTE_UNUSED;
1316 const struct s390_opcode *opformat;
1317 unsigned char insn[6];
1320 /* Get the opcode format. */
1321 s = input_line_pointer;
1322 while (*s != '\0' && *s != ',' && ! isspace (*s))
1325 as_bad (_("Invalid .insn format\n"));
1328 /* Look up the opcode in the hash table. */
1329 opformat = (struct s390_opcode *)
1330 hash_find (s390_opformat_hash, input_line_pointer);
1331 if (opformat == (const struct s390_opcode *) NULL)
1333 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer);
1336 input_line_pointer = s;
1338 if (exp.X_op == O_constant)
1340 if (opformat->oplen == 4 ||
1341 (opformat->oplen == 2 && exp.X_op < 0x10000))
1342 md_number_to_chars (insn, exp.X_add_number, opformat->oplen);
1344 as_bad(_("Invalid .insn format\n"));
1346 else if (exp.X_op == O_big)
1348 if (exp.X_add_number > 0 &&
1349 opformat->oplen == 6 &&
1350 generic_bignum[3] == 0)
1352 md_number_to_chars (insn, generic_bignum[2], 2);
1353 md_number_to_chars (&insn[2], generic_bignum[1], 2);
1354 md_number_to_chars (&insn[4], generic_bignum[0], 2);
1357 as_bad(_("Invalid .insn format\n"));
1360 as_bad (_("second operand of .insn not a constant\n"));
1361 if (*input_line_pointer++ != ',')
1362 as_bad (_("missing comma after insn constant\n"));
1364 if ((s = strchr(input_line_pointer, '\n')) != NULL)
1366 input_line_pointer = md_gather_operands (input_line_pointer, insn, opformat);
1369 demand_empty_rest_of_line ();
1372 /* The .byte pseudo-op. This is similar to the normal .byte
1373 pseudo-op, but it can also take a single ASCII string. */
1377 int ignore ATTRIBUTE_UNUSED;
1379 if (*input_line_pointer != '\"')
1385 /* Gather characters. A real double quote is doubled. Unusual
1386 characters are not permitted. */
1387 ++input_line_pointer;
1392 c = *input_line_pointer++;
1396 if (*input_line_pointer != '\"')
1398 ++input_line_pointer;
1401 FRAG_APPEND_1_CHAR (c);
1404 demand_empty_rest_of_line ();
1407 /* The .ltorg pseudo-op.This emits all literals defined since the last
1408 .ltorg or the invocation of gas. Literals are defined with the
1412 s390_literals (ignore)
1413 int ignore ATTRIBUTE_UNUSED;
1415 struct s390_lpe *lpe;
1417 if (lp_sym == NULL || lpe_count == 0)
1418 return; /* nothing to be done */
1420 /* Emit symbol for start of literal pool. */
1421 S_SET_SEGMENT (lp_sym, now_seg);
1422 S_SET_VALUE (lp_sym, (valueT) frag_now_fix ());
1423 lp_sym->sy_frag = frag_now;
1428 lpe_list = lpe_list->next;
1429 S_SET_SEGMENT (lpe->sym, now_seg);
1430 S_SET_VALUE (lpe->sym, (valueT) frag_now_fix ());
1431 lpe->sym->sy_frag = frag_now;
1433 /* Emit literal pool entry. */
1434 if (lpe->reloc != BFD_RELOC_UNUSED)
1436 reloc_howto_type *reloc_howto =
1437 bfd_reloc_type_lookup (stdoutput, lpe->reloc);
1438 int size = bfd_get_reloc_size (reloc_howto);
1441 if (size > lpe->nbytes)
1442 as_bad (_("%s relocations do not fit in %d bytes"),
1443 reloc_howto->name, lpe->nbytes);
1444 where = frag_more(lpe->nbytes);
1445 md_number_to_chars (where, 0, size);
1446 fix_new_exp (frag_now, where - frag_now->fr_literal,
1447 size, &lpe->ex, reloc_howto->pc_relative, lpe->reloc);
1451 if (lpe->ex.X_op == O_big)
1453 if (lpe->ex.X_add_number <= 0)
1454 generic_floating_point_number = lpe->floatnum;
1456 memcpy (generic_bignum, lpe->bignum,
1457 lpe->ex.X_add_number*sizeof(LITTLENUM_TYPE));
1459 emit_expr (&lpe->ex, lpe->nbytes);
1462 lpe->next = lpe_free_list;
1463 lpe_free_list = lpe;
1465 lpe_list_tail = NULL;
1471 /* Turn a string in input_line_pointer into a floating point constant
1472 of type type, and store the appropriate bytes in *litp. The number
1473 of LITTLENUMS emitted is stored in *sizep . An error message is
1474 returned, or NULL on OK. */
1477 md_atof (type, litp, sizep)
1483 LITTLENUM_TYPE words[4];
1499 return "bad call to md_atof";
1502 t = atof_ieee (input_line_pointer, type, words);
1504 input_line_pointer = t;
1508 for (i = 0; i < prec; i++)
1510 md_number_to_chars (litp, (valueT) words[i], 2);
1517 /* Align a section (I don't know why this is machine dependent). */
1520 md_section_align (seg, addr)
1524 int align = bfd_get_section_alignment (stdoutput, seg);
1526 return ((addr + (1 << align) - 1) & (-1 << align));
1529 /* We don't have any form of relaxing. */
1532 md_estimate_size_before_relax (fragp, seg)
1533 fragS *fragp ATTRIBUTE_UNUSED;
1534 asection *seg ATTRIBUTE_UNUSED;
1540 /* Convert a machine dependent frag. We never generate these. */
1543 md_convert_frag (abfd, sec, fragp)
1544 bfd *abfd ATTRIBUTE_UNUSED;
1545 asection *sec ATTRIBUTE_UNUSED;
1546 fragS *fragp ATTRIBUTE_UNUSED;
1552 md_undefined_symbol (name)
1555 if (*name == '_' && *(name+1) == 'G'
1556 && strcmp(name, "_GLOBAL_OFFSET_TABLE_") == 0)
1560 if(symbol_find(name))
1561 as_bad(_("GOT already in symbol table"));
1562 GOT_symbol = symbol_new (name, undefined_section,
1563 (valueT) 0, &zero_address_frag);
1570 /* Functions concerning relocs. */
1572 /* The location from which a PC relative jump should be calculated,
1573 given a PC relative reloc. */
1576 md_pcrel_from_section (fixp, sec)
1578 segT sec ATTRIBUTE_UNUSED;
1580 return fixp->fx_frag->fr_address + fixp->fx_where;
1583 /* Here we decide which fixups can be adjusted to make them relative to
1584 the beginning of the section instead of the symbol. Basically we need
1585 to make sure that the dynamic relocations are done correctly, so in
1586 some cases we force the original symbol to be used. */
1588 tc_s390_fix_adjustable(fixP)
1591 /* Prevent all adjustments to global symbols. */
1592 if (S_IS_EXTERN (fixP->fx_addsy))
1594 if (S_IS_WEAK (fixP->fx_addsy))
1596 /* adjust_reloc_syms doesn't know about the GOT. */
1597 if (fixP->fx_r_type == BFD_RELOC_32_GOTOFF
1598 || fixP->fx_r_type == BFD_RELOC_390_PLT16DBL
1599 || fixP->fx_r_type == BFD_RELOC_390_PLT32
1600 || fixP->fx_r_type == BFD_RELOC_390_PLT32DBL
1601 || fixP->fx_r_type == BFD_RELOC_390_PLT64
1602 || fixP->fx_r_type == BFD_RELOC_390_GOT12
1603 || fixP->fx_r_type == BFD_RELOC_390_GOT16
1604 || fixP->fx_r_type == BFD_RELOC_32_GOT_PCREL
1605 || fixP->fx_r_type == BFD_RELOC_390_GOT64
1606 || fixP->fx_r_type == BFD_RELOC_390_GOTENT
1607 || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
1608 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
1613 /* Apply a fixup to the object code. This is called for all the
1614 fixups we generated by the call to fix_new_exp, above. In the call
1615 above we used a reloc code which was the largest legal reloc code
1616 plus the operand index. Here we undo that to recover the operand
1617 index. At this point all symbol values should be fully resolved,
1618 and we attempt to completely resolve the reloc. If we can not do
1619 that, we determine the correct reloc code and put it back in the
1623 md_apply_fix3 (fixp, valuep, seg)
1626 segT seg ATTRIBUTE_UNUSED;
1632 where = fixp->fx_frag->fr_literal + fixp->fx_where;
1634 if (fixp->fx_subsy != NULL)
1636 if (!S_IS_DEFINED (fixp->fx_subsy))
1637 as_bad_where (fixp->fx_file, fixp->fx_line,
1638 _("unresolved fx_subsy symbol that must be resolved"));
1639 value -= S_GET_VALUE(fixp->fx_subsy);
1642 if (fixp->fx_addsy != NULL)
1644 /* `*valuep' may contain the value of the symbol on which the reloc
1645 will be based; we have to remove it. */
1646 if (fixp->fx_addsy->sy_used_in_reloc
1647 && S_GET_SEGMENT (fixp->fx_addsy) != absolute_section
1648 && S_GET_SEGMENT (fixp->fx_addsy) != undefined_section
1649 && ! bfd_is_com_section (S_GET_SEGMENT (fixp->fx_addsy)))
1650 value -= S_GET_VALUE (fixp->fx_addsy);
1653 value += fixp->fx_frag->fr_address + fixp->fx_where;
1658 if ((int) fixp->fx_r_type >= (int) BFD_RELOC_UNUSED)
1660 const struct s390_operand *operand;
1663 opindex = (int) fixp->fx_r_type - (int) BFD_RELOC_UNUSED;
1664 operand = &s390_operands[opindex];
1668 /* Insert the fully resolved operand value. */
1669 s390_insert_operand (where, operand, (offsetT) value,
1670 fixp->fx_file, fixp->fx_line);
1675 /* Determine a BFD reloc value based on the operand information.
1676 We are only prepared to turn a few of the operands into
1678 fixp->fx_offset = value;
1679 if (operand->bits == 12 && operand->shift == 20)
1682 fixp->fx_where += 2;
1683 fixp->fx_r_type = BFD_RELOC_390_12;
1685 else if (operand->bits == 12 && operand->shift == 36)
1688 fixp->fx_where += 4;
1689 fixp->fx_r_type = BFD_RELOC_390_12;
1691 else if (operand->bits == 8 && operand->shift == 8)
1694 fixp->fx_where += 1;
1695 fixp->fx_r_type = BFD_RELOC_8;
1697 else if (operand->bits == 16 && operand->shift == 16)
1700 fixp->fx_where += 2;
1701 if (operand->flags & S390_OPERAND_PCREL)
1703 fixp->fx_r_type = BFD_RELOC_390_PC16DBL;
1704 fixp->fx_offset += 2;
1707 fixp->fx_r_type = BFD_RELOC_16;
1709 else if (operand->bits == 32 && operand->shift == 16 &&
1710 (operand->flags & S390_OPERAND_PCREL))
1713 fixp->fx_where += 2;
1714 fixp->fx_offset += 2;
1715 fixp->fx_r_type = BFD_RELOC_390_PC32DBL;
1722 /* Use expr_symbol_where to see if this is an expression
1724 if (expr_symbol_where (fixp->fx_addsy, &sfile, &sline))
1725 as_bad_where (fixp->fx_file, fixp->fx_line,
1726 _("unresolved expression that must be resolved"));
1728 as_bad_where (fixp->fx_file, fixp->fx_line,
1729 _("unsupported relocation type"));
1736 switch (fixp->fx_r_type)
1742 md_number_to_chars (where, value, 1);
1744 case BFD_RELOC_390_12:
1745 case BFD_RELOC_390_GOT12:
1750 mop = bfd_getb16 ((unsigned char *) where);
1751 mop |= (unsigned short) (value & 0xfff);
1752 bfd_putb16 ((bfd_vma) mop, (unsigned char *) where);
1757 case BFD_RELOC_GPREL16:
1758 case BFD_RELOC_16_GOT_PCREL:
1759 case BFD_RELOC_16_GOTOFF:
1761 as_bad_where (fixp->fx_file, fixp->fx_line,
1762 "cannot emit PC relative %s relocation%s%s",
1763 bfd_get_reloc_code_name (fixp->fx_r_type),
1764 fixp->fx_addsy != NULL ? " against " : "",
1765 (fixp->fx_addsy != NULL
1766 ? S_GET_NAME (fixp->fx_addsy)
1769 md_number_to_chars (where, value, 2);
1771 case BFD_RELOC_390_GOT16:
1773 md_number_to_chars (where, value, 2);
1775 case BFD_RELOC_390_PC16DBL:
1776 case BFD_RELOC_390_PLT16DBL:
1779 md_number_to_chars (where, (offsetT) value >> 1, 2);
1784 fixp->fx_r_type = BFD_RELOC_32_PCREL;
1786 fixp->fx_r_type = BFD_RELOC_32;
1788 md_number_to_chars (where, value, 4);
1790 case BFD_RELOC_32_PCREL:
1791 case BFD_RELOC_32_BASEREL:
1792 fixp->fx_r_type = BFD_RELOC_32_PCREL;
1794 md_number_to_chars (where, value, 4);
1796 case BFD_RELOC_32_GOT_PCREL:
1797 case BFD_RELOC_390_PLT32:
1799 md_number_to_chars (where, value, 4);
1801 case BFD_RELOC_390_PC32DBL:
1802 case BFD_RELOC_390_PLT32DBL:
1803 case BFD_RELOC_390_GOTPCDBL:
1804 case BFD_RELOC_390_GOTENT:
1807 md_number_to_chars (where, (offsetT) value >> 1, 4);
1810 case BFD_RELOC_32_GOTOFF:
1812 md_number_to_chars (where, value, sizeof(int));
1815 case BFD_RELOC_390_GOT64:
1816 case BFD_RELOC_390_PLT64:
1818 md_number_to_chars (where, value, 8);
1823 fixp->fx_r_type = BFD_RELOC_64_PCREL;
1825 fixp->fx_r_type = BFD_RELOC_64;
1827 md_number_to_chars (where, value, 8);
1830 case BFD_RELOC_64_PCREL:
1831 fixp->fx_r_type = BFD_RELOC_64_PCREL;
1833 md_number_to_chars (where, value, 8);
1836 case BFD_RELOC_VTABLE_INHERIT:
1837 case BFD_RELOC_VTABLE_ENTRY:
1843 const char *reloc_name = bfd_get_reloc_code_name (fixp->fx_r_type);
1845 if (reloc_name != NULL)
1846 fprintf (stderr, "Gas failure, reloc type %s\n", reloc_name);
1848 fprintf (stderr, "Gas failure, reloc type #%i\n", fixp->fx_r_type);
1854 fixp->fx_offset = value;
1860 /* Generate a reloc for a fixup. */
1863 tc_gen_reloc (seg, fixp)
1864 asection *seg ATTRIBUTE_UNUSED;
1867 bfd_reloc_code_real_type code;
1870 code = fixp->fx_r_type;
1871 if (GOT_symbol && fixp->fx_addsy == GOT_symbol)
1873 if ((s390_arch_size == 32 && code == BFD_RELOC_32_PCREL) ||
1874 (s390_arch_size == 64 && code == BFD_RELOC_64_PCREL))
1875 code = BFD_RELOC_390_GOTPC;
1876 if (code == BFD_RELOC_390_PC32DBL)
1877 code = BFD_RELOC_390_GOTPCDBL;
1880 reloc = (arelent *) xmalloc (sizeof (arelent));
1881 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
1882 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1883 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
1884 reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
1885 if (reloc->howto == NULL)
1887 as_bad_where (fixp->fx_file, fixp->fx_line,
1888 _("cannot represent relocation type %s"),
1889 bfd_get_reloc_code_name (code));
1890 /* Set howto to a garbage value so that we can keep going. */
1891 reloc->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
1892 assert (reloc->howto != NULL);
1894 reloc->addend = fixp->fx_offset;
1900 s390_force_relocation (fixp)
1903 if ( fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
1904 || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)