#include <stdio.h>
#include <stdlib.h>

#ifdef USE_NLLIBC
#include <nllibc.h>
#endif

#include "config.h"
#include "lib.h"
#include "type.h"
#include "asm_symbol.h"
#include "asm_code.h"
#include "asm_code_mips.h"

static char *load_by_size(model_t model)
{
  if (model != NULL) {
    switch (model_get_size(model)) {
    case -1: ERREXIT(1);
    case  1: return "lb";
    case  2: return "lh";
    default: break;
    }
  }
  return "lw";
}

static char *store_by_size(model_t model)
{
  if (model != NULL) {
    switch (model_get_size(model)) {
    case -1: ERREXIT(1);
    case  1: return "sb";
    case  2: return "sh";
    default: break;
    }
  }
  return "sw";
}

static void get_value(FILE *out, long value)
{
  ASM_CODE_OUT(out, "\tlui\t$v0, 0x%lx\n", (value >> 16) & 0xffff);
  ASM_CODE_OUT(out, "\tori\t$v0, $v0, 0x%lx\n", value & 0xffff);
}

static void get_value_r1(FILE *out, long value)
{
  ASM_CODE_OUT(out, "\tlui\t$v1, 0x%lx\n", (value >> 16) & 0xffff);
  ASM_CODE_OUT(out, "\tori\t$v1, $v1, 0x%lx\n", value & 0xffff);
}

static void get_address_stack(FILE *out, int offset)
{
  ASM_CODE_OUT(out, "\taddi\t$v0, $sp, 0x%x\n", offset);
}

static int get_address_stack_r1(FILE *out, int offset)
{
  ASM_CODE_OUT(out, "\taddi\t$v1, $sp, 0x%x\n", offset);
  return 0;
}

static void get_address(FILE *out, char *label)
{
  ASM_CODE_OUT(out, "\tlui\t$v0, %%hi(%s)\n", label);
  ASM_CODE_OUT(out, "\taddiu\t$v0, $v0, %%lo(%s)\n", label);
}

static void add_address(FILE *out, int offset)
{
  ASM_CODE_OUT(out, "\taddi\t$v0, $v0, 0x%x\n", offset);
}

static void get_r1(FILE *out)
{
  ASM_CODE_OUT(out, "\tmove\t$v0, $v1\n");
}

static void set_r1(FILE *out)
{
  ASM_CODE_OUT(out, "\tmove\t$v1, $v0\n");
}

static void memory_load(FILE *out, int offset, model_t model)
{
  ASM_CODE_OUT(out, "\t%s\t$v0, 0x%x($v1)\n", load_by_size(model), offset);
}

static void memory_store(FILE *out, int offset, model_t model)
{
  ASM_CODE_OUT(out, "\t%s\t$v0, 0x%x($v1)\n", store_by_size(model), offset);
}

static void stack_load(FILE *out, int offset, model_t model)
{
  ASM_CODE_OUT(out, "\t%s\t$v0, 0x%x($sp)\n", load_by_size(model), offset);
}

static void stack_store(FILE *out, int offset, model_t model)
{
  ASM_CODE_OUT(out, "\t%s\t$v0, 0x%x($sp)\n", store_by_size(model), offset);
}

static void stack_load_r1(FILE *out, int offset, model_t model)
{
  ASM_CODE_OUT(out, "\t%s\t$v1, 0x%x($sp)\n", load_by_size(model), offset);
}

static void stack_store_r1(FILE *out, int offset, model_t model)
{
  ASM_CODE_OUT(out, "\t%s\t$v1, 0x%x($sp)\n", store_by_size(model), offset);
}

static void stack_expand(FILE *out, int size)
{
  ASM_CODE_OUT(out, "\taddiu\t$sp, $sp, -0x%x\n", size);
}

static void stack_reduce(FILE *out, int size)
{
  ASM_CODE_OUT(out, "\taddiu\t$sp, $sp, 0x%x\n", size);
}

static char *funccall_regs[] = {
  "a0", "a1", "a2", "a3"
};

static void funccall_reg_load(FILE *out, int number)
{
  ASM_CODE_OUT(out, "\tmove\t$v0, $%s\n", funccall_regs[number]);
}

static void funccall_reg_store(FILE *out, int number)
{
  ASM_CODE_OUT(out, "\tmove\t$%s, $v0\n", funccall_regs[number]);
}

static char *tmp_regs[] = {
  "s0", "s1",
};

static void tmp_reg_load(FILE *out, int number)
{
  ASM_CODE_OUT(out, "\tmove\t$v0, $%s\n", tmp_regs[number]);
}

static void tmp_reg_save(FILE *out, int number)
{
  ASM_CODE_OUT(out, "\tmove\t$%s, $v0\n", tmp_regs[number]);
}

static void tmp_reg_load_r1(FILE *out, int number)
{
  ASM_CODE_OUT(out, "\tmove\t$v1, $%s\n", tmp_regs[number]);
}

static void tmp_reg_save_r1(FILE *out, int number)
{
  ASM_CODE_OUT(out, "\tmove\t$%s, $v1\n", tmp_regs[number]);
}

static int sign_extension_char(FILE *out)
{
  ASM_CODE_OUT(out, "\tsll\t$v0, $v0, 24\n");
  ASM_CODE_OUT(out, "\tsra\t$v0, $v0, 24\n");
  return 0;
}

static int sign_extension_uchar(FILE *out)
{
  ASM_CODE_OUT(out, "\tsll\t$v0, $v0, 24\n");
  ASM_CODE_OUT(out, "\tsrl\t$v0, $v0, 24\n");
  return 0;
}

static int sign_extension_short(FILE *out)
{
  ASM_CODE_OUT(out, "\tsll\t$v0, $v0, 16\n");
  ASM_CODE_OUT(out, "\tsra\t$v0, $v0, 16\n");
  return 0;
}

static int sign_extension_ushort(FILE *out)
{
  ASM_CODE_OUT(out, "\tsll\t$v0, $v0, 16\n");
  ASM_CODE_OUT(out, "\tsrl\t$v0, $v0, 16\n");
  return 0;
}

static int sign_extension_int(FILE *out)
{
  return -1;
}

static int sign_extension_uint(FILE *out)
{
  return -1;
}

static int calc_inv(FILE *out, model_t model, model_t model_arg0)
{
  ASM_CODE_OUT(out, "\tnor\t$v0, $zero, $v0\n");
  return 0;
}

static int calc_minus(FILE *out, model_t model, model_t model_arg0)
{
  ASM_CODE_OUT(out, "\tnegu\t$v0, $v0\n");
  return 0;
}

static int calc_op1(FILE *out, c_type_t type, model_t model, model_t model_arg0)
{
  return -1;
}

static void calc_add(FILE *out, model_t model, model_t model_arg0, model_t model_arg1)
{
  ASM_CODE_OUT(out, "\taddu\t$v0, $v0, $v1\n");
}

static void calc_sub(FILE *out, model_t model, model_t model_arg0, model_t model_arg1)
{
  ASM_CODE_OUT(out, "\tsubu\t$v0, $v0, $v1\n");
}

static void calc_and(FILE *out, model_t model, model_t model_arg0, model_t model_arg1)
{
  ASM_CODE_OUT(out, "\tand\t$v0, $v0, $v1\n");
}

static void calc_or(FILE *out, model_t model, model_t model_arg0, model_t model_arg1)
{
  ASM_CODE_OUT(out, "\tor\t$v0, $v0, $v1\n");
}

static int calc_xor(FILE *out, model_t model, model_t model_arg0, model_t model_arg1)
{
  ASM_CODE_OUT(out, "\txor\t$v0, $v0, $v1\n");
  return 0;
}

static int calc_mul(FILE *out, model_t model, model_t model_arg0, model_t model_arg1)
{
  ASM_CODE_OUT(out, "\tmult\t$v0, $v1\n");
  ASM_CODE_OUT(out, "\tmflo\t$v0\n");
  return 0;
}

static int calc_div(FILE *out, model_t model, model_t model_arg0, model_t model_arg1)
{
  if (model_arg0->flags & MODEL_FLAG_UNSIGNED) {
    ASM_CODE_OUT(out, "\tdivu\t$zero, $v0, $v1\n");
  } else {
    ASM_CODE_OUT(out, "\tdiv\t$zero, $v0, $v1\n");
  }
  ASM_CODE_OUT(out, "\tmflo\t$v0\n");
  return 0;
}

static int calc_mod(FILE *out, model_t model, model_t model_arg0, model_t model_arg1)
{
  if (model_arg0->flags & MODEL_FLAG_UNSIGNED) {
    ASM_CODE_OUT(out, "\tdivu\t$zero, $v0, $v1\n");
  } else {
    ASM_CODE_OUT(out, "\tdiv\t$zero, $v0, $v1\n");
  }
  ASM_CODE_OUT(out, "\tmfhi\t$v0\n");
  return 0;
}

static int calc_llshift(FILE *out, model_t model, model_t model_arg0, model_t model_arg1)
{
  ASM_CODE_OUT(out, "\tsllv\t$v0, $v0, $v1\n");
  return 0;
}

static int calc_rashift(FILE *out, model_t model, model_t model_arg0, model_t model_arg1)
{
  ASM_CODE_OUT(out, "\tsrav\t$v0, $v0, $v1\n");
  return 0;
}

static int calc_rlshift(FILE *out, model_t model, model_t model_arg0, model_t model_arg1)
{
  ASM_CODE_OUT(out, "\tsrlv\t$v0, $v0, $v1\n");
  return 0;
}

static int calc_op2(FILE *out, c_type_t type, model_t model, model_t model_arg0, model_t model_arg1)
{
  return -1;
}

static void branch(FILE *out, char *label)
{
  ASM_CODE_OUT(out, "\tj\t%s\n", label);
  ASM_CODE_OUT(out, "\tnop\t/* delay slot */\n");
}

static int branch_zero(FILE *out, char *label)
{
  ASM_CODE_OUT(out, "\tbeqz\t$v0, %s\n", label);
  ASM_CODE_OUT(out, "\tnop\t/* delay slot */\n");
  return 0;
}

static int branch_nzero(FILE *out, char *label)
{
  ASM_CODE_OUT(out, "\tbnez\t$v0, %s\n", label);
  ASM_CODE_OUT(out, "\tnop\t/* delay slot */\n");
  return 0;
}

static int branch_cmp_eq(FILE *out, char *label, model_t model)
{
  ASM_CODE_OUT(out, "\tbeq\t$v0, $v1, %s\n", label);
  ASM_CODE_OUT(out, "\tnop\t/* delay slot */\n");
  return 0;
}

static int branch_cmp_ne(FILE *out, char *label, model_t model)
{
  ASM_CODE_OUT(out, "\tbne\t$v0, $v1, %s\n", label);
  ASM_CODE_OUT(out, "\tnop\t/* delay slot */\n");
  return 0;
}

static int branch_cmp_lt(FILE *out, char *label, model_t model)
{
  ASM_CODE_OUT(out, "\tslt\t$v0, $v0, $v1\n");
  ASM_CODE_OUT(out, "\tbnez\t$v0, %s\n", label);
  ASM_CODE_OUT(out, "\tnop\t/* delay slot */\n");
  return 0;
}

static int branch_cmp_gt(FILE *out, char *label, model_t model)
{
  ASM_CODE_OUT(out, "\tslt\t$v0, $v1, $v0\n");
  ASM_CODE_OUT(out, "\tbnez\t$v0, %s\n", label);
  ASM_CODE_OUT(out, "\tnop\t/* delay slot */\n");
  return 0;
}

static int branch_cmp_le(FILE *out, char *label, model_t model)
{
  ASM_CODE_OUT(out, "\tslt\t$v0, $v1, $v0\n");
  ASM_CODE_OUT(out, "\tbeqz\t$v0, %s\n", label);
  ASM_CODE_OUT(out, "\tnop\t/* delay slot */\n");
  return 0;
}

static int branch_cmp_ge(FILE *out, char *label, model_t model)
{
  ASM_CODE_OUT(out, "\tslt\t$v0, $v0, $v1\n");
  ASM_CODE_OUT(out, "\tbeqz\t$v0, %s\n", label);
  ASM_CODE_OUT(out, "\tnop\t/* delay slot */\n");
  return 0;
}

static int branch_cmp_ult(FILE *out, char *label, model_t model)
{
  ASM_CODE_OUT(out, "\tsltu\t$v0, $v0, $v1\n");
  ASM_CODE_OUT(out, "\tbnez\t$v0, %s\n", label);
  ASM_CODE_OUT(out, "\tnop\t/* delay slot */\n");
  return 0;
}

static int branch_cmp_ugt(FILE *out, char *label, model_t model)
{
  ASM_CODE_OUT(out, "\tsltu\t$v0, $v1, $v0\n");
  ASM_CODE_OUT(out, "\tbnez\t$v0, %s\n", label);
  ASM_CODE_OUT(out, "\tnop\t/* delay slot */\n");
  return 0;
}

static int branch_cmp_ule(FILE *out, char *label, model_t model)
{
  ASM_CODE_OUT(out, "\tsltu\t$v0, $v1, $v0\n");
  ASM_CODE_OUT(out, "\tbeqz\t$v0, %s\n", label);
  ASM_CODE_OUT(out, "\tnop\t/* delay slot */\n");
  return 0;
}

static int branch_cmp_uge(FILE *out, char *label, model_t model)
{
  ASM_CODE_OUT(out, "\tsltu\t$v0, $v0, $v1\n");
  ASM_CODE_OUT(out, "\tbeqz\t$v0, %s\n", label);
  ASM_CODE_OUT(out, "\tnop\t/* delay slot */\n");
  return 0;
}

static int branch_cmp(FILE *out, char *label, c_type_t type, model_t model)
{
  return -1;
}

static int function_call(FILE *out, char *label)
{
  ASM_CODE_OUT(out, "\tjal\t%s\n", label);
  ASM_CODE_OUT(out, "\tnop\t/* delay slot */\n");
  return 0;
}

static int function_call_set(FILE *out)
{
  /*
   * Standard register(R0) is not used as arguments of the function call,
   * so it can be used as the pointer of the function.
   */
  return -1;
}

static int function_call_pointer(FILE *out)
{
  ASM_CODE_OUT(out, "\tjalr\t$v0\n");
  ASM_CODE_OUT(out, "\tnop\t/* delay slot */\n");
  return 0;
}

static void function_start(FILE *out)
{
  ASM_CODE_OUT(out, "\taddiu\t$sp, $sp, -4\n");
  ASM_CODE_OUT(out, "\tsw\t$ra, 0($sp)\n");
}

static void function_end(FILE *out)
{
  ASM_CODE_OUT(out, "\tlw\t$ra, 0($sp)\n");
  ASM_CODE_OUT(out, "\taddiu\t$sp, $sp, 4\n");
  ASM_CODE_OUT(out, "\tjr\t$ra\n");
  ASM_CODE_OUT(out, "\tnop\t/* delay slot */\n\n");
}

static void function_register_save(FILE *out)
{
  ASM_CODE_OUT(out, "\taddiu\t$sp, $sp, -8\n");
  ASM_CODE_OUT(out, "\tsw\t$s0, 0($sp)\n");
  ASM_CODE_OUT(out, "\tsw\t$s1, 4($sp)\n");
}

static void function_register_load(FILE *out)
{
  ASM_CODE_OUT(out, "\tlw\t$s0, 0($sp)\n");
  ASM_CODE_OUT(out, "\tlw\t$s1, 4($sp)\n");
  ASM_CODE_OUT(out, "\taddiu\t$sp, $sp, 8\n");
}

struct asm_code_callback asm_code_callback_mips = {
  NULL, /* type mark */

  4, /* word size */
  4, /* pointer size */
  4, /* funccall args reg number: a0/a1/a2/a3 (See funccall_regs[]) */
  VALUE_FUNCTION_ARGS_NUM, /* funccall args stack number */
  2, /* tmp reg number: s0/s1 (See tmp_regs[]) */
  VALUE_FUNCTION_ARGS_NUM, /* tmp stack number */
  2, /* function register number: s0/s1 (See function_register_save() */
  1, /* function saveparam number: ra (See function_start() */
  16, /* stack align size */
  0, /* stack correct size */

  get_value,
  get_value_r1,
  get_address_stack,
  get_address_stack_r1,
  get_address,
  add_address,
  get_r1,
  set_r1,

  memory_load,
  memory_store,
  stack_load,
  stack_store,
  stack_load_r1,
  stack_store_r1,
  stack_expand,
  stack_reduce,

  funccall_reg_load,
  funccall_reg_store,
  tmp_reg_load,
  tmp_reg_save,
  tmp_reg_load_r1,
  tmp_reg_save_r1,

  sign_extension_char,
  sign_extension_uchar,
  sign_extension_short,
  sign_extension_ushort,
  sign_extension_int,
  sign_extension_uint,

  calc_inv,
  calc_minus,

  calc_op1,

  calc_add,
  calc_sub,
  calc_and,
  calc_or,
  calc_xor,

  calc_mul,
  calc_div,
  calc_mod,
  calc_llshift,
  calc_rashift,
  calc_rlshift,

  calc_op2,

  branch,
  branch_zero,
  branch_nzero,

  branch_cmp_eq,
  branch_cmp_ne,

  branch_cmp_lt,
  branch_cmp_gt,
  branch_cmp_le,
  branch_cmp_ge,
  branch_cmp_ult,
  branch_cmp_ugt,
  branch_cmp_ule,
  branch_cmp_uge,

  branch_cmp,

  function_call,
  function_call_set,
  function_call_pointer,

  function_start,
  function_end,
  function_register_save,
  function_register_load,
};
