Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Enumerations | Functions | Variables
tc-s390.c File Reference
#include "as.h"
#include "safe-ctype.h"
#include "subsegs.h"
#include "struc-symbol.h"
#include "dwarf2dbg.h"
#include "dw2gencfi.h"
#include "opcode/s390.h"
#include "elf/s390.h"

Go to the source code of this file.

Classes

struct  pd_reg
struct  map_tls
struct  map_bfd
struct  s390_lpe
struct  s390_fixup

Defines

#define DEFAULT_ARCH   "s390"
#define TARGET_REG_NAMES_P   TRUE
#define REG_NAME_CNT   (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
#define MAX_INSN_FIXUPS   (4)

Enumerations

enum  elf_suffix_type {
  ELF_SUFFIX_NONE = 0, ELF_SUFFIX_GOT, ELF_SUFFIX_PLT, ELF_SUFFIX_GOTENT,
  ELF_SUFFIX_GOTOFF, ELF_SUFFIX_GOTPLT, ELF_SUFFIX_PLTOFF, ELF_SUFFIX_TLS_GD,
  ELF_SUFFIX_TLS_GOTIE, ELF_SUFFIX_TLS_IE, ELF_SUFFIX_TLS_LDM, ELF_SUFFIX_TLS_LDO,
  ELF_SUFFIX_TLS_LE
}

Functions

static void s390_byte PARAMS ((int))
static int reg_name_search PARAMS ((const struct pd_reg *, int, const char *))
static bfd_boolean register_name PARAMS ((expressionS *))
static void init_default_arch PARAMS ((void))
static void s390_insert_operand PARAMS ((unsigned char *, const struct s390_operand *, offsetT, char *, unsigned int))
static char *md_gather_operands PARAMS ((char *, unsigned char *, const struct s390_opcode *))
static int reg_name_search (struct pd_reg *regs, int regcount, const char *name) const
static bfd_boolean register_name (expressionS *expressionP)
static void init_default_arch ()
const char * s390_target_format ()
int md_parse_option (int c, char *arg)
void md_show_usage (FILE *stream)
void md_begin ()
void s390_md_end ()
static void s390_insert_operand (unsigned char *insn, const struct s390_operand *operand, offsetT val, char *file, unsigned int line)
static
bfd_reloc_code_real_type
s390_tls_suffix 
PARAMS ((char **, expressionS *))
static bfd_reloc_code_real_type s390_tls_suffix (char **str_p, expressionS *exp_p)
static int s390_exp_compare PARAMS ((expressionS *exp1, expressionS *exp2))
static elf_suffix_type
s390_lit_suffix 
PARAMS ((char **, expressionS *, elf_suffix_type))
static elf_suffix_type s390_elf_suffix (char **str_p, expressionS *exp_p)
static int s390_exp_compare (expressionS *exp1, expressionS *exp2)
static elf_suffix_type s390_lit_suffix (char **str_p, expressionS *exp_p, elf_suffix_type suffix)
static void s390_elf_cons (int nbytes)
static char * md_gather_operands (char *str, unsigned char *insn, const struct s390_opcode *opcode)
void md_assemble (char *str)
void md_create_short_jump (char *ptr, addressT from_addr, addressT to_addr, fragS *frag, symbolS *to_symbol)
void md_create_long_jump (char *ptr, addressT from_addr, addressT to_addr, fragS *frag, symbolS *to_symbol)
void s390_bss (ignore)
void s390_insn (ignore)
static void s390_byte (ignore)
static void s390_literals (ignore)
char * md_atof (int type, char *litp, int *sizep)
valueT md_section_align (asection *seg, valueT addr)
int md_estimate_size_before_relax (fragp, seg)
void md_convert_frag (abfd, sec, fragp)
symbolS * md_undefined_symbol (char *name)
long md_pcrel_from_section (fixS *fixp, sec)
int tc_s390_fix_adjustable (fixS *fixP)
int tc_s390_force_relocation (struct fix *fixp)
void md_apply_fix (fixS *fixP, valueT *valP, seg)
arelenttc_gen_reloc (seg, fixS *fixp)
void s390_cfi_frame_initial_instructions ()
int tc_s390_regname_to_dw2regnum (char *regname)

Variables

static char * default_arch = DEFAULT_ARCH
static int s390_arch_size = 0
static unsigned int current_mode_mask = 0
static unsigned int current_cpu = -1U
static bfd_boolean reg_names_p = TARGET_REG_NAMES_P
static bfd_boolean warn_areg_zero = FALSE
const char comment_chars [] = "#"
const char line_comment_chars [] = "#"
const char line_separator_chars [] = ";"
const char EXP_CHARS [] = "eE"
const char FLT_CHARS [] = "dD"
int s390_cie_data_alignment
const pseudo_typeS md_pseudo_table []
static struct pd_reg []
static struct hash_controls390_opformat_hash
static struct hash_controls390_opcode_hash
static flagword s390_flags = 0
symbolS * GOT_symbol
int md_short_jump_size = 4
int md_long_jump_size = 4
const char * md_shortopts = "A:m:kVQ:"
size_t md_longopts_size = sizeof (md_longopts)
static struct s390_lpelpe_free_list = NULL
static struct s390_lpelpe_list = NULL
static struct s390_lpelpe_list_tail = NULL
static symbolS * lp_sym = NULL
static int lp_count = 0
static int lpe_count = 0

Class Documentation

struct pd_reg

Definition at line 467 of file tc-hppa.c.

Class Members
char * name
char * pname
int value
struct map_tls

Definition at line 632 of file tc-s390.c.

Class Members
int length
bfd_reloc_code_real_type reloc
char * string
struct map_bfd

Definition at line 712 of file tc-s390.c.

Class Members
int length
char * string
elf_suffix_type suffix
struct s390_lpe

Definition at line 817 of file tc-s390.c.

Collaboration diagram for s390_lpe:
Class Members
LITTLENUM_TYPE bignum
expressionS ex
FLONUM_TYPE floatnum
int nbytes
struct s390_lpe * next
bfd_reloc_code_real_type reloc
symbolS * sym
struct s390_fixup

Definition at line 1154 of file tc-s390.c.

Collaboration diagram for s390_fixup:
Class Members
expressionS exp
int opindex
bfd_reloc_code_real_type reloc

Define Documentation

#define DEFAULT_ARCH   "s390"

Definition at line 35 of file tc-s390.c.

#define MAX_INSN_FIXUPS   (4)

Definition at line 1161 of file tc-s390.c.

#define REG_NAME_CNT   (sizeof (pre_defined_registers) / sizeof (struct pd_reg))

Definition at line 206 of file tc-s390.c.

#define TARGET_REG_NAMES_P   TRUE

Definition at line 46 of file tc-s390.c.


Enumeration Type Documentation

Enumerator:
ELF_SUFFIX_NONE 
ELF_SUFFIX_GOT 
ELF_SUFFIX_PLT 
ELF_SUFFIX_GOTENT 
ELF_SUFFIX_GOTOFF 
ELF_SUFFIX_GOTPLT 
ELF_SUFFIX_PLTOFF 
ELF_SUFFIX_TLS_GD 
ELF_SUFFIX_TLS_GOTIE 
ELF_SUFFIX_TLS_IE 
ELF_SUFFIX_TLS_LDM 
ELF_SUFFIX_TLS_LDO 
ELF_SUFFIX_TLS_LE 

Definition at line 694 of file tc-s390.c.


Function Documentation

static void init_default_arch ( ) [static]

Definition at line 328 of file tc-s390.c.

{
  if (strcmp (default_arch, "s390") == 0)
    {
      if (s390_arch_size == 0)
       s390_arch_size = 32;
    }
  else if (strcmp (default_arch, "s390x") == 0)
    {
      if (s390_arch_size == 0)
       s390_arch_size = 64;
    }
  else
    as_fatal ("Invalid default architecture, broken assembler.");

  if (current_mode_mask == 0)
    {
      if (s390_arch_size == 32)
       current_mode_mask = 1 << S390_OPCODE_ESA;
      else
       current_mode_mask = 1 << S390_OPCODE_ZARCH;
    }
  if (current_cpu == -1U)
    {
      if (current_mode_mask == (1 << S390_OPCODE_ESA))
       current_cpu = S390_OPCODE_G5;
      else
       current_cpu = S390_OPCODE_Z900;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void md_apply_fix ( fixS *  fixP,
valueT valP,
seg   
)

Definition at line 1996 of file tc-s390.c.

{
  char *where;
  valueT value = *valP;

  where = fixP->fx_frag->fr_literal + fixP->fx_where;

  if (fixP->fx_subsy != NULL)
    as_bad_where (fixP->fx_file, fixP->fx_line,
                "cannot emit relocation %s against subsy symbol %s",
                bfd_get_reloc_code_name (fixP->fx_r_type),
                S_GET_NAME (fixP->fx_subsy));

  if (fixP->fx_addsy != NULL)
    {
      if (fixP->fx_pcrel)
       value += fixP->fx_frag->fr_address + fixP->fx_where;
    }
  else
    fixP->fx_done = 1;

  if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
    {
      const struct s390_operand *operand;
      int opindex;

      opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
      operand = &s390_operands[opindex];

      if (fixP->fx_done)
       {
         /* Insert the fully resolved operand value.  */
         s390_insert_operand ((unsigned char *) where, operand,
                            (offsetT) value, fixP->fx_file, fixP->fx_line);
         return;
       }

      /* Determine a BFD reloc value based on the operand information.
        We are only prepared to turn a few of the operands into
        relocs.  */
      fixP->fx_offset = value;
      if (operand->bits == 12 && operand->shift == 20)
       {
         fixP->fx_size = 2;
         fixP->fx_where += 2;
         fixP->fx_r_type = BFD_RELOC_390_12;
       }
      else if (operand->bits == 12 && operand->shift == 36)
       {
         fixP->fx_size = 2;
         fixP->fx_where += 4;
         fixP->fx_r_type = BFD_RELOC_390_12;
       }
      else if (operand->bits == 20 && operand->shift == 20)
       {
         fixP->fx_size = 2;
         fixP->fx_where += 2;
         fixP->fx_r_type = BFD_RELOC_390_20;
       }
      else if (operand->bits == 8 && operand->shift == 8)
       {
         fixP->fx_size = 1;
         fixP->fx_where += 1;
         fixP->fx_r_type = BFD_RELOC_8;
       }
      else if (operand->bits == 16 && operand->shift == 16)
       {
         fixP->fx_size = 2;
         fixP->fx_where += 2;
         if (operand->flags & S390_OPERAND_PCREL)
           {
             fixP->fx_r_type = BFD_RELOC_390_PC16DBL;
             fixP->fx_offset += 2;
           }
         else
           fixP->fx_r_type = BFD_RELOC_16;
       }
      else if (operand->bits == 32 && operand->shift == 16
              && (operand->flags & S390_OPERAND_PCREL))
       {
         fixP->fx_size = 4;
         fixP->fx_where += 2;
         fixP->fx_offset += 2;
         fixP->fx_r_type = BFD_RELOC_390_PC32DBL;
       }
      else
       {
         char *sfile;
         unsigned int sline;

         /* Use expr_symbol_where to see if this is an expression
            symbol.  */
         if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline))
           as_bad_where (fixP->fx_file, fixP->fx_line,
                       _("unresolved expression that must be resolved"));
         else
           as_bad_where (fixP->fx_file, fixP->fx_line,
                       _("unsupported relocation type"));
         fixP->fx_done = 1;
         return;
       }
    }
  else
    {
      switch (fixP->fx_r_type)
       {
       case BFD_RELOC_8:
         if (fixP->fx_pcrel)
           abort ();
         if (fixP->fx_done)
           md_number_to_chars (where, value, 1);
         break;
       case BFD_RELOC_390_12:
       case BFD_RELOC_390_GOT12:
       case BFD_RELOC_390_GOTPLT12:
         if (fixP->fx_done)
           {
             unsigned short mop;

             mop = bfd_getb16 ((unsigned char *) where);
             mop |= (unsigned short) (value & 0xfff);
             bfd_putb16 ((bfd_vma) mop, (unsigned char *) where);
           }
         break;

       case BFD_RELOC_390_20:
       case BFD_RELOC_390_GOT20:
       case BFD_RELOC_390_GOTPLT20:
         if (fixP->fx_done)
           {
             unsigned int mop;
             mop = bfd_getb32 ((unsigned char *) where);
             mop |= (unsigned int) ((value & 0xfff) << 8 |
                                 (value & 0xff000) >> 12);
             bfd_putb32 ((bfd_vma) mop, (unsigned char *) where);
           } 
         break;

       case BFD_RELOC_16:
       case BFD_RELOC_GPREL16:
       case BFD_RELOC_16_GOT_PCREL:
       case BFD_RELOC_16_GOTOFF:
         if (fixP->fx_pcrel)
           as_bad_where (fixP->fx_file, fixP->fx_line,
                       "cannot emit PC relative %s relocation%s%s",
                       bfd_get_reloc_code_name (fixP->fx_r_type),
                       fixP->fx_addsy != NULL ? " against " : "",
                       (fixP->fx_addsy != NULL
                        ? S_GET_NAME (fixP->fx_addsy)
                        : ""));
         if (fixP->fx_done)
           md_number_to_chars (where, value, 2);
         break;
       case BFD_RELOC_390_GOT16:
       case BFD_RELOC_390_PLTOFF16:
       case BFD_RELOC_390_GOTPLT16:
         if (fixP->fx_done)
           md_number_to_chars (where, value, 2);
         break;
       case BFD_RELOC_390_PC16DBL:
       case BFD_RELOC_390_PLT16DBL:
         value += 2;
         if (fixP->fx_done)
           md_number_to_chars (where, (offsetT) value >> 1, 2);
         break;

       case BFD_RELOC_32:
         if (fixP->fx_pcrel)
           fixP->fx_r_type = BFD_RELOC_32_PCREL;
         else
           fixP->fx_r_type = BFD_RELOC_32;
         if (fixP->fx_done)
           md_number_to_chars (where, value, 4);
         break;
       case BFD_RELOC_32_PCREL:
       case BFD_RELOC_32_BASEREL:
         fixP->fx_r_type = BFD_RELOC_32_PCREL;
         if (fixP->fx_done)
           md_number_to_chars (where, value, 4);
         break;
       case BFD_RELOC_32_GOT_PCREL:
       case BFD_RELOC_390_PLTOFF32:
       case BFD_RELOC_390_PLT32:
       case BFD_RELOC_390_GOTPLT32:
         if (fixP->fx_done)
           md_number_to_chars (where, value, 4);
         break;
       case BFD_RELOC_390_PC32DBL:
       case BFD_RELOC_390_PLT32DBL:
       case BFD_RELOC_390_GOTPCDBL:
       case BFD_RELOC_390_GOTENT:
       case BFD_RELOC_390_GOTPLTENT:
         value += 2;
         if (fixP->fx_done)
           md_number_to_chars (where, (offsetT) value >> 1, 4);
         break;

       case BFD_RELOC_32_GOTOFF:
         if (fixP->fx_done)
           md_number_to_chars (where, value, sizeof (int));
         break;

       case BFD_RELOC_390_GOTOFF64:
         if (fixP->fx_done)
           md_number_to_chars (where, value, 8);
         break;

       case BFD_RELOC_390_GOT64:
       case BFD_RELOC_390_PLTOFF64:
       case BFD_RELOC_390_PLT64:
       case BFD_RELOC_390_GOTPLT64:
         if (fixP->fx_done)
           md_number_to_chars (where, value, 8);
         break;

       case BFD_RELOC_64:
         if (fixP->fx_pcrel)
           fixP->fx_r_type = BFD_RELOC_64_PCREL;
         else
           fixP->fx_r_type = BFD_RELOC_64;
         if (fixP->fx_done)
           md_number_to_chars (where, value, 8);
         break;

       case BFD_RELOC_64_PCREL:
         fixP->fx_r_type = BFD_RELOC_64_PCREL;
         if (fixP->fx_done)
           md_number_to_chars (where, value, 8);
         break;

       case BFD_RELOC_VTABLE_INHERIT:
       case BFD_RELOC_VTABLE_ENTRY:
         fixP->fx_done = 0;
         return;

       case BFD_RELOC_390_TLS_LOAD:
       case BFD_RELOC_390_TLS_GDCALL:
       case BFD_RELOC_390_TLS_LDCALL:
       case BFD_RELOC_390_TLS_GD32:
       case BFD_RELOC_390_TLS_GD64:
       case BFD_RELOC_390_TLS_GOTIE12:
       case BFD_RELOC_390_TLS_GOTIE20:
       case BFD_RELOC_390_TLS_GOTIE32:
       case BFD_RELOC_390_TLS_GOTIE64:
       case BFD_RELOC_390_TLS_LDM32:
       case BFD_RELOC_390_TLS_LDM64:
       case BFD_RELOC_390_TLS_IE32:
       case BFD_RELOC_390_TLS_IE64:
       case BFD_RELOC_390_TLS_LE32:
       case BFD_RELOC_390_TLS_LE64:
       case BFD_RELOC_390_TLS_LDO32:
       case BFD_RELOC_390_TLS_LDO64:
       case BFD_RELOC_390_TLS_DTPMOD:
       case BFD_RELOC_390_TLS_DTPOFF:
       case BFD_RELOC_390_TLS_TPOFF:
         S_SET_THREAD_LOCAL (fixP->fx_addsy);
         /* Fully resolved at link time.  */
         break;
       case BFD_RELOC_390_TLS_IEENT:
         /* Fully resolved at link time.  */
         S_SET_THREAD_LOCAL (fixP->fx_addsy);
         value += 2;
         break;

       default:
         {
           const char *reloc_name = bfd_get_reloc_code_name (fixP->fx_r_type);

           if (reloc_name != NULL)
             fprintf (stderr, "Gas failure, reloc type %s\n", reloc_name);
           else
             fprintf (stderr, "Gas failure, reloc type #%i\n", fixP->fx_r_type);
           fflush (stderr);
           abort ();
         }
       }

      fixP->fx_offset = value;
    }
}

Here is the call graph for this function:

void md_assemble ( char *  str)

Definition at line 1541 of file tc-s390.c.

{
  const struct s390_opcode *opcode;
  unsigned char insn[6];
  char *s;

  /* Get the opcode.  */
  for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
    ;
  if (*s != '\0')
    *s++ = '\0';

  /* Look up the opcode in the hash table.  */
  opcode = (struct s390_opcode *) hash_find (s390_opcode_hash, str);
  if (opcode == (const struct s390_opcode *) NULL)
    {
      as_bad (_("Unrecognized opcode: `%s'"), str);
      return;
    }
  else if (!(opcode->modes & current_mode_mask))
    {
      as_bad ("Opcode %s not available in this mode", str);
      return;
    }
  memcpy (insn, opcode->opcode, sizeof (insn));
  md_gather_operands (s, insn, opcode);
}

Here is the call graph for this function:

char* md_atof ( int type  ,
char *  litp,
int sizep 
)

Definition at line 1778 of file tc-s390.c.

{
  int prec;
  LITTLENUM_TYPE words[4];
  char *t;
  int i;

  switch (type)
    {
    case 'f':
      prec = 2;
      break;

    case 'd':
      prec = 4;
      break;

    default:
      *sizep = 0;
      return "bad call to md_atof";
    }

  t = atof_ieee (input_line_pointer, type, words);
  if (t)
    input_line_pointer = t;

  *sizep = prec * 2;

  for (i = 0; i < prec; i++)
    {
      md_number_to_chars (litp, (valueT) words[i], 2);
      litp += 2;
    }

  return NULL;
}

Here is the call graph for this function:

void md_begin ( void  )

Definition at line 478 of file tc-s390.c.

{
  register const struct s390_opcode *op;
  const struct s390_opcode *op_end;
  bfd_boolean dup_insn = FALSE;
  const char *retval;

  /* Give a warning if the combination -m64-bit and -Aesa is used.  */
  if (s390_arch_size == 64 && current_cpu < S390_OPCODE_Z900)
    as_warn ("The 64 bit file format is used without esame instructions.");

  s390_cie_data_alignment = -s390_arch_size / 8;

  /* Set the ELF flags if desired.  */
  if (s390_flags)
    bfd_set_private_flags (stdoutput, s390_flags);

  /* Insert the opcode formats into a hash table.  */
  s390_opformat_hash = hash_new ();

  op_end = s390_opformats + s390_num_opformats;
  for (op = s390_opformats; op < op_end; op++)
    {
      retval = hash_insert (s390_opformat_hash, op->name, (PTR) op);
      if (retval != (const char *) NULL)
       {
         as_bad (_("Internal assembler error for instruction format %s"),
                op->name);
         dup_insn = TRUE;
       }
    }

  /* Insert the opcodes into a hash table.  */
  s390_opcode_hash = hash_new ();

  op_end = s390_opcodes + s390_num_opcodes;
  for (op = s390_opcodes; op < op_end; op++)
    if (op->min_cpu <= current_cpu)
      {
       retval = hash_insert (s390_opcode_hash, op->name, (PTR) op);
       if (retval != (const char *) NULL)
         {
           as_bad (_("Internal assembler error for instruction %s"),
                  op->name);
           dup_insn = TRUE;
         }
       while (op < op_end - 1 && strcmp (op->name, op[1].name) == 0)
         op++;
      }

  if (dup_insn)
    abort ();

  record_alignment (text_section, 2);
  record_alignment (data_section, 2);
  record_alignment (bss_section, 2);

}

Here is the call graph for this function:

void md_convert_frag ( abfd  ,
sec  ,
fragp   
)

Definition at line 1844 of file tc-s390.c.

{
  abort ();
}
void md_create_long_jump ( char *  ptr,
addressT from_addr  ,
addressT to_addr  ,
fragS *  frag,
symbolS *  to_symbol 
)

Definition at line 1583 of file tc-s390.c.

{
  abort ();
}
void md_create_short_jump ( char *  ptr,
addressT from_addr  ,
addressT to_addr  ,
fragS *  frag,
symbolS *  to_symbol 
)

Definition at line 1573 of file tc-s390.c.

{
  abort ();
}

Definition at line 1833 of file tc-s390.c.

{
  abort ();
  return 0;
}
static char* md_gather_operands ( char *  str,
unsigned char *  insn,
const struct s390_opcode opcode 
) [static]

Definition at line 1166 of file tc-s390.c.

{
  struct s390_fixup fixups[MAX_INSN_FIXUPS];
  const struct s390_operand *operand;
  const unsigned char *opindex_ptr;
  expressionS ex;
  elf_suffix_type suffix;
  bfd_reloc_code_real_type reloc;
  int skip_optional;
  int parentheses;
  char *f;
  int fc, i;

  while (ISSPACE (*str))
    str++;

  parentheses = 0;
  skip_optional = 0;

  /* Gather the operands.  */
  fc = 0;
  for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
    {
      char *hold;

      operand = s390_operands + *opindex_ptr;

      if (skip_optional && (operand->flags & S390_OPERAND_INDEX))
       {
         /* We do an early skip. For D(X,B) constructions the index
            register is skipped (X is optional). For D(L,B) the base
            register will be the skipped operand, because L is NOT
            optional.  */
         skip_optional = 0;
         continue;
       }

      /* Gather the operand.  */
      hold = input_line_pointer;
      input_line_pointer = str;

      /* Parse the operand.  */
      if (! register_name (&ex))
       expression (&ex);

      str = input_line_pointer;
      input_line_pointer = hold;

      /* Write the operand to the insn.  */
      if (ex.X_op == O_illegal)
       as_bad (_("illegal operand"));
      else if (ex.X_op == O_absent)
       as_bad (_("missing operand"));
      else if (ex.X_op == O_register || ex.X_op == O_constant)
       {
         s390_lit_suffix (&str, &ex, ELF_SUFFIX_NONE);

         if (ex.X_op != O_register && ex.X_op != O_constant)
           {
             /* We need to generate a fixup for the
               expression returned by s390_lit_suffix.  */
             if (fc >= MAX_INSN_FIXUPS)
              as_fatal (_("too many fixups"));
             fixups[fc].exp = ex;
             fixups[fc].opindex = *opindex_ptr;
             fixups[fc].reloc = BFD_RELOC_UNUSED;
             ++fc;
           }
         else
           {
             if ((operand->flags & S390_OPERAND_INDEX)
                && ex.X_add_number == 0
                && warn_areg_zero)
              as_warn ("index register specified but zero");
             if ((operand->flags & S390_OPERAND_BASE)
                && ex.X_add_number == 0
                && warn_areg_zero)
              as_warn ("base register specified but zero");
             s390_insert_operand (insn, operand, ex.X_add_number, NULL, 0);
           }
       }
      else
       {
         suffix = s390_elf_suffix (&str, &ex);
         suffix = s390_lit_suffix (&str, &ex, suffix);
         reloc = BFD_RELOC_UNUSED;

         if (suffix == ELF_SUFFIX_GOT)
           {
             if ((operand->flags & S390_OPERAND_DISP) &&
                (operand->bits == 12))
              reloc = BFD_RELOC_390_GOT12;
             else if ((operand->flags & S390_OPERAND_DISP) &&
                     (operand->bits == 20))
              reloc = BFD_RELOC_390_GOT20;
             else if ((operand->flags & S390_OPERAND_SIGNED)
                     && (operand->bits == 16))
              reloc = BFD_RELOC_390_GOT16;
             else if ((operand->flags & S390_OPERAND_PCREL)
                     && (operand->bits == 32))
              reloc = BFD_RELOC_390_GOTENT;
           }
         else if (suffix == ELF_SUFFIX_PLT)
           {
             if ((operand->flags & S390_OPERAND_PCREL)
                && (operand->bits == 16))
              reloc = BFD_RELOC_390_PLT16DBL;
             else if ((operand->flags & S390_OPERAND_PCREL)
                     && (operand->bits == 32))
              reloc = BFD_RELOC_390_PLT32DBL;
           }
         else if (suffix == ELF_SUFFIX_GOTENT)
           {
             if ((operand->flags & S390_OPERAND_PCREL)
                && (operand->bits == 32))
              reloc = BFD_RELOC_390_GOTENT;
           }
         else if (suffix == ELF_SUFFIX_GOTOFF)
           {
             if ((operand->flags & S390_OPERAND_SIGNED)
                && (operand->bits == 16))
              reloc = BFD_RELOC_16_GOTOFF;
           }
         else if (suffix == ELF_SUFFIX_PLTOFF)
           {
             if ((operand->flags & S390_OPERAND_SIGNED)
                && (operand->bits == 16))
              reloc = BFD_RELOC_390_PLTOFF16;
           }
         else if (suffix == ELF_SUFFIX_GOTPLT)
           {
             if ((operand->flags & S390_OPERAND_DISP)
                && (operand->bits == 12))
              reloc = BFD_RELOC_390_GOTPLT12;
             else if ((operand->flags & S390_OPERAND_SIGNED)
                     && (operand->bits == 16))
              reloc = BFD_RELOC_390_GOTPLT16;
             else if ((operand->flags & S390_OPERAND_PCREL)
                     && (operand->bits == 32))
              reloc = BFD_RELOC_390_GOTPLTENT;
           }
         else if (suffix == ELF_SUFFIX_TLS_GOTIE)
           {
             if ((operand->flags & S390_OPERAND_DISP)
                && (operand->bits == 12))
              reloc = BFD_RELOC_390_TLS_GOTIE12;
             else if ((operand->flags & S390_OPERAND_DISP)
                     && (operand->bits == 20))
              reloc = BFD_RELOC_390_TLS_GOTIE20;
           }
         else if (suffix == ELF_SUFFIX_TLS_IE)
           {
             if ((operand->flags & S390_OPERAND_PCREL)
                     && (operand->bits == 32))
              reloc = BFD_RELOC_390_TLS_IEENT;
           }

         if (suffix != ELF_SUFFIX_NONE && reloc == BFD_RELOC_UNUSED)
           as_bad (_("invalid operand suffix"));
         /* We need to generate a fixup of type 'reloc' for this
            expression.  */
         if (fc >= MAX_INSN_FIXUPS)
           as_fatal (_("too many fixups"));
         fixups[fc].exp = ex;
         fixups[fc].opindex = *opindex_ptr;
         fixups[fc].reloc = reloc;
         ++fc;
       }

      /* Check the next character. The call to expression has advanced
        str past any whitespace.  */
      if (operand->flags & S390_OPERAND_DISP)
       {
         /* After a displacement a block in parentheses can start.  */
         if (*str != '(')
           {
             /* Check if parenthesized block can be skipped. If the next
               operand is neiter an optional operand nor a base register
               then we have a syntax error.  */
             operand = s390_operands + *(++opindex_ptr);
             if (!(operand->flags & (S390_OPERAND_INDEX|S390_OPERAND_BASE)))
              as_bad (_("syntax error; missing '(' after displacement"));

             /* Ok, skip all operands until S390_OPERAND_BASE.  */
             while (!(operand->flags & S390_OPERAND_BASE))
              operand = s390_operands + *(++opindex_ptr);

             /* If there is a next operand it must be separated by a comma.  */
             if (opindex_ptr[1] != '\0')
              {
                if (*str != ',')
                  {
                    while (opindex_ptr[1] != '\0')
                     {
                       operand = s390_operands + *(++opindex_ptr);
                       if (operand->flags & S390_OPERAND_OPTIONAL)
                         continue;
                       as_bad (_("syntax error; expected ,"));
                       break;
                     }
                  }
                else
                  str++;
              }
           }
         else
           {
             /* We found an opening parentheses.  */
             str++;
             for (f = str; *f != '\0'; f++)
              if (*f == ',' || *f == ')')
                break;
             /* If there is no comma until the closing parentheses OR
               there is a comma right after the opening parentheses,
               we have to skip optional operands.  */
             if (*f == ',' && f == str)
              {
                /* comma directly after '(' ? */
                skip_optional = 1;
                str++;
              }
             else
              skip_optional = (*f != ',');
           }
       }
      else if (operand->flags & S390_OPERAND_BASE)
       {
         /* After the base register the parenthesed block ends.  */
         if (*str++ != ')')
           as_bad (_("syntax error; missing ')' after base register"));
         skip_optional = 0;
         /* If there is a next operand it must be separated by a comma.  */
         if (opindex_ptr[1] != '\0')
           {
             if (*str != ',')
              {
                while (opindex_ptr[1] != '\0')
                  {
                    operand = s390_operands + *(++opindex_ptr);
                    if (operand->flags & S390_OPERAND_OPTIONAL)
                     continue;
                    as_bad (_("syntax error; expected ,"));
                    break;
                  }
              }
             else
              str++;
           }
       }
      else
       {
         /* We can find an 'early' closing parentheses in e.g. D(L) instead
            of D(L,B).  In this case the base register has to be skipped.  */
         if (*str == ')')
           {
             operand = s390_operands + *(++opindex_ptr);

             if (!(operand->flags & S390_OPERAND_BASE))
              as_bad (_("syntax error; ')' not allowed here"));
             str++;
           }
         /* If there is a next operand it must be separated by a comma.  */
         if (opindex_ptr[1] != '\0')
           {
             if (*str != ',')
              {
                while (opindex_ptr[1] != '\0')
                  {
                    operand = s390_operands + *(++opindex_ptr);
                    if (operand->flags & S390_OPERAND_OPTIONAL)
                     continue;
                    as_bad (_("syntax error; expected ,"));
                    break;
                  }
              }
             else
              str++;
           }
       }
    }

  while (ISSPACE (*str))
    ++str;

  /* Check for tls instruction marker.  */
  reloc = s390_tls_suffix (&str, &ex);
  if (reloc != BFD_RELOC_UNUSED)
    {
      /* We need to generate a fixup of type 'reloc' for this
        instruction.  */
      if (fc >= MAX_INSN_FIXUPS)
       as_fatal (_("too many fixups"));
      fixups[fc].exp = ex;
      fixups[fc].opindex = -1;
      fixups[fc].reloc = reloc;
      ++fc;
    }

  if (*str != '\0')
    {
      char *linefeed;

      if ((linefeed = strchr (str, '\n')) != NULL)
       *linefeed = '\0';
      as_bad (_("junk at end of line: `%s'"), str);
      if (linefeed != NULL)
       *linefeed = '\n';
    }

  /* Write out the instruction.  */
  f = frag_more (opcode->oplen);
  memcpy (f, insn, opcode->oplen);
  dwarf2_emit_insn (opcode->oplen);

  /* Create any fixups.  At this point we do not use a
     bfd_reloc_code_real_type, but instead just use the
     BFD_RELOC_UNUSED plus the operand index.  This lets us easily
     handle fixups for any operand type, although that is admittedly
     not a very exciting feature.  We pick a BFD reloc type in
     md_apply_fix.  */
  for (i = 0; i < fc; i++)
    {

      if (fixups[i].opindex < 0)
       {
         /* Create tls instruction marker relocation.  */
         fix_new_exp (frag_now, f - frag_now->fr_literal, opcode->oplen,
                     &fixups[i].exp, 0, fixups[i].reloc);
         continue;
       }

      operand = s390_operands + fixups[i].opindex;

      if (fixups[i].reloc != BFD_RELOC_UNUSED)
       {
         reloc_howto_type *reloc_howto;
         fixS *fixP;
         int size;

         reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
         if (!reloc_howto)
           abort ();

         size = bfd_get_reloc_size (reloc_howto);

         if (size < 1 || size > 4)
           abort ();

         fixP = fix_new_exp (frag_now,
                           f - frag_now->fr_literal + (operand->shift/8),
                           size, &fixups[i].exp, reloc_howto->pc_relative,
                           fixups[i].reloc);
         /* Turn off overflow checking in fixup_segment. This is necessary
            because fixup_segment will signal an overflow for large 4 byte
            quantities for GOT12 relocations.  */
         if (   fixups[i].reloc == BFD_RELOC_390_GOT12
             || fixups[i].reloc == BFD_RELOC_390_GOT20
             || fixups[i].reloc == BFD_RELOC_390_GOT16)
           fixP->fx_no_overflow = 1;
       }
      else
       fix_new_exp (frag_now, f - frag_now->fr_literal, 4, &fixups[i].exp,
                   (operand->flags & S390_OPERAND_PCREL) != 0,
                   ((bfd_reloc_code_real_type)
                    (fixups[i].opindex + (int) BFD_RELOC_UNUSED)));
    }
  return str;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int md_parse_option ( int c  ,
char *  arg 
)

Definition at line 371 of file tc-s390.c.

{
  switch (c)
    {
      /* -k: Ignore for FreeBSD compatibility.  */
    case 'k':
      break;
    case 'm':
      if (arg != NULL && strcmp (arg, "regnames") == 0)
       reg_names_p = TRUE;

      else if (arg != NULL && strcmp (arg, "no-regnames") == 0)
       reg_names_p = FALSE;

      else if (arg != NULL && strcmp (arg, "warn-areg-zero") == 0)
       warn_areg_zero = TRUE;

      else if (arg != NULL && strcmp (arg, "31") == 0)
       s390_arch_size = 32;

      else if (arg != NULL && strcmp (arg, "64") == 0)
       s390_arch_size = 64;

      else if (arg != NULL && strcmp (arg, "esa") == 0)
       current_mode_mask = 1 << S390_OPCODE_ESA;

      else if (arg != NULL && strcmp (arg, "zarch") == 0)
       current_mode_mask = 1 << S390_OPCODE_ZARCH;

      else if (arg != NULL && strncmp (arg, "arch=", 5) == 0)
       {
         if (strcmp (arg + 5, "g5") == 0)
           current_cpu = S390_OPCODE_G5;
         else if (strcmp (arg + 5, "g6") == 0)
           current_cpu = S390_OPCODE_G6;
         else if (strcmp (arg + 5, "z900") == 0)
           current_cpu = S390_OPCODE_Z900;
         else if (strcmp (arg + 5, "z990") == 0)
           current_cpu = S390_OPCODE_Z990;
         else if (strcmp (arg + 5, "z9-109") == 0)
           current_cpu = S390_OPCODE_Z9_109;
         else if (strcmp (arg + 5, "z9-ec") == 0)
           current_cpu = S390_OPCODE_Z9_EC;
         else
           {
             as_bad (_("invalid switch -m%s"), arg);
             return 0;
           }
       }

      else
       {
         as_bad (_("invalid switch -m%s"), arg);
         return 0;
       }
      break;

    case 'A':
      /* Option -A is deprecated. Still available for compatibility.  */
      if (arg != NULL && strcmp (arg, "esa") == 0)
       current_cpu = S390_OPCODE_G5;
      else if (arg != NULL && strcmp (arg, "esame") == 0)
       current_cpu = S390_OPCODE_Z900;
      else
       as_bad ("invalid architecture -A%s", arg);
      break;

      /* -V: SVR4 argument to print version ID.  */
    case 'V':
      print_version_id ();
      break;

      /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
        should be emitted or not.  FIXME: Not implemented.  */
    case 'Q':
      break;

    default:
      return 0;
    }

  return 1;
}

Here is the call graph for this function:

long md_pcrel_from_section ( fixS *  fixp,
sec   
)

Definition at line 1877 of file tc-s390.c.

{
  return fixp->fx_frag->fr_address + fixp->fx_where;
}

Definition at line 1821 of file tc-s390.c.

{
  int align = bfd_get_section_alignment (stdoutput, seg);

  return ((addr + (1 << align) - 1) & (-1 << align));
}

Here is the call graph for this function:

void md_show_usage ( FILE *  stream)

Definition at line 458 of file tc-s390.c.

{
  fprintf (stream, _("\
        S390 options:\n\
        -mregnames        Allow symbolic names for registers\n\
        -mwarn-areg-zero  Warn about zero base/index registers\n\
        -mno-regnames     Do not allow symbolic names for registers\n\
        -m31              Set file format to 31 bit format\n\
        -m64              Set file format to 64 bit format\n"));
  fprintf (stream, _("\
        -V                print assembler version number\n\
        -Qy, -Qn          ignored\n"));
}

Here is the call graph for this function:

symbolS* md_undefined_symbol ( char *  name)

Definition at line 1853 of file tc-s390.c.

{
  if (*name == '_' && *(name + 1) == 'G'
      && strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
    {
      if (!GOT_symbol)
       {
         if (symbol_find (name))
           as_bad (_("GOT already in symbol table"));
         GOT_symbol = symbol_new (name, undefined_section,
                               (valueT) 0, &zero_address_frag);
       }
      return GOT_symbol;
    }
  return 0;
}

Here is the call graph for this function:

static void s390_byte PARAMS ( (int ) [static]
static int reg_name_search PARAMS ( (const struct pd_reg *, int, const char *)  ) [static]
static bfd_boolean register_name PARAMS ( (expressionS *)  ) [static]
static void init_default_arch PARAMS ( (void)  ) [static]
static void s390_insert_operand PARAMS ( (unsigned char *, const struct s390_operand *, offsetT, char *, unsigned int ) [static]
static char* md_gather_operands PARAMS ( (char *, unsigned char *, const struct s390_opcode *)  ) [static]
static bfd_reloc_code_real_type s390_tls_suffix PARAMS ( (char **, expressionS *)  ) [static]
static int s390_exp_compare PARAMS ( (expressionS *exp1, expressionS *exp2)  ) [static]
static elf_suffix_type s390_lit_suffix PARAMS ( (char **, expressionS *, elf_suffix_type ) [static]
static int reg_name_search ( struct pd_reg regs,
int  regcount,
const char *  name 
) const [static]

Definition at line 222 of file tc-s390.c.

{
  int middle, low, high;
  int cmp;

  low = 0;
  high = regcount - 1;

  do
    {
      middle = (low + high) / 2;
      cmp = strcasecmp (name, regs[middle].name);
      if (cmp < 0)
       high = middle - 1;
      else if (cmp > 0)
       low = middle + 1;
      else
       return regs[middle].value;
    }
  while (low <= high);

  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bfd_boolean register_name ( expressionS expressionP) [static]

Definition at line 263 of file tc-s390.c.

{
  int reg_number;
  char *name;
  char *start;
  char c;

  /* Find the spelling of the operand.  */
  start = name = input_line_pointer;
  if (name[0] == '%' && ISALPHA (name[1]))
    name = ++input_line_pointer;
  else
    return FALSE;

  c = get_symbol_end ();
  reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name);

  /* Put back the delimiting char.  */
  *input_line_pointer = c;

  /* Look to see if it's in the register table.  */
  if (reg_number >= 0)
    {
      expressionP->X_op = O_register;
      expressionP->X_add_number = reg_number;

      /* Make the rest nice.  */
      expressionP->X_add_symbol = NULL;
      expressionP->X_op_symbol = NULL;
      return TRUE;
    }

  /* Reset the line as if we had not done anything.  */
  input_line_pointer = start;
  return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s390_bss ( ignore  )

Definition at line 1594 of file tc-s390.c.

{
  /* We don't support putting frags in the BSS segment, we fake it
     by marking in_bss, then looking at s_skip for clues.  */

  subseg_set (bss_section, 0);
  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

static void s390_byte ( ignore  ) [static]

Definition at line 1677 of file tc-s390.c.

{
  if (*input_line_pointer != '\"')
    {
      cons (1);
      return;
    }

  /* Gather characters.  A real double quote is doubled.  Unusual
     characters are not permitted.  */
  ++input_line_pointer;
  while (1)
    {
      char c;

      c = *input_line_pointer++;

      if (c == '\"')
       {
         if (*input_line_pointer != '\"')
           break;
         ++input_line_pointer;
       }

      FRAG_APPEND_1_CHAR (c);
    }

  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

Definition at line 2320 of file tc-s390.c.

{
  cfi_add_CFA_def_cfa (15, s390_arch_size == 64 ? 160 : 96);
}

Here is the call graph for this function:

static void s390_elf_cons ( int  nbytes) [static]

Definition at line 1036 of file tc-s390.c.

{
  expressionS exp;
  elf_suffix_type suffix;

  if (is_it_end_of_statement ())
    {
      demand_empty_rest_of_line ();
      return;
    }

  do
    {
      expression (&exp);

      if (exp.X_op == O_symbol
         && *input_line_pointer == '@'
         && (suffix = s390_elf_suffix (&input_line_pointer, &exp)) != ELF_SUFFIX_NONE)
       {
         bfd_reloc_code_real_type reloc;
         reloc_howto_type *reloc_howto;
         int size;
         char *where;

         if (nbytes == 2)
           {
             static bfd_reloc_code_real_type tab2[] =
              {
                BFD_RELOC_UNUSED,         /* ELF_SUFFIX_NONE  */
                BFD_RELOC_390_GOT16,             /* ELF_SUFFIX_GOT  */
                BFD_RELOC_UNUSED,         /* ELF_SUFFIX_PLT  */
                BFD_RELOC_UNUSED,         /* ELF_SUFFIX_GOTENT  */
                BFD_RELOC_16_GOTOFF,             /* ELF_SUFFIX_GOTOFF  */
                BFD_RELOC_UNUSED,         /* ELF_SUFFIX_GOTPLT  */
                BFD_RELOC_390_PLTOFF16,   /* ELF_SUFFIX_PLTOFF  */
                BFD_RELOC_UNUSED,         /* ELF_SUFFIX_TLS_GD  */
                BFD_RELOC_UNUSED,         /* ELF_SUFFIX_TLS_GOTIE  */
                BFD_RELOC_UNUSED,         /* ELF_SUFFIX_TLS_IE  */
                BFD_RELOC_UNUSED,         /* ELF_SUFFIX_TLS_LDM  */
                BFD_RELOC_UNUSED,         /* ELF_SUFFIX_TLS_LDO  */
                BFD_RELOC_UNUSED          /* ELF_SUFFIX_TLS_LE  */
              };
             reloc = tab2[suffix];
           }
         else if (nbytes == 4)
           {
             static bfd_reloc_code_real_type tab4[] =
              {
                BFD_RELOC_UNUSED,         /* ELF_SUFFIX_NONE  */
                BFD_RELOC_32_GOT_PCREL,   /* ELF_SUFFIX_GOT  */
                BFD_RELOC_390_PLT32,             /* ELF_SUFFIX_PLT  */
                BFD_RELOC_UNUSED,         /* ELF_SUFFIX_GOTENT  */
                BFD_RELOC_32_GOTOFF,             /* ELF_SUFFIX_GOTOFF  */
                BFD_RELOC_390_GOTPLT32,   /* ELF_SUFFIX_GOTPLT  */
                BFD_RELOC_390_PLTOFF32,   /* ELF_SUFFIX_PLTOFF  */
                BFD_RELOC_390_TLS_GD32,   /* ELF_SUFFIX_TLS_GD  */
                BFD_RELOC_390_TLS_GOTIE32,       /* ELF_SUFFIX_TLS_GOTIE  */
                BFD_RELOC_390_TLS_IE32,   /* ELF_SUFFIX_TLS_IE  */
                BFD_RELOC_390_TLS_LDM32,  /* ELF_SUFFIX_TLS_LDM  */
                BFD_RELOC_390_TLS_LDO32,  /* ELF_SUFFIX_TLS_LDO  */
                BFD_RELOC_390_TLS_LE32    /* ELF_SUFFIX_TLS_LE  */
              };
             reloc = tab4[suffix];
           }
         else if (nbytes == 8)
           {
             static bfd_reloc_code_real_type tab8[] =
              {
                BFD_RELOC_UNUSED,         /* ELF_SUFFIX_NONE  */
                BFD_RELOC_390_GOT64,             /* ELF_SUFFIX_GOT  */
                BFD_RELOC_390_PLT64,             /* ELF_SUFFIX_PLT  */
                BFD_RELOC_UNUSED,         /* ELF_SUFFIX_GOTENT  */
                BFD_RELOC_390_GOTOFF64,   /* ELF_SUFFIX_GOTOFF  */
                BFD_RELOC_390_GOTPLT64,   /* ELF_SUFFIX_GOTPLT  */
                BFD_RELOC_390_PLTOFF64,   /* ELF_SUFFIX_PLTOFF  */
                BFD_RELOC_390_TLS_GD64,   /* ELF_SUFFIX_TLS_GD  */
                BFD_RELOC_390_TLS_GOTIE64,       /* ELF_SUFFIX_TLS_GOTIE  */
                BFD_RELOC_390_TLS_IE64,   /* ELF_SUFFIX_TLS_IE  */
                BFD_RELOC_390_TLS_LDM64,  /* ELF_SUFFIX_TLS_LDM  */
                BFD_RELOC_390_TLS_LDO64,  /* ELF_SUFFIX_TLS_LDO  */
                BFD_RELOC_390_TLS_LE64    /* ELF_SUFFIX_TLS_LE  */
              };
             reloc = tab8[suffix];
           }
         else
           reloc = BFD_RELOC_UNUSED;

         if (reloc != BFD_RELOC_UNUSED
             && (reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc)))
           {
             size = bfd_get_reloc_size (reloc_howto);
             if (size > nbytes)
              as_bad (_("%s relocations do not fit in %d bytes"),
                     reloc_howto->name, nbytes);
             where = frag_more (nbytes);
             md_number_to_chars (where, 0, size);
             /* To make fixup_segment do the pc relative conversion the
               pcrel parameter on the fix_new_exp call needs to be FALSE.  */
             fix_new_exp (frag_now, where - frag_now->fr_literal,
                        size, &exp, FALSE, reloc);
           }
         else
           as_bad (_("relocation not applicable"));
       }
      else
       emit_expr (&exp, (unsigned int) nbytes);
    }
  while (*input_line_pointer++ == ',');

  input_line_pointer--;            /* Put terminator back into stream.  */
  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

static elf_suffix_type s390_elf_suffix ( char **  str_p,
expressionS exp_p 
) [static]

Definition at line 727 of file tc-s390.c.

{
  static struct map_bfd mapping[] =
  {
    { "got", 3, ELF_SUFFIX_GOT  },
    { "got12", 5, ELF_SUFFIX_GOT  },
    { "plt", 3, ELF_SUFFIX_PLT  },
    { "gotent", 6, ELF_SUFFIX_GOTENT },
    { "gotoff", 6, ELF_SUFFIX_GOTOFF },
    { "gotplt", 6, ELF_SUFFIX_GOTPLT },
    { "pltoff", 6, ELF_SUFFIX_PLTOFF },
    { "tlsgd", 5, ELF_SUFFIX_TLS_GD },
    { "gotntpoff", 9, ELF_SUFFIX_TLS_GOTIE },
    { "indntpoff", 9, ELF_SUFFIX_TLS_IE },
    { "tlsldm", 6, ELF_SUFFIX_TLS_LDM },
    { "dtpoff", 6, ELF_SUFFIX_TLS_LDO },
    { "ntpoff", 6, ELF_SUFFIX_TLS_LE },
    { NULL,  0, ELF_SUFFIX_NONE }
  };

  struct map_bfd *ptr;
  char *str = *str_p;
  char *ident;
  int len;

  if (*str++ != '@')
    return ELF_SUFFIX_NONE;

  ident = str;
  while (ISALNUM (*str))
    str++;
  len = str - ident;

  for (ptr = &mapping[0]; ptr->length > 0; ptr++)
    if (len == ptr->length
       && strncasecmp (ident, ptr->string, ptr->length) == 0)
      {
       if (exp_p->X_add_number != 0)
         as_warn (_("identifier+constant@%s means identifier@%s+constant"),
                 ptr->string, ptr->string);
       /* Now check for identifier@suffix+constant.  */
       if (*str == '-' || *str == '+')
         {
           char *orig_line = input_line_pointer;
           expressionS new_exp;

           input_line_pointer = str;
           expression (&new_exp);

           switch (new_exp.X_op)
             {
             case O_constant: /* X_add_number (a constant expression).  */
              exp_p->X_add_number += new_exp.X_add_number;
              str = input_line_pointer;
              break;
             case O_symbol:   /* X_add_symbol + X_add_number.  */
              /* this case is used for e.g. xyz@PLT+.Label.  */
              exp_p->X_add_number += new_exp.X_add_number;
              exp_p->X_op_symbol = new_exp.X_add_symbol;
              exp_p->X_op = O_add;
              str = input_line_pointer;
              break;
             case O_uminus:   /* (- X_add_symbol) + X_add_number.  */
              /* this case is used for e.g. xyz@PLT-.Label.  */
              exp_p->X_add_number += new_exp.X_add_number;
              exp_p->X_op_symbol = new_exp.X_add_symbol;
              exp_p->X_op = O_subtract;
              str = input_line_pointer;
              break;
             default:
              break;
             }

           /* If s390_elf_suffix has not been called with
              &input_line_pointer as first parameter, we have
              clobbered the input_line_pointer. We have to
              undo that.  */
           if (&input_line_pointer != str_p)
             input_line_pointer = orig_line;
         }
       *str_p = str;
       return ptr->suffix;
      }

  return BFD_RELOC_UNUSED;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int s390_exp_compare ( expressionS exp1,
expressionS exp2 
) [static]

Definition at line 836 of file tc-s390.c.

{
  if (exp1->X_op != exp2->X_op)
    return 0;

  switch (exp1->X_op)
    {
    case O_constant:   /* X_add_number must be equal.  */
    case O_register:
      return exp1->X_add_number == exp2->X_add_number;

    case O_big:
      as_bad (_("Can't handle O_big in s390_exp_compare"));

    case O_symbol:     /* X_add_symbol & X_add_number must be equal.  */
    case O_symbol_rva:
    case O_uminus:
    case O_bit_not:
    case O_logical_not:
      return (exp1->X_add_symbol == exp2->X_add_symbol)
       &&   (exp1->X_add_number == exp2->X_add_number);

    case O_multiply:   /* X_add_symbol,X_op_symbol&X_add_number must be equal.  */
    case O_divide:
    case O_modulus:
    case O_left_shift:
    case O_right_shift:
    case O_bit_inclusive_or:
    case O_bit_or_not:
    case O_bit_exclusive_or:
    case O_bit_and:
    case O_add:
    case O_subtract:
    case O_eq:
    case O_ne:
    case O_lt:
    case O_le:
    case O_ge:
    case O_gt:
    case O_logical_and:
    case O_logical_or:
      return (exp1->X_add_symbol == exp2->X_add_symbol)
       &&   (exp1->X_op_symbol  == exp2->X_op_symbol)
       &&   (exp1->X_add_number == exp2->X_add_number);
    default:
      return 0;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void s390_insert_operand ( unsigned char *  insn,
const struct s390_operand operand,
offsetT  val,
char *  file,
unsigned int  line 
) [static]

Definition at line 550 of file tc-s390.c.

{
  addressT uval;
  int offset;

  if (operand->flags & (S390_OPERAND_SIGNED|S390_OPERAND_PCREL))
    {
      offsetT min, max;

      max = ((offsetT) 1 << (operand->bits - 1)) - 1;
      min = - ((offsetT) 1 << (operand->bits - 1));
      /* Halve PCREL operands.  */
      if (operand->flags & S390_OPERAND_PCREL)
       val >>= 1;
      /* Check for underflow / overflow.  */
      if (val < min || val > max)
       {
         const char *err =
           "operand out of range (%s not between %ld and %ld)";
         char buf[100];

         if (operand->flags & S390_OPERAND_PCREL)
           {
             val <<= 1;
             min <<= 1;
             max <<= 1;
           }
         sprint_value (buf, val);
         if (file == (char *) NULL)
           as_bad (err, buf, (int) min, (int) max);
         else
           as_bad_where (file, line, err, buf, (int) min, (int) max);
         return;
       }
      /* val is ok, now restrict it to operand->bits bits.  */
      uval = (addressT) val & ((((addressT) 1 << (operand->bits-1)) << 1) - 1);
      /* val is restrict, now check for special case.  */
      if (operand->bits == 20 && operand->shift == 20)
        uval = (uval >> 12) | ((uval & 0xfff) << 8);
    }
  else
    {
      addressT min, max;

      max = (((addressT) 1 << (operand->bits - 1)) << 1) - 1;
      min = (offsetT) 0;
      uval = (addressT) val;
      /* Length x in an instructions has real length x+1.  */
      if (operand->flags & S390_OPERAND_LENGTH)
       uval--;
      /* Check for underflow / overflow.  */
      if (uval < min || uval > max)
       {
         if (operand->flags & S390_OPERAND_LENGTH)
           {
             uval++;
             min++;
             max++;
           }

         as_bad_value_out_of_range (_("operand"), uval, (offsetT) min, (offsetT) max, file, line);

         return;
       }
    }

  /* Insert fragments of the operand byte for byte.  */
  offset = operand->shift + operand->bits;
  uval <<= (-offset) & 7;
  insn += (offset - 1) / 8;
  while (uval != 0)
    {
      *insn-- |= uval;
      uval >>= 8;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void s390_insn ( ignore  )

Definition at line 1607 of file tc-s390.c.

{
  expressionS exp;
  const struct s390_opcode *opformat;
  unsigned char insn[6];
  char *s;

  /* Get the opcode format.  */
  s = input_line_pointer;
  while (*s != '\0' && *s != ',' && ! ISSPACE (*s))
    s++;
  if (*s != ',')
    as_bad (_("Invalid .insn format\n"));
  *s++ = '\0';

  /* Look up the opcode in the hash table.  */
  opformat = (struct s390_opcode *)
    hash_find (s390_opformat_hash, input_line_pointer);
  if (opformat == (const struct s390_opcode *) NULL)
    {
      as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer);
      return;
    }
  input_line_pointer = s;
  expression (&exp);
  if (exp.X_op == O_constant)
    {
      if (   (   opformat->oplen == 6
             && (addressT) exp.X_add_number < (1ULL << 48))
         || (   opformat->oplen == 4
             && (addressT) exp.X_add_number < (1ULL << 32))
         || (   opformat->oplen == 2
             && (addressT) exp.X_add_number < (1ULL << 16)))
       md_number_to_chars ((char *) insn, exp.X_add_number, opformat->oplen);
      else
       as_bad (_("Invalid .insn format\n"));
    }
  else if (exp.X_op == O_big)
    {
      if (exp.X_add_number > 0
         && opformat->oplen == 6
         && generic_bignum[3] == 0)
       {
         md_number_to_chars ((char *) insn, generic_bignum[2], 2);
         md_number_to_chars ((char *) &insn[2], generic_bignum[1], 2);
         md_number_to_chars ((char *) &insn[4], generic_bignum[0], 2);
       }
      else
       as_bad (_("Invalid .insn format\n"));
    }
  else
    as_bad (_("second operand of .insn not a constant\n"));

  if (strcmp (opformat->name, "e") != 0 && *input_line_pointer++ != ',')
    as_bad (_("missing comma after insn constant\n"));

  if ((s = strchr (input_line_pointer, '\n')) != NULL)
    *s = '\0';
  input_line_pointer = md_gather_operands (input_line_pointer, insn,
                                      opformat);
  if (s != NULL)
    *s = '\n';
  demand_empty_rest_of_line ();
}

Here is the call graph for this function:

static elf_suffix_type s390_lit_suffix ( char **  str_p,
expressionS exp_p,
elf_suffix_type  suffix 
) [static]

Definition at line 890 of file tc-s390.c.

{
  bfd_reloc_code_real_type reloc;
  char tmp_name[64];
  char *str = *str_p;
  char *ident;
  struct s390_lpe *lpe;
  int nbytes, len;

  if (*str++ != ':')
    return suffix;       /* No modification.  */

  /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8".  */
  ident = str;
  while (ISALNUM (*str))
    str++;
  len = str - ident;
  if (len != 4 || strncasecmp (ident, "lit", 3) != 0
      || (ident[3]!='1' && ident[3]!='2' && ident[3]!='4' && ident[3]!='8'))
    return suffix;      /* no modification */
  nbytes = ident[3] - '0';

  reloc = BFD_RELOC_UNUSED;
  if (suffix == ELF_SUFFIX_GOT)
    {
      if (nbytes == 2)
       reloc = BFD_RELOC_390_GOT16;
      else if (nbytes == 4)
       reloc = BFD_RELOC_32_GOT_PCREL;
      else if (nbytes == 8)
       reloc = BFD_RELOC_390_GOT64;
    }
  else if (suffix == ELF_SUFFIX_PLT)
    {
      if (nbytes == 4)
       reloc = BFD_RELOC_390_PLT32;
      else if (nbytes == 8)
       reloc = BFD_RELOC_390_PLT64;
    }

  if (suffix != ELF_SUFFIX_NONE && reloc == BFD_RELOC_UNUSED)
    as_bad (_("Invalid suffix for literal pool entry"));

  /* Search the pool if the new entry is a duplicate.  */
  if (exp_p->X_op == O_big)
    {
      /* Special processing for big numbers.  */
      for (lpe = lpe_list; lpe != NULL; lpe = lpe->next)
       {
         if (lpe->ex.X_op == O_big)
           {
             if (exp_p->X_add_number <= 0 && lpe->ex.X_add_number <= 0)
              {
                if (memcmp (&generic_floating_point_number, &lpe->floatnum,
                           sizeof (FLONUM_TYPE)) == 0)
                  break;
              }
             else if (exp_p->X_add_number == lpe->ex.X_add_number)
              {
                if (memcmp (generic_bignum, lpe->bignum,
                           sizeof (LITTLENUM_TYPE)*exp_p->X_add_number) == 0)
                  break;
              }
           }
       }
    }
  else
    {
      /* Processing for 'normal' data types.  */
      for (lpe = lpe_list; lpe != NULL; lpe = lpe->next)
       if (lpe->nbytes == nbytes && lpe->reloc == reloc
           && s390_exp_compare (exp_p, &lpe->ex) != 0)
         break;
    }

  if (lpe == NULL)
    {
      /* A new literal.  */
      if (lpe_free_list != NULL)
       {
         lpe = lpe_free_list;
         lpe_free_list = lpe_free_list->next;
       }
      else
       {
         lpe = (struct s390_lpe *) xmalloc (sizeof (struct s390_lpe));
       }

      lpe->ex = *exp_p;

      if (exp_p->X_op == O_big)
       {
         if (exp_p->X_add_number <= 0)
           lpe->floatnum = generic_floating_point_number;
         else if (exp_p->X_add_number <= 4)
           memcpy (lpe->bignum, generic_bignum,
                  exp_p->X_add_number * sizeof (LITTLENUM_TYPE));
         else
           as_bad (_("Big number is too big"));
       }

      lpe->nbytes = nbytes;
      lpe->reloc = reloc;
      /* Literal pool name defined ?  */
      if (lp_sym == NULL)
       {
         sprintf (tmp_name, ".L\001%i", lp_count);
         lp_sym = symbol_make (tmp_name);
       }

      /* Make name for literal pool entry.  */
      sprintf (tmp_name, ".L\001%i\002%i", lp_count, lpe_count);
      lpe_count++;
      lpe->sym = symbol_make (tmp_name);

      /* Add to literal pool list.  */
      lpe->next = NULL;
      if (lpe_list_tail != NULL)
       {
         lpe_list_tail->next = lpe;
         lpe_list_tail = lpe;
       }
      else
       lpe_list = lpe_list_tail = lpe;
    }

  /* Now change exp_p to the offset into the literal pool.
     Thats the expression: .L^Ax^By-.L^Ax   */
  exp_p->X_add_symbol = lpe->sym;
  exp_p->X_op_symbol = lp_sym;
  exp_p->X_op = O_subtract;
  exp_p->X_add_number = 0;

  *str_p = str;

  /* We change the suffix type to ELF_SUFFIX_NONE, because
     the difference of two local labels is just a number.  */
  return ELF_SUFFIX_NONE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void s390_literals ( ignore  ) [static]

Definition at line 1713 of file tc-s390.c.

{
  struct s390_lpe *lpe;

  if (lp_sym == NULL || lpe_count == 0)
    return;     /* Nothing to be done.  */

  /* Emit symbol for start of literal pool.  */
  S_SET_SEGMENT (lp_sym, now_seg);
  S_SET_VALUE (lp_sym, (valueT) frag_now_fix ());
  lp_sym->sy_frag = frag_now;

  while (lpe_list)
    {
      lpe = lpe_list;
      lpe_list = lpe_list->next;
      S_SET_SEGMENT (lpe->sym, now_seg);
      S_SET_VALUE (lpe->sym, (valueT) frag_now_fix ());
      lpe->sym->sy_frag = frag_now;

      /* Emit literal pool entry.  */
      if (lpe->reloc != BFD_RELOC_UNUSED)
       {
         reloc_howto_type *reloc_howto =
           bfd_reloc_type_lookup (stdoutput, lpe->reloc);
         int size = bfd_get_reloc_size (reloc_howto);
         char *where;

         if (size > lpe->nbytes)
           as_bad (_("%s relocations do not fit in %d bytes"),
                  reloc_howto->name, lpe->nbytes);
         where = frag_more (lpe->nbytes);
         md_number_to_chars (where, 0, size);
         fix_new_exp (frag_now, where - frag_now->fr_literal,
                     size, &lpe->ex, reloc_howto->pc_relative, lpe->reloc);
       }
      else
       {
         if (lpe->ex.X_op == O_big)
           {
             if (lpe->ex.X_add_number <= 0)
              generic_floating_point_number = lpe->floatnum;
             else
              memcpy (generic_bignum, lpe->bignum,
                     lpe->ex.X_add_number * sizeof (LITTLENUM_TYPE));
           }
         emit_expr (&lpe->ex, lpe->nbytes);
       }

      lpe->next = lpe_free_list;
      lpe_free_list = lpe;
    }
  lpe_list_tail = NULL;
  lp_sym = NULL;
  lp_count++;
  lpe_count = 0;
}

Here is the call graph for this function:

void s390_md_end ( )

Definition at line 361 of file tc-s390.c.

{
  /* We don't get a chance to initialize anything before we're called,
     so handle that now.  */
  init_default_arch ();

  return s390_arch_size == 64 ? "elf64-s390" : "elf32-s390";
}

Here is the call graph for this function:

static bfd_reloc_code_real_type s390_tls_suffix ( char **  str_p,
expressionS exp_p 
) [static]

Definition at line 644 of file tc-s390.c.

{
  static struct map_tls mapping[] =
  {
    { "tls_load", 8, BFD_RELOC_390_TLS_LOAD },
    { "tls_gdcall", 10, BFD_RELOC_390_TLS_GDCALL  },
    { "tls_ldcall", 10, BFD_RELOC_390_TLS_LDCALL  },
    { NULL,  0, BFD_RELOC_UNUSED }
  };
  struct map_tls *ptr;
  char *orig_line;
  char *str;
  char *ident;
  int len;

  str = *str_p;
  if (*str++ != ':')
    return BFD_RELOC_UNUSED;

  ident = str;
  while (ISIDNUM (*str))
    str++;
  len = str - ident;
  if (*str++ != ':')
    return BFD_RELOC_UNUSED;

  orig_line = input_line_pointer;
  input_line_pointer = str;
  expression (exp_p);
  str = input_line_pointer;
  if (&input_line_pointer != str_p)
    input_line_pointer = orig_line;

  if (exp_p->X_op != O_symbol)
    return BFD_RELOC_UNUSED;

  for (ptr = &mapping[0]; ptr->length > 0; ptr++)
    if (len == ptr->length
       && strncasecmp (ident, ptr->string, ptr->length) == 0)
      {
       /* Found a matching tls suffix.  */
       *str_p = str;
       return ptr->reloc;
      }
  return BFD_RELOC_UNUSED;
}

Here is the call graph for this function:

Here is the caller graph for this function:

arelent* tc_gen_reloc ( seg  ,
fixS *  fixp 
)

Definition at line 2283 of file tc-s390.c.

{
  bfd_reloc_code_real_type code;
  arelent *reloc;

  code = fixp->fx_r_type;
  if (GOT_symbol && fixp->fx_addsy == GOT_symbol)
    {
      if (   (s390_arch_size == 32 && code == BFD_RELOC_32_PCREL)
         || (s390_arch_size == 64 && code == BFD_RELOC_64_PCREL))
       code = BFD_RELOC_390_GOTPC;
      if (code == BFD_RELOC_390_PC32DBL)
       code = BFD_RELOC_390_GOTPCDBL;
    }

  reloc = (arelent *) xmalloc (sizeof (arelent));
  reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
  *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
  reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
  reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
  if (reloc->howto == NULL)
    {
      as_bad_where (fixp->fx_file, fixp->fx_line,
                  _("cannot represent relocation type %s"),
                  bfd_get_reloc_code_name (code));
      /* Set howto to a garbage value so that we can keep going.  */
      reloc->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
      assert (reloc->howto != NULL);
    }
  reloc->addend = fixp->fx_offset;

  return reloc;
}

Here is the call graph for this function:

int tc_s390_fix_adjustable ( fixS *  fixP)

Definition at line 1889 of file tc-s390.c.

{
  /* Don't adjust references to merge sections.  */
  if ((S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_MERGE) != 0)
    return 0;
  /* adjust_reloc_syms doesn't know about the GOT.  */
  if (   fixP->fx_r_type == BFD_RELOC_16_GOTOFF
      || fixP->fx_r_type == BFD_RELOC_32_GOTOFF
      || fixP->fx_r_type == BFD_RELOC_390_GOTOFF64
      || fixP->fx_r_type == BFD_RELOC_390_PLTOFF16
      || fixP->fx_r_type == BFD_RELOC_390_PLTOFF32
      || fixP->fx_r_type == BFD_RELOC_390_PLTOFF64
      || fixP->fx_r_type == BFD_RELOC_390_PLT16DBL
      || fixP->fx_r_type == BFD_RELOC_390_PLT32
      || fixP->fx_r_type == BFD_RELOC_390_PLT32DBL
      || fixP->fx_r_type == BFD_RELOC_390_PLT64
      || fixP->fx_r_type == BFD_RELOC_390_GOT12
      || fixP->fx_r_type == BFD_RELOC_390_GOT20
      || fixP->fx_r_type == BFD_RELOC_390_GOT16
      || fixP->fx_r_type == BFD_RELOC_32_GOT_PCREL
      || fixP->fx_r_type == BFD_RELOC_390_GOT64
      || fixP->fx_r_type == BFD_RELOC_390_GOTENT
      || fixP->fx_r_type == BFD_RELOC_390_GOTPLT12
      || fixP->fx_r_type == BFD_RELOC_390_GOTPLT16
      || fixP->fx_r_type == BFD_RELOC_390_GOTPLT20
      || fixP->fx_r_type == BFD_RELOC_390_GOTPLT32
      || fixP->fx_r_type == BFD_RELOC_390_GOTPLT64
      || fixP->fx_r_type == BFD_RELOC_390_GOTPLTENT
      || fixP->fx_r_type == BFD_RELOC_390_TLS_LOAD
      || fixP->fx_r_type == BFD_RELOC_390_TLS_GDCALL
      || fixP->fx_r_type == BFD_RELOC_390_TLS_LDCALL
      || fixP->fx_r_type == BFD_RELOC_390_TLS_GD32
      || fixP->fx_r_type == BFD_RELOC_390_TLS_GD64
      || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE12
      || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE20
      || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE32
      || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE64
      || fixP->fx_r_type == BFD_RELOC_390_TLS_LDM32
      || fixP->fx_r_type == BFD_RELOC_390_TLS_LDM64
      || fixP->fx_r_type == BFD_RELOC_390_TLS_IE32
      || fixP->fx_r_type == BFD_RELOC_390_TLS_IE64
      || fixP->fx_r_type == BFD_RELOC_390_TLS_IEENT
      || fixP->fx_r_type == BFD_RELOC_390_TLS_LE32
      || fixP->fx_r_type == BFD_RELOC_390_TLS_LE64
      || fixP->fx_r_type == BFD_RELOC_390_TLS_LDO32
      || fixP->fx_r_type == BFD_RELOC_390_TLS_LDO64
      || fixP->fx_r_type == BFD_RELOC_390_TLS_DTPMOD
      || fixP->fx_r_type == BFD_RELOC_390_TLS_DTPOFF
      || fixP->fx_r_type == BFD_RELOC_390_TLS_TPOFF
      || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
      || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
    return 0;
  return 1;
}

Here is the call graph for this function:

Definition at line 1948 of file tc-s390.c.

{
  /* Ensure we emit a relocation for every reference to the global
     offset table or to the procedure link table.  */
  switch (fixp->fx_r_type)
    {
    case BFD_RELOC_390_GOT12:
    case BFD_RELOC_390_GOT20:
    case BFD_RELOC_32_GOT_PCREL:
    case BFD_RELOC_32_GOTOFF:
    case BFD_RELOC_390_GOTOFF64:
    case BFD_RELOC_390_PLTOFF16:
    case BFD_RELOC_390_PLTOFF32:
    case BFD_RELOC_390_PLTOFF64:
    case BFD_RELOC_390_GOTPC:
    case BFD_RELOC_390_GOT16:
    case BFD_RELOC_390_GOTPCDBL:
    case BFD_RELOC_390_GOT64:
    case BFD_RELOC_390_GOTENT:
    case BFD_RELOC_390_PLT32:
    case BFD_RELOC_390_PLT16DBL:
    case BFD_RELOC_390_PLT32DBL:
    case BFD_RELOC_390_PLT64:
    case BFD_RELOC_390_GOTPLT12:
    case BFD_RELOC_390_GOTPLT16:
    case BFD_RELOC_390_GOTPLT20:
    case BFD_RELOC_390_GOTPLT32:
    case BFD_RELOC_390_GOTPLT64:
    case BFD_RELOC_390_GOTPLTENT:
      return 1;
    default:
      break;;
    }

  return generic_force_reloc (fixp);
}

Here is the call graph for this function:

int tc_s390_regname_to_dw2regnum ( char *  regname)

Definition at line 2326 of file tc-s390.c.

{
  int regnum = -1;

  if (regname[0] != 'c' && regname[0] != 'a')
    {
      regnum = reg_name_search (pre_defined_registers, REG_NAME_CNT, regname);
      if (regname[0] == 'f' && regnum != -1)
        regnum += 16;
    }
  else if (strcmp (regname, "ap") == 0)
    regnum = 32;
  else if (strcmp (regname, "cc") == 0)
    regnum = 33;
  return regnum;
}

Here is the call graph for this function:


Variable Documentation

const char comment_chars[] = "#"

Definition at line 57 of file tc-s390.c.

unsigned int current_cpu = -1U [static]

Definition at line 42 of file tc-s390.c.

Definition at line 41 of file tc-s390.c.

char* default_arch = DEFAULT_ARCH [static]

Definition at line 37 of file tc-s390.c.

const char EXP_CHARS[] = "eE"

Definition at line 68 of file tc-s390.c.

const char FLT_CHARS[] = "dD"

Definition at line 72 of file tc-s390.c.

symbolS* GOT_symbol

Definition at line 312 of file tc-s390.c.

const char line_comment_chars[] = "#"

Definition at line 60 of file tc-s390.c.

Definition at line 64 of file tc-s390.c.

int lp_count = 0 [static]

Definition at line 832 of file tc-s390.c.

symbolS* lp_sym = NULL [static]

Definition at line 831 of file tc-s390.c.

int lpe_count = 0 [static]

Definition at line 833 of file tc-s390.c.

Definition at line 828 of file tc-s390.c.

Definition at line 829 of file tc-s390.c.

Definition at line 830 of file tc-s390.c.

Definition at line 316 of file tc-s390.c.

size_t md_longopts_size = sizeof (md_longopts)

Definition at line 323 of file tc-s390.c.

const pseudo_typeS md_pseudo_table[]
Initial value:
{
  { "align", s_align_bytes, 0 },
  
  { "bss",      s390_bss,       0 },
  { "insn",     s390_insn,      0 },
  
  { "byte",   s390_byte,    0 },
  { "short",    s390_elf_cons,  2 },
  { "long",   s390_elf_cons,       4 },
  { "quad",     s390_elf_cons,  8 },
  { "ltorg",    s390_literals,  0 },
  { "string",   stringer,       2 },
  { NULL,     NULL,         0 }
}

Definition at line 86 of file tc-s390.c.

Definition at line 315 of file tc-s390.c.

const char* md_shortopts = "A:m:kVQ:"

Definition at line 319 of file tc-s390.c.

struct pd_reg[] [static]

Definition at line 130 of file tc-s390.c.

Definition at line 49 of file tc-s390.c.

int s390_arch_size = 0 [static]

Definition at line 39 of file tc-s390.c.

Definition at line 75 of file tc-s390.c.

flagword s390_flags = 0 [static]

Definition at line 310 of file tc-s390.c.

Definition at line 307 of file tc-s390.c.

Definition at line 304 of file tc-s390.c.

Definition at line 52 of file tc-s390.c.