URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [tags/] [nog_patch_70/] [or1ksim/] [cuc/] [load.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/* load.c -- OpenRISC Custom Unit Compiler, instruction loading and converting
 *    Copyright (C) 2002 Marko Mlinar, markom@opencores.org
 *
 *    This file is part of OpenRISC 1000 Architectural Simulator.
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <assert.h>
#include <string.h>
 
#include "config.h"
 
#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif
 
#include "port.h"
#include "arch.h"
#include "abstract.h"
#include "sim-config.h"
#include "cuc.h"
#include "opcode/or32.h"
#include "insn.h"
 
static const cuc_conv conv[] = {
{"l.add", II_ADD}, {"l.addi", II_ADD},
{"l.movhi", II_OR},
{"l.sub", II_SUB}, {"l.subi", II_SUB},
{"l.and", II_AND}, {"l.andi", II_AND},
{"l.xor", II_XOR}, {"l.xori", II_XOR},
{"l.or",  II_OR }, {"l.ori",  II_OR},
{"l.mul", II_MUL}, {"l.muli", II_MUL},
 
{"l.sra", II_SRA}, {"l.srai", II_SRA},
{"l.srl", II_SRL}, {"l.srli", II_SRL},
{"l.sll", II_SLL}, {"l.slli", II_SLL},
 
{"l.lbz",II_LB | II_MEM}, {"l.lbs", II_LB | II_MEM | II_SIGNED},
{"l.lhz",II_LH | II_MEM}, {"l.lhs", II_LH | II_MEM | II_SIGNED},
{"l.lwz",II_LW | II_MEM}, {"l.lws", II_LW | II_MEM | II_SIGNED},
{"l.sb", II_SB | II_MEM}, {"l.sh",  II_SH | II_MEM}, {"l.sw", II_SW | II_MEM},
{"l.sfeq",  II_SFEQ }, {"l.sfeqi", II_SFEQ},
{"l.sfne",  II_SFNE }, {"l.sfnei", II_SFNE},
{"l.sflts", II_SFLT | II_SIGNED}, {"l.sfltis", II_SFLT | II_SIGNED},
{"l.sfltu", II_SFLT}, {"l.sfltiu", II_SFLT},
{"l.sfgts", II_SFGT | II_SIGNED}, {"l.sfgtis", II_SFGT | II_SIGNED},
{"l.sfgtu", II_SFGT}, {"l.sfgtiu", II_SFGT},
{"l.sfges", II_SFGE | II_SIGNED}, {"l.sfgeis", II_SFGE | II_SIGNED},
{"l.sfgeu", II_SFGE}, {"l.sfgeiu", II_SFGE},
{"l.sfles", II_SFLE | II_SIGNED}, {"l.sfleis", II_SFLE | II_SIGNED},
{"l.sfleu", II_SFLE}, {"l.sfleiu", II_SFLE},
{"l.j",     II_BF   },
{"l.bf",    II_BF   },
{"l.jal",   II_CALL },
{"l.nop",   II_NOP  }
};
 
/* Instructions from function */
cuc_insn insn[MAX_INSNS];
int num_insn;
int reloc[MAX_INSNS];
 
/* Prints out instructions */
void print_cuc_insns (char *s, int verbose)
{
  PRINTF ("****************** %s ******************\n", s);
  print_insns (0, insn, num_insn,verbose);
  PRINTF ("\n\n");
}
 
void xchg_insn (int i, int j)
{
  cuc_insn t;
  t = insn[i];
  insn[i] = insn[j];
  insn[j] = t;
}
 
/* Negates conditional instruction */
void negate_conditional (cuc_insn *ii)
{
  assert (ii->type & IT_COND);
 
  if (ii->index == II_SFEQ) change_insn_type (ii, II_SFNE);
  else if (ii->index == II_SFNE) change_insn_type (ii, II_SFEQ);
  else if (ii->index == II_SFLT) change_insn_type (ii, II_SFGE);
  else if (ii->index == II_SFGT) change_insn_type (ii, II_SFLE);
  else if (ii->index == II_SFLE) change_insn_type (ii, II_SFGT);
  else if (ii->index == II_SFGE) change_insn_type (ii, II_SFLT);
  else assert (0);
}
 
/* Remove delay slots */
void remove_dslots ()
{
  int i;
  int in_delay = 0;
  for (i = 0; i < num_insn; i++) {
    if (in_delay) insn[i].type |= IT_INDELAY;
    in_delay = 0;
    if (insn[i].type & IT_BRANCH) in_delay = 1;
    if (insn[i].type & IT_INDELAY) {
      cuc_insn *ii;
      cuc_insn *bi;
      assert (i >= 2);
      ii = &insn[i - 2];
      bi = &insn[i - 1];
      /* delay slot should not be a branch target! */
      assert ((insn[i].type & IT_BBSTART) == 0);
      assert ((bi->type & IT_INDELAY) == 0);
      insn[i].type &= ~IT_INDELAY; /* no more in delay slot */
 
      /* Get the value we need before the actual jump */
      if (bi->opt[1] & OPT_REGISTER && bi->op[1] >= 0) {
        int r = bi->op[1];
        assert (ii->index == II_NOP);
        change_insn_type (ii, II_ADD);
        ii->type = IT_COND;
        ii->dep = NULL;
        ii->op[0] = r; ii->opt[0] = OPT_REGISTER | OPT_DEST;
        ii->op[1] = r; ii->opt[1] = OPT_REGISTER;
        ii->op[2] = 0; ii->opt[2] = OPT_CONST;
        ii->opt[3] = OPT_NONE;
        bi->op[1] = i - 2; bi->opt[1] = OPT_REF;
      }
      xchg_insn (i, i - 1);
    }
  }
  assert (in_delay == 0);
}
 
/* Convert local variables (uses stack frame -- r1) to internal values */
void detect_locals ()
{
  int stack[CUC_MAX_STACK];
  int i, can_remove_stack = 1;
  int real_stack_size = 0;
 
  for (i = 0; i < CUC_MAX_STACK; i++) stack[i] = -1;
 
  for (i = 0; i < num_insn; i++) {
    /* sw off (r1),rx */
    if (insn[i].index == II_SW
      && (insn[i].opt[0] & OPT_CONST)
      && insn[i].op[1] == 1 && (insn[i].opt[1] & OPT_REGISTER)) {
 
      if (insn[i].op[0] < CUC_MAX_STACK/* && insn[i].op[1] >= 4*/) { /* Convert to normal move */
        stack[insn[i].op[0]] = i;
        insn[i].type &= IT_INDELAY | IT_BBSTART;
        change_insn_type (&insn[i], II_ADD);
        insn[i].op[0] = -1; insn[i].opt[0] = OPT_REGISTER | OPT_DEST;
        insn[i].op[1] = insn[i].op[2]; insn[i].opt[1] = insn[i].opt[2];
        insn[i].op[2] = 0; insn[i].opt[2] = OPT_CONST;
      } else can_remove_stack = 0;
    /* lw rx,off (r1) */
    } else if (insn[i].index == II_LW
      && (insn[i].opt[1] & OPT_CONST)
      && insn[i].op[2] == 1 && (insn[i].opt[2] & OPT_REGISTER)) {
 
      if (insn[i].op[1] < CUC_MAX_STACK && stack[insn[i].op[1]] >= 0) { /* Convert to normal move */
        insn[i].type &= IT_INDELAY | IT_BBSTART;
        change_insn_type (&insn[i], II_ADD);
        insn[i].op[1] = stack[insn[i].op[1]]; insn[i].opt[1] = OPT_REF;
        insn[i].op[2] = 0; insn[i].opt[2] = OPT_CONST;
      } else can_remove_stack = 0;
    /* Check for defined stack size */
    } else if (insn[i].index == II_ADD && !real_stack_size
            && (insn[i].opt[0] & OPT_REGISTER) && insn[i].op[0] == 1
            && (insn[i].opt[1] & OPT_REGISTER) && insn[i].op[1] == 1
            && (insn[i].opt[2] & OPT_CONST)) {
      real_stack_size = -insn[i].op[2];
    }
  }
  //assert (can_remove_stack); /* TODO */  
}
 
/* Disassemble one instruction from insn index and generate parameters */
const char *build_insn (unsigned long data, cuc_insn *insn)
{
  const char *name;
  char *s;
  extern char *disassembled;
  int index = insn_decode (data);
  struct or32_opcode const *opcode;
  int i, argc = 0;
 
  insn->insn = data;
  insn->index = -1;
  insn->type = 0;
  name = insn_name (index);
  insn->index = index;
  disassemble_index (data, index);
  strcpy (insn->disasm, disassembled);
  insn->dep = NULL;
  for (i = 0; i < MAX_OPERANDS; i++) insn->opt[i] = OPT_NONE;
 
  if (index < 0) {
    fprintf (stderr, "Invalid opcode 0x%08lx!\n", data);
    exit (1);
  }
  opcode = &or32_opcodes[index];
 
  for (s = opcode->args; *s != '\0'; ++s) {
    switch (*s) {
    case '\0': return name;
    case 'r':
      insn->opt[argc] = OPT_REGISTER | (argc ? 0 : OPT_DEST);
      insn->op[argc++] = or32_extract(*++s, opcode->encoding, data);
      break;
 
    default:
      if (strchr (opcode->encoding, *s)) {
        unsigned long imm = or32_extract (*s, opcode->encoding, data);
        imm = extend_imm(imm, *s);
        insn->opt[argc] = OPT_CONST;
        insn->op[argc++] = imm;
      }
    }
  }
  return name;
}
 
/* inserts nop before branch */
void expand_branch ()
{
  int i, j, num_bra = 0, d;
  for (i = 0; i < num_insn; i++) if (insn[i].type & IT_BRANCH) num_bra++;
 
  d = num_insn + 2 * num_bra;
  assert (d < MAX_INSNS);
 
  /* Add nop before branch */
  for (i = num_insn - 1; i >= 0; i--) if (insn[i].type & IT_BRANCH) {
    insn[--d] = insn[i]; // for delay slot (later)
    if (insn[d].opt[1] & OPT_REGISTER) {
      assert (insn[d].op[1] == FLAG_REG);
      insn[d].op[1] = i; insn[d].opt[1] = OPT_REF;
    }
    insn[--d] = insn[i]; // for branch
    change_insn_type (&insn[d], II_NOP);
    insn[--d] = insn[i]; // save flag & negation of conditional, if required
    change_insn_type (&insn[d], II_CMOV);
    insn[d].op[0] = -1; insn[d].opt[0] = OPT_REGISTER | OPT_DEST;
    insn[d].op[1] = insn[d].type & IT_FLAG1 ? 0 : 1; insn[d].opt[1] = OPT_CONST;
    insn[d].op[2] = insn[d].type & IT_FLAG1 ? 1 : 0; insn[d].opt[2] = OPT_CONST;
    insn[d].op[3] = FLAG_REG; insn[d].opt[3] = OPT_REGISTER;
    insn[d].type = IT_COND;
    if (insn[d].type)
    reloc[i] = d;
  } else {
    insn[--d] = insn[i];
    reloc[i] = d;
  }
  num_insn += 2 * num_bra;
  for (i = 0; i < num_insn; i++)
    for (j = 0; j < MAX_OPERANDS; j++)
      if (insn[i].opt[j] & OPT_REF || insn[i].opt[j] & OPT_JUMP)
        insn[i].op[j] = reloc[insn[i].op[j]];
}
 
/* expands immediate memory instructions to two */
void expand_memory ()
{
  int i, j, num_mem = 0, d;
  for (i = 0; i < num_insn; i++) if (insn[i].type & IT_MEMORY) num_mem++;
 
  d = num_insn + num_mem;
  assert (d < MAX_INSNS);
 
  /* Split memory commands */
  for (i = num_insn - 1; i >= 0; i--) if (insn[i].type & IT_MEMORY) {
    insn[--d] = insn[i];
    insn[--d] = insn[i];
    reloc[i] = d;
    switch (insn[d].index) {
    case II_SW:
    case II_SH:
    case II_SB:
              insn[d + 1].op[1] = d; insn[d + 1].opt[1] = OPT_REF; /* sw rx,(t($-1)) */
              insn[d + 1].op[0] = insn[i].op[2]; insn[d + 1].opt[0] = insn[d + 1].opt[2];
              insn[d + 1].opt[2] = OPT_NONE;
              insn[d + 1].type &= ~IT_BBSTART;
              insn[d].op[2] = insn[d].op[0]; insn[d].opt[2] = insn[d].opt[0];
              insn[d].op[0] = -1; insn[d].opt[0] = OPT_REGISTER | OPT_DEST; /* add rd, ra, rb */
              insn[d].opt[3] = OPT_NONE;
              insn[d].type &= IT_INDELAY | IT_BBSTART;
              insn[d].type |= IT_MEMADD;
              change_insn_type (&insn[d], II_ADD);
              break;
    case II_LW:
    case II_LH:
    case II_LB:
              insn[d].op[0] = -1; insn[d].opt[0] = OPT_REGISTER | OPT_DEST; /* add rd, ra, rb */
              insn[d].type &= IT_INDELAY | IT_BBSTART;
              insn[d].type |= IT_MEMADD;
              change_insn_type (&insn[d], II_ADD);
              insn[d + 1].op[1] = d; insn[d + 1].opt[1] = OPT_REF; /* lw (t($-1)),rx */
              insn[d + 1].opt[2] = OPT_NONE;
              insn[d + 1].opt[3] = OPT_NONE;
              insn[d + 1].type &= ~IT_BBSTART;
              break;
    default:  fprintf (stderr, "%4i, %4i: %s\n", i, d, cuc_insn_name (&insn[d]));
              assert (0);
    }
  } else {
    insn[--d] = insn[i];
    reloc[i] = d;
  }
  num_insn += num_mem;
  for (i = 0; i < num_insn; i++) if (!(insn[i].type & IT_MEMORY))
    for (j = 0; j < MAX_OPERANDS; j++)
      if (insn[i].opt[j] & OPT_REF || insn[i].opt[j] & OPT_JUMP)
        insn[i].op[j] = reloc[insn[i].op[j]];
}
 
/* expands signed comparisons to three instructions */
void expand_signed ()
{
  int i, j, num_sig = 0, d;
  for (i = 0; i < num_insn; i++)
    if (insn[i].type & IT_SIGNED && !(insn[i].type & IT_MEMORY)) num_sig++;
 
  d = num_insn + num_sig * 2;
  assert (d < MAX_INSNS);
 
  /* Split signed instructions */
  for (i = num_insn - 1; i >= 0; i--)
    /* We will expand signed memory later */
    if (insn[i].type & IT_SIGNED && !(insn[i].type & IT_MEMORY)) {
      insn[--d] = insn[i];
      insn[d].op[1] = d - 2; insn[d].opt[1] = OPT_REF;
      insn[d].op[2] = d - 1; insn[d].opt[2] = OPT_REF;
 
      insn[--d] = insn[i];
      change_insn_type (&insn[d], II_ADD);
      insn[d].type = 0;
      insn[d].op[0] = -1; insn[d].opt[0] = OPT_REGISTER | OPT_DEST;
      insn[d].op[1] = insn[d].op[2]; insn[d].opt[1] = insn[d].opt[2];
      insn[d].op[2] = 0x80000000; insn[d].opt[2] = OPT_CONST;
      insn[d].opt[3] = OPT_NONE;
 
      insn[--d] = insn[i];
      change_insn_type (&insn[d], II_ADD);
      insn[d].type = 0;
      insn[d].op[0] = -1; insn[d].opt[0] = OPT_REGISTER | OPT_DEST;
      insn[d].op[1] = insn[d].op[1]; insn[d].opt[1] = insn[d].opt[1];
      insn[d].op[2] = 0x80000000; insn[d].opt[2] = OPT_CONST;
      insn[d].opt[3] = OPT_NONE;
 
      reloc[i] = d;
    } else {
      insn[--d] = insn[i];
      reloc[i] = d;
    }
  num_insn += num_sig * 2;
  for (i = 0; i < num_insn; i++) if (insn[i].type & IT_MEMORY || !(insn[i].type & IT_SIGNED)) {
    for (j = 0; j < MAX_OPERANDS; j++)
      if (insn[i].opt[j] & OPT_REF || insn[i].opt[j] & OPT_JUMP)
        insn[i].op[j] = reloc[insn[i].op[j]];
  } else insn[i].type &= ~IT_SIGNED;
}
 
/* expands calls to 7 instructions */
void expand_calls ()
{
  int i, j, num_call = 0, d;
  for (i = 0; i < num_insn; i++)
    if (insn[i].index == II_CALL) num_call++;
 
  d = num_insn + num_call * 6; /* 6 parameters */
  assert (d < MAX_INSNS);
 
  /* Split call instructions */
  for (i = num_insn - 1; i >= 0; i--)
    /* We will expand signed memory later */
    if (insn[i].index == II_CALL) {
      insn[--d] = insn[i];
      insn[d].op[0] = insn[d].op[1]; insn[d].opt[0] = OPT_CONST;
      insn[d].opt[1] = OPT_NONE;
      insn[d].type |= IT_VOLATILE;
 
      for (j = 0; j < 6; j++) {
        insn[--d] = insn[i];
        change_insn_type (&insn[d], II_ADD);
        insn[d].type = IT_VOLATILE;
        insn[d].op[0] = 3 + j; insn[d].opt[0] = OPT_REGISTER | OPT_DEST;
        insn[d].op[1] = 3 + j; insn[d].opt[1] = OPT_REGISTER;
        insn[d].op[2] = 0x80000000; insn[d].opt[2] = OPT_CONST;
        insn[d].opt[3] = OPT_NONE;
      }
 
      reloc[i] = d;
    } else {
      insn[--d] = insn[i];
      reloc[i] = d;
    }
  num_insn += num_call * 6;
  for (i = 0; i < num_insn; i++)
    for (j = 0; j < MAX_OPERANDS; j++)
      if (insn[i].opt[j] & OPT_REF || insn[i].opt[j] & OPT_JUMP)
        insn[i].op[j] = reloc[insn[i].op[j]];
}
 
/* Loads function from file into global array insn.
   Function returns nonzero if function cannot be converted. */
int cuc_load (char *in_fn)
{
  int i, j;
  FILE *fi;
  int func_return = 0;
  num_insn = 0;
 
  log ("Loading filename %s\n", in_fn);
  if ((fi = fopen (in_fn, "rt")) == NULL) {
    fprintf (stderr, "Cannot open '%s'\n", in_fn);
    exit (1);
  }
  /* Read in the function and decode the instructions */
  for (i = 0;; i++) {
    unsigned long data;
    const char *name;
 
    if (fscanf (fi, "%08lx\n", &data) != 1) break;
 
    /* build params */
    name = build_insn (data, &insn[i]);
    if (func_return) func_return++;
    //PRINTF ("%s\n", name);
 
    if (or32_opcodes[insn[i].index].flags & OR32_IF_DELAY) {
      int f;
      if (strcmp (name, "l.bnf") == 0) f = 1;
      else if (strcmp (name, "l.bf") == 0) f = 0;
      else if (strcmp (name, "l.j") == 0) {
        f = -1;
      } else if (strcmp (name, "l.jr") == 0 && func_return == 0) {
        func_return = 1;
        change_insn_type (&insn[i], II_NOP);
        continue;
      } else {
        cucdebug (1, "Instruction #%i: \"%s\" not supported.\n", i, name);
        log ("Instruction #%i: \"%s\" not supported.\n", i, name);
        return 1;
      }
      if (f < 0) { /* l.j */
        /* repair params */
        change_insn_type (&insn[i], II_BF);
        insn[i].op[0] = i + insn[i].op[0]; insn[i].opt[0] = OPT_JUMP;
        insn[i].op[1] = 1; insn[i].opt[1] = OPT_CONST;
        insn[i].type |= IT_BRANCH | IT_VOLATILE;
      } else {
        change_insn_type (&insn[i], II_BF);
        insn[i].op[0] = i + insn[i].op[0]; insn[i].opt[0] = OPT_JUMP;
        insn[i].op[1] = FLAG_REG; insn[i].opt[1] = OPT_REGISTER;
        insn[i].type |= IT_BRANCH | IT_VOLATILE;
        if (f) insn[i].type |= IT_FLAG1;
      }
    } else {
      insn[i].index = -1;
      for (j = 0; j < sizeof (conv) / sizeof (cuc_conv); j++)
        if (strcmp (conv[j].from, name) == 0) {
          if (conv[j].to & II_SIGNED) insn[i].type |= IT_SIGNED;
          if (conv[j].to & II_MEM) insn[i].type |= IT_MEMORY | IT_VOLATILE;
          change_insn_type (&insn[i], conv[j].to & II_MASK);
          break;
        }
      if (strcmp (name, "l.movhi") == 0) {
        insn[i].op[1] <<= 16;
        insn[i].op[2] = 0;
        insn[i].opt[2] = OPT_CONST;
      }
      if (insn[i].index == II_SFEQ || insn[i].index == II_SFNE
       || insn[i].index == II_SFLE || insn[i].index == II_SFGT
       || insn[i].index == II_SFGE || insn[i].index == II_SFLT) {
        /* repair params */
        insn[i].op[2] = insn[i].op[1]; insn[i].opt[2] = insn[i].opt[1] & ~OPT_DEST;
        insn[i].op[1] = insn[i].op[0]; insn[i].opt[1] = insn[i].opt[0] & ~OPT_DEST;
        insn[i].op[0] = FLAG_REG; insn[i].opt[0] = OPT_DEST | OPT_REGISTER;
        insn[i].opt[3] = OPT_NONE;
        insn[i].type |= IT_COND;
      }
      if (insn[i].index < 0 || insn[i].index == II_NOP && insn[i].op[0] != 0) {
        cucdebug (1, "Instruction #%i: \"%s\" not supported (2).\n", i, name);
        log ("Instruction #%i: \"%s\" not supported (2).\n", i, name);
        return 1;
      }
    }
  }
  num_insn = i;
  fclose (fi);
  if (func_return != 2) {
    cucdebug (1, "Unsupported function structure.\n");
    log ("Unsupported function structure.\n");
    return 1;
  }
 
  log ("Number of instructions loaded = %i\n", num_insn);
  if (cuc_debug >= 3) print_cuc_insns ("INITIAL", 1);
 
  log ("Converting.\n");
  expand_branch ();
  if (cuc_debug >= 6) print_cuc_insns ("AFTER_EXP_BRANCH", 0);
 
  remove_dslots ();
  if (cuc_debug >= 6) print_cuc_insns ("NO_DELAY_SLOTS", 0);
 
  if (config.cuc.calling_convention) {
    detect_locals ();
    if (cuc_debug >= 7) print_cuc_insns ("AFTER_LOCALS", 0);
  }
  expand_memory ();
  if (cuc_debug >= 3) print_cuc_insns ("AFTER_EXP_MEM", 0);
 
  expand_signed ();
  if (cuc_debug >= 3) print_cuc_insns ("AFTER_EXP_SIG", 0);
 
  expand_calls ();
  if (cuc_debug >= 3) print_cuc_insns ("AFTER_EXP_CALLS", 0);
 
  return 0;
}

Line No.	Rev	Author	Line
1	879	markom	`/* load.c -- OpenRISC Custom Unit Compiler, instruction loading and converting`
2			`* Copyright (C) 2002 Marko Mlinar, markom@opencores.org`
3			`*`
4			`* This file is part of OpenRISC 1000 Architectural Simulator.`
5			`*`
6			`* This program is free software; you can redistribute it and/or modify`
7			`* it under the terms of the GNU General Public License as published by`
8			`* the Free Software Foundation; either version 2 of the License, or`
9			`* (at your option) any later version.`
10			`*`
11			`* This program is distributed in the hope that it will be useful,`
12			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
13			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
14			`* GNU General Public License for more details.`
15			`*`
16			`* You should have received a copy of the GNU General Public License`
17			`* along with this program; if not, write to the Free Software`
18			`* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */`
19
20			`#include <stdio.h>`
21			`#include <stdlib.h>`
22			`#include <stdarg.h>`
23			`#include <assert.h>`
24	1308	phoenix	`#include <string.h>`
25
26	1350	nogj	`#include "config.h"`
27
28			`#ifdef HAVE_INTTYPES_H`
29			`#include <inttypes.h>`
30			`#endif`
31
32			`#include "port.h"`
33			`#include "arch.h"`
34	1308	phoenix	`#include "abstract.h"`
35	897	markom	`#include "sim-config.h"`
36	879	markom	`#include "cuc.h"`
37			`#include "opcode/or32.h"`
38			`#include "insn.h"`
39
40			`static const cuc_conv conv[] = {`
41			`{"l.add", II_ADD}, {"l.addi", II_ADD},`
42	898	markom	`{"l.movhi", II_OR},`
43	879	markom	`{"l.sub", II_SUB}, {"l.subi", II_SUB},`
44			`{"l.and", II_AND}, {"l.andi", II_AND},`
45			`{"l.xor", II_XOR}, {"l.xori", II_XOR},`
46			`{"l.or", II_OR }, {"l.ori", II_OR},`
47			`{"l.mul", II_MUL}, {"l.muli", II_MUL},`
48
49			`{"l.sra", II_SRA}, {"l.srai", II_SRA},`
50			`{"l.srl", II_SRL}, {"l.srli", II_SRL},`
51			`{"l.sll", II_SLL}, {"l.slli", II_SLL},`
52
53			`{"l.lbz",II_LB \| II_MEM}, {"l.lbs", II_LB \| II_MEM \| II_SIGNED},`
54			`{"l.lhz",II_LH \| II_MEM}, {"l.lhs", II_LH \| II_MEM \| II_SIGNED},`
55			`{"l.lwz",II_LW \| II_MEM}, {"l.lws", II_LW \| II_MEM \| II_SIGNED},`
56			`{"l.sb", II_SB \| II_MEM}, {"l.sh", II_SH \| II_MEM}, {"l.sw", II_SW \| II_MEM},`
57			`{"l.sfeq", II_SFEQ }, {"l.sfeqi", II_SFEQ},`
58			`{"l.sfne", II_SFNE }, {"l.sfnei", II_SFNE},`
59			`{"l.sflts", II_SFLT \| II_SIGNED}, {"l.sfltis", II_SFLT \| II_SIGNED},`
60			`{"l.sfltu", II_SFLT}, {"l.sfltiu", II_SFLT},`
61			`{"l.sfgts", II_SFGT \| II_SIGNED}, {"l.sfgtis", II_SFGT \| II_SIGNED},`
62			`{"l.sfgtu", II_SFGT}, {"l.sfgtiu", II_SFGT},`
63			`{"l.sfges", II_SFGE \| II_SIGNED}, {"l.sfgeis", II_SFGE \| II_SIGNED},`
64			`{"l.sfgeu", II_SFGE}, {"l.sfgeiu", II_SFGE},`
65			`{"l.sfles", II_SFLE \| II_SIGNED}, {"l.sfleis", II_SFLE \| II_SIGNED},`
66			`{"l.sfleu", II_SFLE}, {"l.sfleiu", II_SFLE},`
67			`{"l.j", II_BF },`
68			`{"l.bf", II_BF },`
69	906	markom	`{"l.jal", II_CALL },`
70	879	markom	`{"l.nop", II_NOP }`
71			`};`
72
73			`/* Instructions from function */`
74			`cuc_insn insn[MAX_INSNS];`
75			`int num_insn;`
76			`int reloc[MAX_INSNS];`
77
78			`/* Prints out instructions */`
79			`void print_cuc_insns (char *s, int verbose)`
80			`{`
81	997	markom	`PRINTF ("**************** %s ****************\n", s);`
82	1062	markom	`print_insns (0, insn, num_insn,verbose);`
83	997	markom	`PRINTF ("\n\n");`
84	879	markom	`}`
85
86			`void xchg_insn (int i, int j)`
87			`{`
88			`cuc_insn t;`
89			`t = insn[i];`
90			`insn[i] = insn[j];`
91			`insn[j] = t;`
92			`}`
93
94	905	markom	`/* Negates conditional instruction */`
95			`void negate_conditional (cuc_insn *ii)`
96			`{`
97			`assert (ii->type & IT_COND);`
98
99			`if (ii->index == II_SFEQ) change_insn_type (ii, II_SFNE);`
100			`else if (ii->index == II_SFNE) change_insn_type (ii, II_SFEQ);`
101			`else if (ii->index == II_SFLT) change_insn_type (ii, II_SFGE);`
102			`else if (ii->index == II_SFGT) change_insn_type (ii, II_SFLE);`
103			`else if (ii->index == II_SFLE) change_insn_type (ii, II_SFGT);`
104			`else if (ii->index == II_SFGE) change_insn_type (ii, II_SFLT);`
105			`else assert (0);`
106			`}`
107
108	879	markom	`/* Remove delay slots */`
109			`void remove_dslots ()`
110			`{`
111			`int i;`
112			`int in_delay = 0;`
113			`for (i = 0; i < num_insn; i++) {`
114			`if (in_delay) insn[i].type \|= IT_INDELAY;`
115			`in_delay = 0;`
116			`if (insn[i].type & IT_BRANCH) in_delay = 1;`
117			`if (insn[i].type & IT_INDELAY) {`
118	1043	markom	`cuc_insn *ii;`
119			`cuc_insn *bi;`
120			`assert (i >= 2);`
121			`ii = &insn[i - 2];`
122			`bi = &insn[i - 1];`
123	879	markom	`/* delay slot should not be a branch target! */`
124			`assert ((insn[i].type & IT_BBSTART) == 0);`
125	1043	markom	`assert ((bi->type & IT_INDELAY) == 0);`
126	879	markom	`insn[i].type &= ~IT_INDELAY; /* no more in delay slot */`
127	1043	markom
128			`/* Get the value we need before the actual jump */`
129			`if (bi->opt[1] & OPT_REGISTER && bi->op[1] >= 0) {`
130			`int r = bi->op[1];`
131			`assert (ii->index == II_NOP);`
132			`change_insn_type (ii, II_ADD);`
133			`ii->type = IT_COND;`
134			`ii->dep = NULL;`
135			`ii->op[0] = r; ii->opt[0] = OPT_REGISTER \| OPT_DEST;`
136			`ii->op[1] = r; ii->opt[1] = OPT_REGISTER;`
137			`ii->op[2] = 0; ii->opt[2] = OPT_CONST;`
138			`ii->opt[3] = OPT_NONE;`
139			`bi->op[1] = i - 2; bi->opt[1] = OPT_REF;`
140			`}`
141			`xchg_insn (i, i - 1);`
142	879	markom	`}`
143			`}`
144			`assert (in_delay == 0);`
145			`}`
146
147			`/* Convert local variables (uses stack frame -- r1) to internal values */`
148			`void detect_locals ()`
149			`{`
150	1308	phoenix	`int stack[CUC_MAX_STACK];`
151	879	markom	`int i, can_remove_stack = 1;`
152			`int real_stack_size = 0;`
153
154	1308	phoenix	`for (i = 0; i < CUC_MAX_STACK; i++) stack[i] = -1;`
155	879	markom
156			`for (i = 0; i < num_insn; i++) {`
157			`/* sw off (r1),rx */`
158			`if (insn[i].index == II_SW`
159			`&& (insn[i].opt[0] & OPT_CONST)`
160			`&& insn[i].op[1] == 1 && (insn[i].opt[1] & OPT_REGISTER)) {`
161
162	1308	phoenix	`if (insn[i].op[0] < CUC_MAX_STACK/* && insn[i].op[1] >= 4/) { / Convert to normal move */`
163	879	markom	`stack[insn[i].op[0]] = i;`
164			`insn[i].type &= IT_INDELAY \| IT_BBSTART;`
165			`change_insn_type (&insn[i], II_ADD);`
166			`insn[i].op[0] = -1; insn[i].opt[0] = OPT_REGISTER \| OPT_DEST;`
167			`insn[i].op[1] = insn[i].op[2]; insn[i].opt[1] = insn[i].opt[2];`
168			`insn[i].op[2] = 0; insn[i].opt[2] = OPT_CONST;`
169			`} else can_remove_stack = 0;`
170			`/* lw rx,off (r1) */`
171			`} else if (insn[i].index == II_LW`
172			`&& (insn[i].opt[1] & OPT_CONST)`
173			`&& insn[i].op[2] == 1 && (insn[i].opt[2] & OPT_REGISTER)) {`
174
175	1308	phoenix	`if (insn[i].op[1] < CUC_MAX_STACK && stack[insn[i].op[1]] >= 0) { /* Convert to normal move */`
176	879	markom	`insn[i].type &= IT_INDELAY \| IT_BBSTART;`
177			`change_insn_type (&insn[i], II_ADD);`
178			`insn[i].op[1] = stack[insn[i].op[1]]; insn[i].opt[1] = OPT_REF;`
179			`insn[i].op[2] = 0; insn[i].opt[2] = OPT_CONST;`
180			`} else can_remove_stack = 0;`
181			`/* Check for defined stack size */`
182			`} else if (insn[i].index == II_ADD && !real_stack_size`
183			`&& (insn[i].opt[0] & OPT_REGISTER) && insn[i].op[0] == 1`
184			`&& (insn[i].opt[1] & OPT_REGISTER) && insn[i].op[1] == 1`
185			`&& (insn[i].opt[2] & OPT_CONST)) {`
186			`real_stack_size = -insn[i].op[2];`
187			`}`
188			`}`
189	883	markom	`//assert (can_remove_stack); /* TODO */`
190	879	markom	`}`
191
192			`/* Disassemble one instruction from insn index and generate parameters */`
193			`const char build_insn (unsigned long data, cuc_insn insn)`
194			`{`
195			`const char *name;`
196			`char *s;`
197			`extern char *disassembled;`
198			`int index = insn_decode (data);`
199			`struct or32_opcode const *opcode;`
200			`int i, argc = 0;`
201
202			`insn->insn = data;`
203			`insn->index = -1;`
204			`insn->type = 0;`
205			`name = insn_name (index);`
206			`insn->index = index;`
207			`disassemble_index (data, index);`
208			`strcpy (insn->disasm, disassembled);`
209			`insn->dep = NULL;`
210			`for (i = 0; i < MAX_OPERANDS; i++) insn->opt[i] = OPT_NONE;`
211
212			`if (index < 0) {`
213	1308	phoenix	`fprintf (stderr, "Invalid opcode 0x%08lx!\n", data);`
214	879	markom	`exit (1);`
215			`}`
216			`opcode = &or32_opcodes[index];`
217
218			`for (s = opcode->args; *s != '\0'; ++s) {`
219			`switch (*s) {`
220			`case '\0': return name;`
221			`case 'r':`
222			`insn->opt[argc] = OPT_REGISTER \| (argc ? 0 : OPT_DEST);`
223			`insn->op[argc++] = or32_extract(*++s, opcode->encoding, data);`
224			`break;`
225
226			`default:`
227			`if (strchr (opcode->encoding, *s)) {`
228			`unsigned long imm = or32_extract (*s, opcode->encoding, data);`
229			`imm = extend_imm(imm, *s);`
230			`insn->opt[argc] = OPT_CONST;`
231			`insn->op[argc++] = imm;`
232			`}`
233			`}`
234			`}`
235			`return name;`
236			`}`
237
238	1043	markom	`/* inserts nop before branch */`
239			`void expand_branch ()`
240			`{`
241			`int i, j, num_bra = 0, d;`
242			`for (i = 0; i < num_insn; i++) if (insn[i].type & IT_BRANCH) num_bra++;`
243
244	1062	markom	`d = num_insn + 2 * num_bra;`
245	1043	markom	`assert (d < MAX_INSNS);`
246
247	1061	markom	`/* Add nop before branch */`
248	1043	markom	`for (i = num_insn - 1; i >= 0; i--) if (insn[i].type & IT_BRANCH) {`
249	1062	markom	`insn[--d] = insn[i]; // for delay slot (later)`
250			`if (insn[d].opt[1] & OPT_REGISTER) {`
251			`assert (insn[d].op[1] == FLAG_REG);`
252			`insn[d].op[1] = i; insn[d].opt[1] = OPT_REF;`
253			`}`
254			`insn[--d] = insn[i]; // for branch`
255			`change_insn_type (&insn[d], II_NOP);`
256			`insn[--d] = insn[i]; // save flag & negation of conditional, if required`
257			`change_insn_type (&insn[d], II_CMOV);`
258			`insn[d].op[0] = -1; insn[d].opt[0] = OPT_REGISTER \| OPT_DEST;`
259			`insn[d].op[1] = insn[d].type & IT_FLAG1 ? 0 : 1; insn[d].opt[1] = OPT_CONST;`
260			`insn[d].op[2] = insn[d].type & IT_FLAG1 ? 1 : 0; insn[d].opt[2] = OPT_CONST;`
261			`insn[d].op[3] = FLAG_REG; insn[d].opt[3] = OPT_REGISTER;`
262			`insn[d].type = IT_COND;`
263			`if (insn[d].type)`
264	1043	markom	`reloc[i] = d;`
265			`} else {`
266			`insn[--d] = insn[i];`
267			`reloc[i] = d;`
268			`}`
269	1062	markom	`num_insn += 2 * num_bra;`
270	1043	markom	`for (i = 0; i < num_insn; i++)`
271			`for (j = 0; j < MAX_OPERANDS; j++)`
272			`if (insn[i].opt[j] & OPT_REF \|\| insn[i].opt[j] & OPT_JUMP)`
273			`insn[i].op[j] = reloc[insn[i].op[j]];`
274			`}`
275
276	879	markom	`/* expands immediate memory instructions to two */`
277			`void expand_memory ()`
278			`{`
279			`int i, j, num_mem = 0, d;`
280			`for (i = 0; i < num_insn; i++) if (insn[i].type & IT_MEMORY) num_mem++;`
281
282			`d = num_insn + num_mem;`
283			`assert (d < MAX_INSNS);`
284
285			`/* Split memory commands */`
286			`for (i = num_insn - 1; i >= 0; i--) if (insn[i].type & IT_MEMORY) {`
287			`insn[--d] = insn[i];`
288			`insn[--d] = insn[i];`
289			`reloc[i] = d;`
290			`switch (insn[d].index) {`
291			`case II_SW:`
292			`case II_SH:`
293			`case II_SB:`
294	1060	markom	`insn[d + 1].op[1] = d; insn[d + 1].opt[1] = OPT_REF; /* sw rx,(t($-1)) */`
295			`insn[d + 1].op[0] = insn[i].op[2]; insn[d + 1].opt[0] = insn[d + 1].opt[2];`
296			`insn[d + 1].opt[2] = OPT_NONE;`
297			`insn[d + 1].type &= ~IT_BBSTART;`
298	1061	markom	`insn[d].op[2] = insn[d].op[0]; insn[d].opt[2] = insn[d].opt[0];`
299	879	markom	`insn[d].op[0] = -1; insn[d].opt[0] = OPT_REGISTER \| OPT_DEST; /* add rd, ra, rb */`
300			`insn[d].opt[3] = OPT_NONE;`
301			`insn[d].type &= IT_INDELAY \| IT_BBSTART;`
302			`insn[d].type \|= IT_MEMADD;`
303			`change_insn_type (&insn[d], II_ADD);`
304			`break;`
305			`case II_LW:`
306			`case II_LH:`
307			`case II_LB:`
308			`insn[d].op[0] = -1; insn[d].opt[0] = OPT_REGISTER \| OPT_DEST; /* add rd, ra, rb */`
309			`insn[d].type &= IT_INDELAY \| IT_BBSTART;`
310			`insn[d].type \|= IT_MEMADD;`
311			`change_insn_type (&insn[d], II_ADD);`
312			`insn[d + 1].op[1] = d; insn[d + 1].opt[1] = OPT_REF; /* lw (t($-1)),rx */`
313			`insn[d + 1].opt[2] = OPT_NONE;`
314			`insn[d + 1].opt[3] = OPT_NONE;`
315			`insn[d + 1].type &= ~IT_BBSTART;`
316			`break;`
317			`default: fprintf (stderr, "%4i, %4i: %s\n", i, d, cuc_insn_name (&insn[d]));`
318			`assert (0);`
319			`}`
320			`} else {`
321			`insn[--d] = insn[i];`
322			`reloc[i] = d;`
323			`}`
324			`num_insn += num_mem;`
325			`for (i = 0; i < num_insn; i++) if (!(insn[i].type & IT_MEMORY))`
326			`for (j = 0; j < MAX_OPERANDS; j++)`
327			`if (insn[i].opt[j] & OPT_REF \|\| insn[i].opt[j] & OPT_JUMP)`
328			`insn[i].op[j] = reloc[insn[i].op[j]];`
329			`}`
330
331			`/* expands signed comparisons to three instructions */`
332			`void expand_signed ()`
333			`{`
334			`int i, j, num_sig = 0, d;`
335	897	markom	`for (i = 0; i < num_insn; i++)`
336			`if (insn[i].type & IT_SIGNED && !(insn[i].type & IT_MEMORY)) num_sig++;`
337	879	markom
338			`d = num_insn + num_sig * 2;`
339			`assert (d < MAX_INSNS);`
340
341			`/* Split signed instructions */`
342	897	markom	`for (i = num_insn - 1; i >= 0; i--)`
343	879	markom	`/* We will expand signed memory later */`
344	897	markom	`if (insn[i].type & IT_SIGNED && !(insn[i].type & IT_MEMORY)) {`
345			`insn[--d] = insn[i];`
346			`insn[d].op[1] = d - 2; insn[d].opt[1] = OPT_REF;`
347			`insn[d].op[2] = d - 1; insn[d].opt[2] = OPT_REF;`
348	879	markom
349	897	markom	`insn[--d] = insn[i];`
350			`change_insn_type (&insn[d], II_ADD);`
351			`insn[d].type = 0;`
352			`insn[d].op[0] = -1; insn[d].opt[0] = OPT_REGISTER \| OPT_DEST;`
353			`insn[d].op[1] = insn[d].op[2]; insn[d].opt[1] = insn[d].opt[2];`
354	905	markom	`insn[d].op[2] = 0x80000000; insn[d].opt[2] = OPT_CONST;`
355	897	markom	`insn[d].opt[3] = OPT_NONE;`
356	879	markom
357	897	markom	`insn[--d] = insn[i];`
358			`change_insn_type (&insn[d], II_ADD);`
359			`insn[d].type = 0;`
360			`insn[d].op[0] = -1; insn[d].opt[0] = OPT_REGISTER \| OPT_DEST;`
361			`insn[d].op[1] = insn[d].op[1]; insn[d].opt[1] = insn[d].opt[1];`
362	905	markom	`insn[d].op[2] = 0x80000000; insn[d].opt[2] = OPT_CONST;`
363	897	markom	`insn[d].opt[3] = OPT_NONE;`
364	879	markom
365	897	markom	`reloc[i] = d;`
366			`} else {`
367			`insn[--d] = insn[i];`
368			`reloc[i] = d;`
369			`}`
370	879	markom	`num_insn += num_sig * 2;`
371			`for (i = 0; i < num_insn; i++) if (insn[i].type & IT_MEMORY \|\| !(insn[i].type & IT_SIGNED)) {`
372			`for (j = 0; j < MAX_OPERANDS; j++)`
373			`if (insn[i].opt[j] & OPT_REF \|\| insn[i].opt[j] & OPT_JUMP)`
374			`insn[i].op[j] = reloc[insn[i].op[j]];`
375			`} else insn[i].type &= ~IT_SIGNED;`
376			`}`
377
378	906	markom	`/* expands calls to 7 instructions */`
379			`void expand_calls ()`
380			`{`
381			`int i, j, num_call = 0, d;`
382			`for (i = 0; i < num_insn; i++)`
383			`if (insn[i].index == II_CALL) num_call++;`
384
385			`d = num_insn + num_call * 6; /* 6 parameters */`
386			`assert (d < MAX_INSNS);`
387
388			`/* Split call instructions */`
389			`for (i = num_insn - 1; i >= 0; i--)`
390			`/* We will expand signed memory later */`
391			`if (insn[i].index == II_CALL) {`
392			`insn[--d] = insn[i];`
393			`insn[d].op[0] = insn[d].op[1]; insn[d].opt[0] = OPT_CONST;`
394			`insn[d].opt[1] = OPT_NONE;`
395			`insn[d].type \|= IT_VOLATILE;`
396
397			`for (j = 0; j < 6; j++) {`
398			`insn[--d] = insn[i];`
399			`change_insn_type (&insn[d], II_ADD);`
400			`insn[d].type = IT_VOLATILE;`
401			`insn[d].op[0] = 3 + j; insn[d].opt[0] = OPT_REGISTER \| OPT_DEST;`
402			`insn[d].op[1] = 3 + j; insn[d].opt[1] = OPT_REGISTER;`
403			`insn[d].op[2] = 0x80000000; insn[d].opt[2] = OPT_CONST;`
404			`insn[d].opt[3] = OPT_NONE;`
405			`}`
406
407			`reloc[i] = d;`
408			`} else {`
409			`insn[--d] = insn[i];`
410			`reloc[i] = d;`
411			`}`
412			`num_insn += num_call * 6;`
413			`for (i = 0; i < num_insn; i++)`
414			`for (j = 0; j < MAX_OPERANDS; j++)`
415			`if (insn[i].opt[j] & OPT_REF \|\| insn[i].opt[j] & OPT_JUMP)`
416			`insn[i].op[j] = reloc[insn[i].op[j]];`
417			`}`
418
419	897	markom	`/* Loads function from file into global array insn.`
420			`Function returns nonzero if function cannot be converted. */`
421			`int cuc_load (char *in_fn)`
422	879	markom	`{`
423	1308	phoenix	`int i, j;`
424	879	markom	`FILE *fi;`
425			`int func_return = 0;`
426			`num_insn = 0;`
427
428			`log ("Loading filename %s\n", in_fn);`
429			`if ((fi = fopen (in_fn, "rt")) == NULL) {`
430			`fprintf (stderr, "Cannot open '%s'\n", in_fn);`
431			`exit (1);`
432			`}`
433			`/* Read in the function and decode the instructions */`
434			`for (i = 0;; i++) {`
435			`unsigned long data;`
436			`const char *name;`
437
438	1308	phoenix	`if (fscanf (fi, "%08lx\n", &data) != 1) break;`
439	879	markom
440			`/* build params */`
441			`name = build_insn (data, &insn[i]);`
442			`if (func_return) func_return++;`
443	997	markom	`//PRINTF ("%s\n", name);`
444	879	markom
445			`if (or32_opcodes[insn[i].index].flags & OR32_IF_DELAY) {`
446			`int f;`
447			`if (strcmp (name, "l.bnf") == 0) f = 1;`
448			`else if (strcmp (name, "l.bf") == 0) f = 0;`
449			`else if (strcmp (name, "l.j") == 0) {`
450			`f = -1;`
451			`} else if (strcmp (name, "l.jr") == 0 && func_return == 0) {`
452			`func_return = 1;`
453			`change_insn_type (&insn[i], II_NOP);`
454			`continue;`
455			`} else {`
456	897	markom	`cucdebug (1, "Instruction #%i: \"%s\" not supported.\n", i, name);`
457			`log ("Instruction #%i: \"%s\" not supported.\n", i, name);`
458			`return 1;`
459	879	markom	`}`
460			`if (f < 0) { /* l.j */`
461			`/* repair params */`
462			`change_insn_type (&insn[i], II_BF);`
463			`insn[i].op[0] = i + insn[i].op[0]; insn[i].opt[0] = OPT_JUMP;`
464			`insn[i].op[1] = 1; insn[i].opt[1] = OPT_CONST;`
465			`insn[i].type \|= IT_BRANCH \| IT_VOLATILE;`
466			`} else {`
467			`change_insn_type (&insn[i], II_BF);`
468			`insn[i].op[0] = i + insn[i].op[0]; insn[i].opt[0] = OPT_JUMP;`
469			`insn[i].op[1] = FLAG_REG; insn[i].opt[1] = OPT_REGISTER;`
470			`insn[i].type \|= IT_BRANCH \| IT_VOLATILE;`
471	1062	markom	`if (f) insn[i].type \|= IT_FLAG1;`
472	879	markom	`}`
473			`} else {`
474			`insn[i].index = -1;`
475			`for (j = 0; j < sizeof (conv) / sizeof (cuc_conv); j++)`
476			`if (strcmp (conv[j].from, name) == 0) {`
477			`if (conv[j].to & II_SIGNED) insn[i].type \|= IT_SIGNED;`
478			`if (conv[j].to & II_MEM) insn[i].type \|= IT_MEMORY \| IT_VOLATILE;`
479			`change_insn_type (&insn[i], conv[j].to & II_MASK);`
480			`break;`
481			`}`
482	898	markom	`if (strcmp (name, "l.movhi") == 0) {`
483			`insn[i].op[1] <<= 16;`
484			`insn[i].op[2] = 0;`
485			`insn[i].opt[2] = OPT_CONST;`
486			`}`
487	1062	markom	`if (insn[i].index == II_SFEQ \|\| insn[i].index == II_SFNE`
488			`\|\| insn[i].index == II_SFLE \|\| insn[i].index == II_SFGT`
489			`\|\| insn[i].index == II_SFGE \|\| insn[i].index == II_SFLT) {`
490			`/* repair params */`
491			`insn[i].op[2] = insn[i].op[1]; insn[i].opt[2] = insn[i].opt[1] & ~OPT_DEST;`
492			`insn[i].op[1] = insn[i].op[0]; insn[i].opt[1] = insn[i].opt[0] & ~OPT_DEST;`
493			`insn[i].op[0] = FLAG_REG; insn[i].opt[0] = OPT_DEST \| OPT_REGISTER;`
494			`insn[i].opt[3] = OPT_NONE;`
495			`insn[i].type \|= IT_COND;`
496			`}`
497	897	markom	`if (insn[i].index < 0 \|\| insn[i].index == II_NOP && insn[i].op[0] != 0) {`
498			`cucdebug (1, "Instruction #%i: \"%s\" not supported (2).\n", i, name);`
499			`log ("Instruction #%i: \"%s\" not supported (2).\n", i, name);`
500			`return 1;`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [tags/] [nog_patch_70/] [or1ksim/] [cuc/] [load.c] - Blame information for rev 1765