Subversion Repositories openrisc

/* Subroutines for insn-output.c for GNU compiler.  OpenRISC 1000 version.

   Copyright (C) 1987, 1992, 1997, 1999, 2000, 2001, 2002, 2003, 2004,

   2005  Free Software Foundation, Inc

   Contributed by Damjan Lampret <damjanl@bsemi.com> in 1999.

   Major optimizations by Matjaz Breskvar <matjazb@bsemi.com> in 2005.

This file is part of GNU CC.

GNU CC 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 1, or (at your option)

any later version.

GNU CC 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 GNU CC; see the file COPYING.  If not, write to

the Free Software Foundation, 59 Temple Place - Suite 330,

Boston, MA 02111-1307, USA.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "rtl.h"

#include "tree.h"

#include "obstack.h"

#include "regs.h"

#include "hard-reg-set.h"

#include "real.h"

#include "insn-config.h"

#include "conditions.h"

#include "output.h"

#include "insn-attr.h"

#include "flags.h"

#include "reload.h"

#include "function.h"

#include "expr.h"

#include "optabs.h"

#include "toplev.h"

#include "recog.h"

#include "ggc.h"

#include "except.h"

#include "c-pragma.h"

#include "integrate.h"

#include "tm_p.h"

#include "target.h"

#include "target-def.h"

#include "debug.h"

#include "langhooks.h"

/* Set thist to nonzero if you want l.nop instruction in delay slot

   of l.jr instruction in epilogue. */

#define  NOP_DELAY_SLOT_FILL 0

/* This is the pseudo register number that holds the comparison flags */

#define FLAGS_REG 32

/* Save information from a "cmpxx" operation until the branch or scc is

   emitted.  */

rtx or32_compare_op0, or32_compare_op1;

/* used in function prologue/epilogue generation */

extern int leaf_function;

rtx or32_expand_compare (enum rtx_code code, rtx op0, rtx op1);

void output_ascii_pseudo_op (FILE *, const unsigned char *, int);

/* Local function prototypes */

static bool or32_save_reg_p (int regno);

HOST_WIDE_INT or32_compute_frame_size (HOST_WIDE_INT size);

static rtx emit_frame_insn (rtx insn);

static rtx indexed_memory (rtx base, HOST_WIDE_INT disp);

static int or32_emit_int_cmove (rtx dest, rtx op, rtx true_cond,

                                rtx false_cond);

static void or32_output_function_prologue (FILE * file, HOST_WIDE_INT vars);

#undef TARGET_ASM_FUNCTION_PROLOGUE

#define TARGET_ASM_FUNCTION_PROLOGUE or32_output_function_prologue

static void or32_output_function_epilogue (FILE * file, HOST_WIDE_INT vars);

#undef TARGET_ASM_FUNCTION_EPILOGUE

#define TARGET_ASM_FUNCTION_EPILOGUE or32_output_function_epilogue

static bool or32_function_ok_for_sibcall (tree decl, tree exp);

#undef TARGET_FUNCTION_OK_FOR_SIBCALL

#define TARGET_FUNCTION_OK_FOR_SIBCALL or32_function_ok_for_sibcall

static bool or32_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode, tree, bool);

#undef TARGET_PASS_BY_REFERENCE

#define TARGET_PASS_BY_REFERENCE or32_pass_by_reference

static int or32_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode, tree, bool);

#undef TARGET_ARG_PARTIAL_BYTES

#define TARGET_ARG_PARTIAL_BYTES or32_arg_partial_bytes

/* Initialize the GCC target structure.  */

/* Define this macro if an argument declared as `char' or `short' in a

   prototype should actually be passed as an `int'.  In addition to

   avoiding errors in certain cases of mismatch, it also makes for

   better code on certain machines. */

#undef TARGET_PROMOTE_PROTOTYPES

#define TARGET_PROMOTE_PROTOTYPES hook_bool_tree_true

/* Define this if function arguments should also be promoted using the above

   procedure.  */

#undef TARGET_PROMOTE_FUNCTION_ARGS

#define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_tree_true

/* Likewise, if the function return value is promoted.  */

#undef TARGET_PROMOTE_FUNCTION_RETURN

#define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_tree_true

struct gcc_target targetm = TARGET_INITIALIZER;

/* Stack layout we use for pushing and poping saved registers */

struct or32_frame_info

{

  bool save_lr_p;

  int lr_save_offset;

  bool save_fp_p;

  int fp_save_offset;

  int gpr_size;

  int gpr_offset;

  int total_size;

  int vars_size;

  int args_size;

  HOST_WIDE_INT mask;

};

static struct or32_frame_info frame_info;

/* Add a REG_MAYBE_DEAD note to the insn.  */

static void

or32_maybe_dead (rtx insn)

{

  REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_MAYBE_DEAD,

                                        const0_rtx, REG_NOTES (insn));

}

int

or32_print_operand_punct_valid_p (int code)

{

  switch (code)

    {

    case '(':                   /* idea taken from sparc; output nop for %( if

                                   not optimizing or the slot is not filled. */

    case '%':

      return 1;

    }

  return 0;

}

void

or32_print_operand_address (FILE * file, register rtx addr)

{

  register rtx reg1, reg2, breg, ireg;

  rtx offset;

  switch (GET_CODE (addr))

    {

    case MEM:

      if (GET_CODE (XEXP (addr, 0)) == REG)

        fprintf (file, "%s", reg_names[REGNO (addr)]);

      else

        abort ();

      break;

    case REG:

      fprintf (file, "0(%s)", reg_names[REGNO (addr)]);

      break;

    case PLUS:

      reg1 = 0;

      reg2 = 0;

      ireg = 0;

      breg = 0;

      offset = 0;

      if (GET_CODE (XEXP (addr, 0)) == REG)

        {

          offset = XEXP (addr, 1);

          addr = XEXP (addr, 0);

        }

      else if (GET_CODE (XEXP (addr, 1)) == REG)

        {

          offset = XEXP (addr, 0);

          addr = XEXP (addr, 1);

        }

      output_address (offset);

      fprintf (file, "(%s)", reg_names[REGNO (addr)]);

      break;

    default:

      /* fprintf(file, "{%d}", GET_CODE (addr)); */

      output_addr_const (file, addr);

    }

}

/* Calulcate and return stack size for current function.  */

static int

calculate_stack_size (int vars, int *lr_save_area,

                      int *fp_save_area, int *gpr_save_area, int *save_area)

{

  int regno;

  *gpr_save_area = 0;

  for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)

    {

      if (regs_ever_live[regno] && !call_used_regs[regno])

        *gpr_save_area += 4;

    }

  *lr_save_area = (!current_function_is_leaf

                   || regs_ever_live[LINK_REGNUM]) ? 4 : 0;

  *fp_save_area = frame_pointer_needed ? 4 : 0;

  *save_area = (OR32_ALIGN (current_function_outgoing_args_size, 4)

                + *lr_save_area + *fp_save_area);

  return

    (OR32_ALIGN (current_function_outgoing_args_size, 4)

     + *lr_save_area + *fp_save_area + *gpr_save_area + OR32_ALIGN (vars, 4));

}

/* Set up the stack and frame pointer (if desired) for the

   function.  */

static void

or32_output_function_prologue (FILE * file, HOST_WIDE_INT vars)

{

  int save_area;

  int gpr_save_area;

  int lr_save_area;

  int fp_save_area;

  int stack_size;

  int regno;

  if (TARGET_MASK_SCHED_LOGUE)

    return;

#if 0

  save_area = 0;

  for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)

    {

      if (regs_ever_live[regno] && !call_used_regs[regno])

        {

          save_area += 1;

        }

    }

  if (save_area != 0)

    fprintf (file, "\tl.nop \t0x%x\n", 0x100 + save_area);

  return;

#endif

  if (vars < 0)

    abort ();

  stack_size = calculate_stack_size

    (vars, &lr_save_area, &fp_save_area, &gpr_save_area, &save_area);

  fprintf (file,

           "\n\t# gpr_save_area %d vars %ld current_function_outgoing_args_size %d\n",

           gpr_save_area, vars, current_function_outgoing_args_size);

  if (stack_size >= 0x8000)

    {

      fprintf (file, "\tl.movhi   \tr%d,hi(%d)\n", GP_ARG_RETURN, stack_size);

      fprintf (file, "\tl.ori   \tr%d,r%d,lo(%d)\n", GP_ARG_RETURN,

               GP_ARG_RETURN, stack_size);

      fprintf (file, "\tl.sub   \tr%d,r%d,r%d\n", STACK_POINTER_REGNUM,

               STACK_POINTER_REGNUM, GP_ARG_RETURN);

    }

  else if (stack_size > 0)

    {

      fprintf (file, "\tl.addi   \tr%d,r%d,%d\n", STACK_POINTER_REGNUM,

               STACK_POINTER_REGNUM, -stack_size);

    }

  if (fp_save_area)

    {

      fprintf (file, "\tl.sw     \t%d(r%d),r%d\n",

               OR32_ALIGN (current_function_outgoing_args_size, 4)

               + lr_save_area, STACK_POINTER_REGNUM, FRAME_POINTER_REGNUM);

      if (stack_size >= 0x8000)

        fprintf (file, "\tl.add   \tr%d,r%d,r%d\n", FRAME_POINTER_REGNUM,

                 STACK_POINTER_REGNUM, GP_ARG_RETURN);

      else

        fprintf (file, "\tl.addi   \tr%d,r%d,%d\n", FRAME_POINTER_REGNUM,

                 STACK_POINTER_REGNUM, stack_size);

    }

  if (lr_save_area)

    {

      fprintf (file, "\tl.sw     \t%d(r%d),r%d\n",

               OR32_ALIGN (current_function_outgoing_args_size, 4),

               STACK_POINTER_REGNUM, LINK_REGNUM);

    }

  save_area = (OR32_ALIGN (current_function_outgoing_args_size, 4)

               + lr_save_area + fp_save_area);

  for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)

    {

      if (regs_ever_live[regno] && !call_used_regs[regno])

        {

          fprintf (file, "\tl.sw    \t%d(r%d),r%d\n", save_area,

                   STACK_POINTER_REGNUM, regno);

          save_area += 4;

        }

    }

}

/* Do any necessary cleanup after a function to restore stack, frame,

   and regs.  */

static void

or32_output_function_epilogue (FILE * file, HOST_WIDE_INT vars)

{

  int save_area;

  int gpr_save_area;

  int lr_save_area;

  int fp_save_area;

  int stack_size;

  int regno;

  if (TARGET_MASK_SCHED_LOGUE)

    return;

#if 0

  save_area = 0;

  for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)

    {

      if (regs_ever_live[regno] && !call_used_regs[regno])

        {

          save_area += 1;

        }

    }

  fprintf (file, "\tl.nop \t0x%x\n", 0x200 + save_area);

  return;

#endif

  stack_size = calculate_stack_size

    (vars, &lr_save_area, &fp_save_area, &gpr_save_area, &save_area);

  if (lr_save_area)

    {

      fprintf (file, "\tl.lwz    \tr%d,%d(r%d)\n", LINK_REGNUM,

               OR32_ALIGN (current_function_outgoing_args_size, 4),

               STACK_POINTER_REGNUM);

    }

  if (fp_save_area)

    {

      fprintf (file, "\tl.lwz    \tr%d,%d(r%d)\n", FRAME_POINTER_REGNUM,

               OR32_ALIGN (current_function_outgoing_args_size, 4)

               + lr_save_area, STACK_POINTER_REGNUM);

    }

  save_area = (OR32_ALIGN (current_function_outgoing_args_size, 4)

               + lr_save_area + fp_save_area);

  for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)

    {

      if (regs_ever_live[regno] && !call_used_regs[regno])

        {

          fprintf (file, "\tl.lwz    \tr%d,%d(r%d)\n", regno, save_area,

                   STACK_POINTER_REGNUM);

          save_area += 4;

        }

    }

  if (stack_size >= 0x8000)

    {

      fprintf (file, "\tl.movhi   \tr3,hi(%d)\n", stack_size);

      fprintf (file, "\tl.ori   \tr3,r3,lo(%d)\n", stack_size);

      if (!TARGET_MASK_ALIGNED_JUMPS)

        fprintf (file, "\tl.jr  \tr%d\n", LINK_REGNUM);

      else

        fprintf (file, "\t.balignl 0x8,0x15000015,0x4;l.jr  \tr%d\n",

                 LINK_REGNUM);

      fprintf (file, "\tl.add   \tr%d,r%d,r3\n", STACK_POINTER_REGNUM,

               STACK_POINTER_REGNUM);

    }

  else if (stack_size > 0)

    {

      if (!TARGET_MASK_ALIGNED_JUMPS)

        fprintf (file, "\tl.jr  \tr%d\n", LINK_REGNUM);

      else

        fprintf (file, "\t.balignl 0x8,0x15000015,0x4;l.jr  \tr%d\n",

                 LINK_REGNUM);

      fprintf (file, "\tl.addi   \tr%d,r%d,%d\n", STACK_POINTER_REGNUM,

               STACK_POINTER_REGNUM, stack_size);

    }

  else

    {

      if (!TARGET_MASK_ALIGNED_JUMPS)

        fprintf (file, "\tl.jr  \tr%d\n", LINK_REGNUM);

      else

        fprintf (file, "\t.balignl 0x8,0x15000015,0x4;l.jr  \tr%d\n",

                 LINK_REGNUM);

      fprintf (file, "\tl.nop\n");

    }

#if 0

  fprintf (file, ".endproc _%s\n", get_function_name ());

#endif

}

/* Compuate full frame size and layout.  SIZE is the size of the

   functions local variables.  Store information in FRAME_INFO and

   return total size of stack frame.  */

HOST_WIDE_INT

or32_compute_frame_size (HOST_WIDE_INT size)

{

  HOST_WIDE_INT args_size;

  HOST_WIDE_INT vars_size;

  HOST_WIDE_INT stack_offset;

  int regno;

  args_size = current_function_outgoing_args_size;

  vars_size = OR32_ALIGN (size, 4);

  frame_info.args_size = args_size;

  frame_info.vars_size = vars_size;

  /* If the function has local variables, we're committed to

     allocating it anyway.  Otherwise reclaim it here.  */

  /* FIXME: Verify this.  Got if from the MIPS port.  */

  if (vars_size == 0 && current_function_is_leaf)

    args_size = 0;

  stack_offset = args_size;

  /* Save link register right after possible outgoing arguments.  */

  if (or32_save_reg_p (LINK_REGNUM))

    {

      frame_info.lr_save_offset = stack_offset;

      frame_info.save_lr_p = true;

      stack_offset = stack_offset + UNITS_PER_WORD;

    }

  else

    frame_info.save_lr_p = false;

  /* Save frame pointer right after possible link register.  */

  if (or32_save_reg_p (FRAME_POINTER_REGNUM))

    {

      frame_info.fp_save_offset = stack_offset;

      frame_info.save_fp_p = true;

      stack_offset = stack_offset + UNITS_PER_WORD;

    }

  else

    frame_info.save_fp_p = false;

  frame_info.gpr_size = 0;

  frame_info.mask = 0;

  frame_info.gpr_offset = stack_offset;

  for (regno = 0; regno <= LAST_INT_REG; regno++)

    {

      if (regno == LINK_REGNUM || regno == FRAME_POINTER_REGNUM)

        /* These has already been saved if so needed.  */

        continue;

      if (or32_save_reg_p (regno))

        {

          frame_info.gpr_size += UNITS_PER_WORD;

          frame_info.mask |= (1 << regno);

        }

    }

  frame_info.total_size = ((frame_info.save_fp_p ? UNITS_PER_WORD : 0)

                           + (frame_info.save_lr_p ? UNITS_PER_WORD : 0)

                           + args_size + frame_info.gpr_size + vars_size);

  return frame_info.total_size;

}

/* Return true if current function must save REGNO.  */

static bool

or32_save_reg_p (int regno)

{

  /* No need to save the faked cc0 register.  */

  if (regno == FLAGS_REG)

    return false;

  /* Check call-saved registers.  */

  if (regs_ever_live[regno] && !call_used_regs[regno])

    return true;

  /* We need to save the old frame pointer before setting up a new

     one.  */

  if (regno == FRAME_POINTER_REGNUM && frame_pointer_needed)

    return true;

  /* We need to save the incoming return address if it is ever clobbered

     within the function.  */

  if (regno == LINK_REGNUM && regs_ever_live[regno])

    return true;

  return false;

}

/* Emit a frame related insn.  Same as emit_insn, but sets

   RTX_FRAME_RELATED_P to one.  */

static rtx

emit_frame_insn (rtx insn)

{

  insn = emit_insn (insn);

  RTX_FRAME_RELATED_P (insn) = 1;

  return (insn);

}

static rtx

indexed_memory (rtx base, HOST_WIDE_INT disp)

{

  return gen_rtx_MEM (Pmode, gen_rtx_PLUS (Pmode, base, GEN_INT (disp)));

}

/* Called after register allocation to add any instructions needed for

   the prologue.  Using a prologue insn is favored compared to putting

   all of the instructions in output_function_prologue(), since it

   allows the scheduler to intermix instructions with the saves of the

   caller saved registers.  In some cases, it might be necessary to

   emit a barrier instruction as the last insn to prevent such

   scheduling.  */

void

or32_expand_prologue (void)

{

  int total_size = or32_compute_frame_size (get_frame_size ());

  rtx sp_rtx;

  rtx value_rtx;

  if (!total_size)

    /* No frame needed.  */

    return;

  sp_rtx = gen_rtx_REG (Pmode, STACK_POINTER_REGNUM);

  if (total_size > 32767)

    {

      value_rtx = gen_rtx_REG (Pmode, GP_ARG_RETURN);

      emit_frame_insn (gen_rtx_SET (Pmode, value_rtx, GEN_INT (total_size)));

    }

  else

    value_rtx = GEN_INT (total_size);

  /* Update the stack pointer to reflect frame size.  */

  emit_frame_insn

    (gen_rtx_SET (Pmode, stack_pointer_rtx,

                  gen_rtx_MINUS (Pmode, stack_pointer_rtx, value_rtx)));

  if (frame_info.save_fp_p)

    {

      emit_frame_insn

        (gen_rtx_SET (Pmode,

                      indexed_memory (stack_pointer_rtx,

                                      frame_info.fp_save_offset),

                      frame_pointer_rtx));

      emit_frame_insn

        (gen_rtx_SET (Pmode, frame_pointer_rtx,

                      gen_rtx_PLUS (Pmode, frame_pointer_rtx, value_rtx)));

    }

  if (frame_info.save_lr_p)

    {

      emit_frame_insn

        (gen_rtx_SET (Pmode,

                      indexed_memory (stack_pointer_rtx,

                                      frame_info.lr_save_offset),

                      gen_rtx_REG (Pmode, LINK_REGNUM)));

    }

  if (frame_info.gpr_size)

    {

      int offset = 0;

      int regno;

      for (regno = 0; regno <= LAST_INT_REG; regno++)

        {

          HOST_WIDE_INT disp = frame_info.gpr_offset + offset;

          if (!(frame_info.mask & (1 << regno)))

            continue;

          emit_frame_insn

            (gen_rtx_SET (Pmode,

                          indexed_memory (stack_pointer_rtx, disp),

                          gen_rtx_REG (Pmode, regno)));

          offset = offset + UNITS_PER_WORD;

        }

    }

}

/* Called after register allocation to add any instructions needed for

   the epilogue.  Using an epilogue insn is favored compared to

   putting all of the instructions in output_function_epilogue(),

   since it allows the scheduler to intermix instructions with the

   restores of the caller saved registers.  In some cases, it might be

   necessary to emit a barrier instruction as the first insn to

   prevent such scheduling.  */

void

or32_expand_epilogue (int sibcall)

{

  int total_size = or32_compute_frame_size (get_frame_size ());

  rtx value_rtx;

  if (total_size > 32767)

    {

      value_rtx = gen_rtx_REG (Pmode, 3);

      emit_insn (gen_rtx_SET (Pmode, value_rtx, GEN_INT (total_size)));

    }

  else

    value_rtx = GEN_INT (total_size);

  if (frame_info.save_lr_p)

    {

      or32_maybe_dead

        (emit_insn

         (gen_rtx_SET (Pmode, gen_rtx_REG (Pmode, LINK_REGNUM),

                       indexed_memory (stack_pointer_rtx,

                                       frame_info.lr_save_offset))));

    }

  if (frame_info.save_fp_p)

    {

      emit_insn

        (gen_rtx_SET (Pmode, gen_rtx_REG (Pmode, FRAME_POINTER_REGNUM),

                      indexed_memory (stack_pointer_rtx,

                                      frame_info.fp_save_offset)));

    }

  if (frame_info.gpr_size)

    {

      int offset = 0;

      int regno;

      for (regno = 0; regno <= LAST_INT_REG; regno++)

        {

          HOST_WIDE_INT disp = frame_info.gpr_offset + offset;

          if (!(frame_info.mask & (1 << regno)))

            continue;

          emit_insn

            (gen_rtx_SET (Pmode, gen_rtx_REG (Pmode, regno),

                          indexed_memory (stack_pointer_rtx, disp)));

          offset = offset + UNITS_PER_WORD;

        }

    }

  if (total_size)

    {

      emit_insn (gen_rtx_SET (Pmode, stack_pointer_rtx,

                              gen_rtx_PLUS (Pmode,

                                            stack_pointer_rtx, value_rtx)));

    }

  if (!sibcall)

    emit_jump_insn (gen_return_internal (gen_rtx_REG( Pmode, 9)));

}

void

or32_print_operand (FILE * file, rtx x, int code)

{

  if (code == 'r' && GET_CODE (x) == MEM && GET_CODE (XEXP (x, 0)) == REG)

    fprintf (file, "%s", reg_names[REGNO (XEXP (x, 0))]);

  else if (code == '(')

    {

      if (dbr_sequence_length ())

        fprintf (file, "\t# delay slot filled");

      else

        fprintf (file, "\n\tl.nop\t\t\t# nop delay slot");

    }

  else if (code == 'C')

    {

      switch (GET_CODE (x))

        {

        case EQ: