Back to index

cell-binutils  2.17cvs20070401
Classes | Enumerations | Functions | Variables
s390-mkopc.c File Reference
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

Go to the source code of this file.

Classes

struct  op_struct

Enumerations

enum  s390_opcode_mode_val { S390_OPCODE_ESA = 0, S390_OPCODE_ZARCH, S390_OPCODE_ESA = 0, S390_OPCODE_ZARCH }
enum  s390_opcode_cpu_val {
  S390_OPCODE_G5 = 0, S390_OPCODE_G6, S390_OPCODE_Z900, S390_OPCODE_Z990,
  S390_OPCODE_Z9_109, S390_OPCODE_Z9_EC, S390_OPCODE_G5 = 0, S390_OPCODE_G6,
  S390_OPCODE_Z900, S390_OPCODE_Z990, S390_OPCODE_Z9_109, S390_OPCODE_Z9_EC
}

Functions

static void createTable (void)
static void insertOpcode (char *opcode, char *mnemonic, char *format, int min_cpu, int mode_bits)
static void dumpTable (void)
int main (void)

Variables

struct op_structop_array
int max_ops
int no_ops
static char file_header [] = "const struct s390_opcode s390_opcodes[] =\n {\n"

Class Documentation

struct op_struct

Definition at line 43 of file s390-mkopc.c.

Class Members
char format
int min_cpu
char mnemonic
int mode_bits
int no_nibbles
char opcode
unsigned long long sort_value

Enumeration Type Documentation

Enumerator:
S390_OPCODE_G5 
S390_OPCODE_G6 
S390_OPCODE_Z900 
S390_OPCODE_Z990 
S390_OPCODE_Z9_109 
S390_OPCODE_Z9_EC 
S390_OPCODE_G5 
S390_OPCODE_G6 
S390_OPCODE_Z900 
S390_OPCODE_Z990 
S390_OPCODE_Z9_109 
S390_OPCODE_Z9_EC 

Definition at line 33 of file s390-mkopc.c.

Enumerator:
S390_OPCODE_ESA 
S390_OPCODE_ZARCH 
S390_OPCODE_ESA 
S390_OPCODE_ZARCH 

Definition at line 27 of file s390-mkopc.c.


Function Documentation

static void createTable ( void  ) [static]

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

{
  max_ops = 256;
  op_array = malloc (max_ops * sizeof (struct op_struct));
  no_ops = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void dumpTable ( void  ) [static]

Definition at line 134 of file s390-mkopc.c.

{
  char *str;
  int  ix;

  /*  Write hash table entries (slots).  */
  printf (file_header);

  for (ix = 0; ix < no_ops; ix++)
    {
      printf ("  { \"%s\", ", op_array[ix].mnemonic);
      for (str = op_array[ix].opcode; *str != 0; str++)
       if (*str == '?')
         *str = '0';
      printf ("OP%i(0x%sLL), ", 
             op_array[ix].no_nibbles*4, op_array[ix].opcode);
      printf ("MASK_%s, INSTR_%s, ",
             op_array[ix].format, op_array[ix].format);
      printf ("%i, ", op_array[ix].mode_bits);
      printf ("%i}", op_array[ix].min_cpu);
      if (ix < no_ops-1)
       printf (",\n");
      else
       printf ("\n");
    }
  printf ("};\n\n");
  printf ("const int s390_num_opcodes =\n");
  printf ("  sizeof (s390_opcodes) / sizeof (s390_opcodes[0]);\n\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void insertOpcode ( char *  opcode,
char *  mnemonic,
char *  format,
int  min_cpu,
int  mode_bits 
) [static]

Definition at line 70 of file s390-mkopc.c.

{
  char *str;
  unsigned long long sort_value;
  int no_nibbles;
  int ix, k;

  while (no_ops >= max_ops)
    {
      max_ops = max_ops * 2;
      op_array = realloc (op_array, max_ops * sizeof (struct op_struct));
    }

  sort_value = 0;
  str = opcode;
  for (ix = 0; ix < 16; ix++)
    {
      if (*str >= '0' && *str <= '9')
       sort_value = (sort_value << 4) + (*str - '0');
      else if (*str >= 'a' && *str <= 'f')
       sort_value = (sort_value << 4) + (*str - 'a' + 10);
      else if (*str >= 'A' && *str <= 'F')
       sort_value = (sort_value << 4) + (*str - 'A' + 10);
      else if (*str == '?')
       sort_value <<= 4;
      else
       break;
      str ++;
    }
  sort_value <<= 4*(16 - ix);
  sort_value += (min_cpu << 8) + mode_bits;
  no_nibbles = ix;
  for (ix = 0; ix < no_ops; ix++)
    if (sort_value > op_array[ix].sort_value)
      break;
  for (k = no_ops; k > ix; k--)
    op_array[k] = op_array[k-1];
  strcpy(op_array[ix].opcode, opcode);
  strcpy(op_array[ix].mnemonic, mnemonic);
  strcpy(op_array[ix].format, format);
  op_array[ix].sort_value = sort_value;
  op_array[ix].no_nibbles = no_nibbles;
  op_array[ix].min_cpu = min_cpu;
  op_array[ix].mode_bits = mode_bits;
  no_ops++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int main ( void  )

Definition at line 165 of file s390-mkopc.c.

{
  char currentLine[256];
  
  createTable ();

  /*  Read opcode descriptions from `stdin'.  For each mnemonic,
      make an entry into the opcode table.  */
  while (fgets (currentLine, sizeof (currentLine), stdin) != NULL)
    {
      char  opcode[16];
      char  mnemonic[16];
      char  format[16];
      char  description[64];
      char  cpu_string[16];
      char  modes_string[16];
      int   min_cpu;
      int   mode_bits;
      char  *str;

      if (currentLine[0] == '#')
        continue;
      memset (opcode, 0, 8);
      if (sscanf (currentLine, "%15s %15s %15s \"%[^\"]\" %15s %15s",
                opcode, mnemonic, format, description,
                cpu_string, modes_string) == 6)
       {
         if (strcmp (cpu_string, "g5") == 0)
           min_cpu = S390_OPCODE_G5;
         else if (strcmp (cpu_string, "g6") == 0)
           min_cpu = S390_OPCODE_G6;
         else if (strcmp (cpu_string, "z900") == 0)
           min_cpu = S390_OPCODE_Z900;
         else if (strcmp (cpu_string, "z990") == 0)
           min_cpu = S390_OPCODE_Z990;
         else if (strcmp (cpu_string, "z9-109") == 0)
           min_cpu = S390_OPCODE_Z9_109;
         else if (strcmp (cpu_string, "z9-ec") == 0)
           min_cpu = S390_OPCODE_Z9_EC;
         else {
           fprintf (stderr, "Couldn't parse cpu string %s\n", cpu_string);
           exit (1);
         }

         str = modes_string;
         mode_bits = 0;
         do {
           if (strncmp (str, "esa", 3) == 0
              && (str[3] == 0 || str[3] == ',')) {
             mode_bits |= 1 << S390_OPCODE_ESA;
             str += 3;
           } else if (strncmp (str, "zarch", 5) == 0
                     && (str[5] == 0 || str[5] == ',')) {
             mode_bits |= 1 << S390_OPCODE_ZARCH;
             str += 5;
           } else {
             fprintf (stderr, "Couldn't parse modes string %s\n",
                     modes_string);
             exit (1);
           }
           if (*str == ',')
             str++;
         } while (*str != 0);
         insertOpcode (opcode, mnemonic, format, min_cpu, mode_bits);
       }
      else
        fprintf (stderr, "Couldn't scan line %s\n", currentLine);
    }

  dumpTable ();
  return 0;
}

Here is the call graph for this function:


Variable Documentation

char file_header[] = "const struct s390_opcode s390_opcodes[] =\n {\n" [static]

Definition at line 118 of file s390-mkopc.c.

Definition at line 56 of file s390-mkopc.c.

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

Definition at line 55 of file s390-mkopc.c.