#include <stdio.h>

#include "config.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
#include "insn-config.h"
#include "conditions.h"
#include "insn-flags.h"
#include "output.h"
#include "insn-attr.h"
#include "tree.h"
#include "flags.h"
#include "function.h"

enum reg_class regclass_map[] = { AREG, DREG, CREG, BREG,
				  SIREG, DIREG, BPREG, GENERAL_REGS };

static char *register_names[] = REGISTER_NAMES;

int
i86_reg_class_from_letter(c)
{
  switch (c)
  {
  case 'a': return AREG;
  case 'b': return BREG;
  case 'c': return CREG;
  case 'd': return DREG;
  case 'S': return SIREG;
  case 'D': return DIREG;
  case 'B': return BPREG;
  case 'r': return GENERAL_REGS;
  case 'q': return Q_REGS;
  }
  return NO_REGS;
}

i86_const_ok_for_letter_p(v,c)
{
  switch (c)
  {
  case 'I':
    /* The constant that we can shift by: shl ax,1 */
    return v == 1;
  case 'J':
    /* I/O ports and byte registers */
    return v >= 0 && v <= 255;
  }
  return 0;
}

/* The purpose of this function is to decide if "x" represents
   an addressing mode that the assembler can handle directly.  If
   not, gcc will simplify it.

*/

#define DEBUG 0

static char packreg[] = "gggbiibs";
char *
pack_rtx(r, buf, ebuf, strict)
  rtx r;
  char *buf, *ebuf;
{
  rtx x0, x1;
  if (buf >= ebuf)
    return buf;
  switch (GET_CODE(r))
  {
  case PLUS:
    *buf++ = '+';
    buf = pack_rtx(XEXP(r,0), buf, ebuf, strict);
    buf = pack_rtx(XEXP(r,1), buf, ebuf, strict);
    break;
  case MEM:
    *buf++ = 'm';
    buf = pack_rtx(XEXP(r,0), buf, ebuf, strict);
    break;
  case PRE_DEC:
    *buf++ = '<';
    buf = pack_rtx(XEXP(r,0), buf, ebuf, strict);
    break;
  case REG:
    if (strict || REGNO(r)<FIRST_PSEUDO_REGISTER)
      *buf++ = REGNO(r) >= FIRST_PSEUDO_REGISTER ? '?' : packreg[REGNO(r)];
    else
      *buf++ = 'p';
    break;
  case CONST:
  case CONST_INT:
  case SYMBOL_REF:
    *buf++ = '#';
    break;
  default:
    *buf++ = '?';
    break;
  }
  return buf;
}

static char *valid_addr_list[] = {
  "#",
  "b",
  "i",
  "p",
  "+bi",
  "+ib",
  "+pi",
  "+ip",
  "+pb",
  "+bp",
  "+pp",
  "+b#",
  "+i#",
  "+p#",
  "++bi#",
  "++ib#",
  "++pi#",
  "++ip#",
  "++pb#",
  "++bp#",
  "++pp#",
  "<s",
  "<p",
  0
};

extern char *mode_name[];

int
i86_valid_addr(mode,x,strict)
  enum machine_mode mode;
  rtx x;
  int strict;
{
  int i;
  char packed[20];
  *pack_rtx(x, packed, packed+20, strict) = 0;
#if DEBUG
  print_rtl(stdout, x);
  printf(" mode %s %s: `%s'   ", mode_name[mode], strict?"strict":"", packed);
#endif

  for (i=0; valid_addr_list[i]; i++)
  {
    char *v = valid_addr_list[i];
    if (*v == '!')
    {
      if (strict)
	continue;
      v++;
    }
    if (strcmp(packed, v) == 0)
    {
#if DEBUG
      printf("yup\n");
#endif
      return 1;
    }
  }
#if DEBUG
  printf("nope\n");
#endif
  return 0;
}

void
i86_notice_update_cc(e)
  rtx e;
{
  CC_STATUS_INIT;
}

i86_asm_file_start(file)
  FILE *file;
{
  fprintf(file, "\n\n");
}

i86_asm_file_end(file)
  FILE *file;
{
}

i86_asm_identify_gcc(file)
  FILE *file;
{
}

i86_asm_output_source_filename(file, name)
  FILE *file;
  char *name;
{
  fprintf(file, "\t; file %s\n", name);
}

i86_asm_output_source_line(file, line)
  FILE *file;
  int line;
{
  fprintf(file, "\n\t; line %d\n", line);
}

i86_asm_output_external(f,d,s)
  FILE *f;
  char *s;
{
  fprintf(f, "\textern ");
  assemble_name(f, s);
  fprintf(f, "\n");
}

i86_asm_output_external_libcall(f,s)
  FILE *f;
  rtx s;
{
  printf("out ext lib: ", s);
  print_rtl(stdout, s);
  printf("\n");
}

i86_function_prolog(file, size)
  FILE *file;
  int size;
{
  int regno;
  fprintf(file, "\tpush\tbp\n");
  fprintf(file, "\tmov\tbp,sp\n");
  if (size)
    fprintf(file, "\tsub\tsp,%d\n", size);

  for (regno = 5; regno >= 0; regno--)
    if (regs_ever_live[regno] && ! call_used_regs[regno])
	fprintf(file, "\tpush\t%s\n", register_names[regno]);
  fprintf(file, "\n");
}

i86_function_epilog(file, size)
  FILE *file;
  int size;
{
  int regno;
  fprintf(file, "\n");

  for (regno = 0; regno <= 5; regno++)
    if (regs_ever_live[regno] && ! call_used_regs[regno])
	fprintf(file, "\tpop\t%s\n", register_names[regno]);

  fprintf(file, "\tleave\n");
  fprintf(file, "\tret\n\n");
}

#undef DEBUG
#define DEBUG 0

i86_print_operand(s,x,c)
  FILE *s;
  rtx x;
  int c;
{
  rtx x0;
#if DEBUG
  printf("[i86_print_operand(%c)]\n", c?c:' ');
  print_rtl(stdout, x);
  printf("\n");
#endif
  switch (GET_CODE (x))
  {
  case REG:
    if ((c == 'L' || c == 'H') && REGNO(x) <= 4)
      fprintf (s, "%c%c", register_names[REGNO(x)][0], c-'L'+'l');
    else
      fprintf (s, "%s", register_names[REGNO(x)]);
    break;
  case MEM:
    if (c == 'P')
      i86_print_operand(s, XEXP(x,0), 0);
    else
      output_address(x);
    break;
  case PLUS:
    i86_print_operand(s, XEXP(x,0),' ');
    if (GET_CODE(XEXP(x,1)) == CONST_INT)
    {
      fprintf(s, "%+d", INTVAL(XEXP(x,1)));
    }
    else
    {
      fputc('+', s);
      i86_print_operand(s, XEXP(x,1),' ');
    }
    break;
  case SYMBOL_REF:
    assemble_name(s, XSTR(x,0));
    break;
  case CONST:
  case CONST_INT:
  case CODE_LABEL:
    output_addr_const(s, x);
    break;
  default:
    printf("blah! default in i86_print_operand %d\n", GET_CODE(x));
    break;
  }
}

i86_print_operand_address(s,x)
  FILE *s;
  rtx x;
{
  putc('[', s);
  i86_print_operand(s,XEXP(x,0),0);
  putc(']', s);
}