Subversion Repositories openrisc

/* Convert tree expression to rtl instructions, for GNU compiler.

/* Convert tree expression to rtl instructions, for GNU compiler.

   Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,

   Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,

   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007

   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007

   Free Software Foundation, Inc.

   Free Software Foundation, Inc.

This file is part of GCC.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under

GCC 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

the terms of the GNU General Public License as published by the Free

Software Foundation; either version 3, or (at your option) any later

Software Foundation; either version 3, or (at your option) any later

version.

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

for more details.

You should have received a copy of the GNU General Public License

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

<http://www.gnu.org/licenses/>.  */

#include "config.h"

#include "config.h"

#include "system.h"

#include "system.h"

#include "coretypes.h"

#include "coretypes.h"

#include "tm.h"

#include "tm.h"

#include "machmode.h"

#include "machmode.h"

#include "real.h"

#include "real.h"

#include "rtl.h"

#include "rtl.h"

#include "tree.h"

#include "tree.h"

#include "flags.h"

#include "flags.h"

#include "regs.h"

#include "regs.h"

#include "hard-reg-set.h"

#include "hard-reg-set.h"

#include "except.h"

#include "except.h"

#include "function.h"

#include "function.h"

#include "insn-config.h"

#include "insn-config.h"

#include "insn-attr.h"

#include "insn-attr.h"

/* Include expr.h after insn-config.h so we get HAVE_conditional_move.  */

/* Include expr.h after insn-config.h so we get HAVE_conditional_move.  */

#include "expr.h"

#include "expr.h"

#include "optabs.h"

#include "optabs.h"

#include "libfuncs.h"

#include "libfuncs.h"

#include "recog.h"

#include "recog.h"

#include "reload.h"

#include "reload.h"

#include "output.h"

#include "output.h"

#include "typeclass.h"

#include "typeclass.h"

#include "toplev.h"

#include "toplev.h"

#include "ggc.h"

#include "ggc.h"

#include "langhooks.h"

#include "langhooks.h"

#include "intl.h"

#include "intl.h"

#include "tm_p.h"

#include "tm_p.h"

#include "tree-iterator.h"

#include "tree-iterator.h"

#include "tree-pass.h"

#include "tree-pass.h"

#include "tree-flow.h"

#include "tree-flow.h"

#include "target.h"

#include "target.h"

#include "timevar.h"

#include "timevar.h"

/* Decide whether a function's arguments should be processed

/* Decide whether a function's arguments should be processed

   from first to last or from last to first.

   from first to last or from last to first.

   They should if the stack and args grow in opposite directions, but

   They should if the stack and args grow in opposite directions, but

   only if we have push insns.  */

   only if we have push insns.  */

#ifdef PUSH_ROUNDING

#ifdef PUSH_ROUNDING

#ifndef PUSH_ARGS_REVERSED

#ifndef PUSH_ARGS_REVERSED

#if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)

#if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)

#define PUSH_ARGS_REVERSED      /* If it's last to first.  */

#define PUSH_ARGS_REVERSED      /* If it's last to first.  */

#endif

#endif

#endif

#endif

#endif

#endif

#ifndef STACK_PUSH_CODE

#ifndef STACK_PUSH_CODE

#ifdef STACK_GROWS_DOWNWARD

#ifdef STACK_GROWS_DOWNWARD

#define STACK_PUSH_CODE PRE_DEC

#define STACK_PUSH_CODE PRE_DEC

#else

#else

#define STACK_PUSH_CODE PRE_INC

#define STACK_PUSH_CODE PRE_INC

#endif

#endif

#endif

#endif

/* If this is nonzero, we do not bother generating VOLATILE

/* If this is nonzero, we do not bother generating VOLATILE

   around volatile memory references, and we are willing to

   around volatile memory references, and we are willing to

   output indirect addresses.  If cse is to follow, we reject

   output indirect addresses.  If cse is to follow, we reject

   indirect addresses so a useful potential cse is generated;

   indirect addresses so a useful potential cse is generated;

   if it is used only once, instruction combination will produce

   if it is used only once, instruction combination will produce

   the same indirect address eventually.  */

   the same indirect address eventually.  */

int cse_not_expected;

int cse_not_expected;

/* This structure is used by move_by_pieces to describe the move to

/* This structure is used by move_by_pieces to describe the move to

   be performed.  */

   be performed.  */

struct move_by_pieces

struct move_by_pieces

{

{

  rtx to;

  rtx to;

  rtx to_addr;

  rtx to_addr;

  int autinc_to;

  int autinc_to;

  int explicit_inc_to;

  int explicit_inc_to;

  rtx from;

  rtx from;

  rtx from_addr;

  rtx from_addr;

  int autinc_from;

  int autinc_from;

  int explicit_inc_from;

  int explicit_inc_from;

  unsigned HOST_WIDE_INT len;

  unsigned HOST_WIDE_INT len;

  HOST_WIDE_INT offset;

  HOST_WIDE_INT offset;

  int reverse;

  int reverse;

};

};

/* This structure is used by store_by_pieces to describe the clear to

/* This structure is used by store_by_pieces to describe the clear to

   be performed.  */

   be performed.  */

struct store_by_pieces

struct store_by_pieces

{

{

  rtx to;

  rtx to;

  rtx to_addr;

  rtx to_addr;

  int autinc_to;

  int autinc_to;

  int explicit_inc_to;

  int explicit_inc_to;

  unsigned HOST_WIDE_INT len;

  unsigned HOST_WIDE_INT len;

  HOST_WIDE_INT offset;

  HOST_WIDE_INT offset;

  rtx (*constfun) (void *, HOST_WIDE_INT, enum machine_mode);

  rtx (*constfun) (void *, HOST_WIDE_INT, enum machine_mode);

  void *constfundata;

  void *constfundata;

  int reverse;

  int reverse;

};

};

static unsigned HOST_WIDE_INT move_by_pieces_ninsns (unsigned HOST_WIDE_INT,

static unsigned HOST_WIDE_INT move_by_pieces_ninsns (unsigned HOST_WIDE_INT,

                                                     unsigned int,

                                                     unsigned int,

                                                     unsigned int);

                                                     unsigned int);

static void move_by_pieces_1 (rtx (*) (rtx, ...), enum machine_mode,

static void move_by_pieces_1 (rtx (*) (rtx, ...), enum machine_mode,

                              struct move_by_pieces *);

                              struct move_by_pieces *);

static bool block_move_libcall_safe_for_call_parm (void);

static bool block_move_libcall_safe_for_call_parm (void);

static bool emit_block_move_via_movmem (rtx, rtx, rtx, unsigned);

static bool emit_block_move_via_movmem (rtx, rtx, rtx, unsigned);

static rtx emit_block_move_via_libcall (rtx, rtx, rtx, bool);

static rtx emit_block_move_via_libcall (rtx, rtx, rtx, bool);

static tree emit_block_move_libcall_fn (int);

static tree emit_block_move_libcall_fn (int);

static void emit_block_move_via_loop (rtx, rtx, rtx, unsigned);

static void emit_block_move_via_loop (rtx, rtx, rtx, unsigned);

static rtx clear_by_pieces_1 (void *, HOST_WIDE_INT, enum machine_mode);

static rtx clear_by_pieces_1 (void *, HOST_WIDE_INT, enum machine_mode);

static void clear_by_pieces (rtx, unsigned HOST_WIDE_INT, unsigned int);

static void clear_by_pieces (rtx, unsigned HOST_WIDE_INT, unsigned int);

static void store_by_pieces_1 (struct store_by_pieces *, unsigned int);

static void store_by_pieces_1 (struct store_by_pieces *, unsigned int);

static void store_by_pieces_2 (rtx (*) (rtx, ...), enum machine_mode,

static void store_by_pieces_2 (rtx (*) (rtx, ...), enum machine_mode,

                               struct store_by_pieces *);

                               struct store_by_pieces *);

static rtx clear_storage_via_libcall (rtx, rtx, bool);

static rtx clear_storage_via_libcall (rtx, rtx, bool);

static tree clear_storage_libcall_fn (int);

static tree clear_storage_libcall_fn (int);

static rtx compress_float_constant (rtx, rtx);

static rtx compress_float_constant (rtx, rtx);

static rtx get_subtarget (rtx);

static rtx get_subtarget (rtx);

static void store_constructor_field (rtx, unsigned HOST_WIDE_INT,

static void store_constructor_field (rtx, unsigned HOST_WIDE_INT,

                                     HOST_WIDE_INT, enum machine_mode,

                                     HOST_WIDE_INT, enum machine_mode,

                                     tree, tree, int, int);

                                     tree, tree, int, int);

static void store_constructor (tree, rtx, int, HOST_WIDE_INT);

static void store_constructor (tree, rtx, int, HOST_WIDE_INT);

static rtx store_field (rtx, HOST_WIDE_INT, HOST_WIDE_INT, enum machine_mode,

static rtx store_field (rtx, HOST_WIDE_INT, HOST_WIDE_INT, enum machine_mode,

                        tree, tree, int);

                        tree, tree, int);

static unsigned HOST_WIDE_INT highest_pow2_factor_for_target (tree, tree);

static unsigned HOST_WIDE_INT highest_pow2_factor_for_target (tree, tree);

static int is_aligning_offset (tree, tree);

static int is_aligning_offset (tree, tree);

static void expand_operands (tree, tree, rtx, rtx*, rtx*,

static void expand_operands (tree, tree, rtx, rtx*, rtx*,

                             enum expand_modifier);

                             enum expand_modifier);

static rtx reduce_to_bit_field_precision (rtx, rtx, tree);

static rtx reduce_to_bit_field_precision (rtx, rtx, tree);

static rtx do_store_flag (tree, rtx, enum machine_mode, int);

static rtx do_store_flag (tree, rtx, enum machine_mode, int);

#ifdef PUSH_ROUNDING

#ifdef PUSH_ROUNDING

static void emit_single_push_insn (enum machine_mode, rtx, tree);

static void emit_single_push_insn (enum machine_mode, rtx, tree);

#endif

#endif

static void do_tablejump (rtx, enum machine_mode, rtx, rtx, rtx);

static void do_tablejump (rtx, enum machine_mode, rtx, rtx, rtx);

static rtx const_vector_from_tree (tree);

static rtx const_vector_from_tree (tree);

static void write_complex_part (rtx, rtx, bool);

static void write_complex_part (rtx, rtx, bool);

/* Record for each mode whether we can move a register directly to or

/* Record for each mode whether we can move a register directly to or

   from an object of that mode in memory.  If we can't, we won't try

   from an object of that mode in memory.  If we can't, we won't try

   to use that mode directly when accessing a field of that mode.  */

   to use that mode directly when accessing a field of that mode.  */

static char direct_load[NUM_MACHINE_MODES];

static char direct_load[NUM_MACHINE_MODES];

static char direct_store[NUM_MACHINE_MODES];

static char direct_store[NUM_MACHINE_MODES];

/* Record for each mode whether we can float-extend from memory.  */

/* Record for each mode whether we can float-extend from memory.  */

static bool float_extend_from_mem[NUM_MACHINE_MODES][NUM_MACHINE_MODES];

static bool float_extend_from_mem[NUM_MACHINE_MODES][NUM_MACHINE_MODES];

/* This macro is used to determine whether move_by_pieces should be called

/* This macro is used to determine whether move_by_pieces should be called

   to perform a structure copy.  */

   to perform a structure copy.  */

#ifndef MOVE_BY_PIECES_P

#ifndef MOVE_BY_PIECES_P

#define MOVE_BY_PIECES_P(SIZE, ALIGN) \

#define MOVE_BY_PIECES_P(SIZE, ALIGN) \

  (move_by_pieces_ninsns (SIZE, ALIGN, MOVE_MAX_PIECES + 1) \

  (move_by_pieces_ninsns (SIZE, ALIGN, MOVE_MAX_PIECES + 1) \

   < (unsigned int) MOVE_RATIO)

   < (unsigned int) MOVE_RATIO)

#endif

#endif

/* This macro is used to determine whether clear_by_pieces should be

/* This macro is used to determine whether clear_by_pieces should be

   called to clear storage.  */

   called to clear storage.  */

#ifndef CLEAR_BY_PIECES_P

#ifndef CLEAR_BY_PIECES_P

#define CLEAR_BY_PIECES_P(SIZE, ALIGN) \

#define CLEAR_BY_PIECES_P(SIZE, ALIGN) \

  (move_by_pieces_ninsns (SIZE, ALIGN, STORE_MAX_PIECES + 1) \

  (move_by_pieces_ninsns (SIZE, ALIGN, STORE_MAX_PIECES + 1) \

   < (unsigned int) CLEAR_RATIO)

   < (unsigned int) CLEAR_RATIO)

#endif

#endif

/* This macro is used to determine whether store_by_pieces should be

/* This macro is used to determine whether store_by_pieces should be

   called to "memset" storage with byte values other than zero, or

   called to "memset" storage with byte values other than zero, or

   to "memcpy" storage when the source is a constant string.  */

   to "memcpy" storage when the source is a constant string.  */

#ifndef STORE_BY_PIECES_P

#ifndef STORE_BY_PIECES_P

#define STORE_BY_PIECES_P(SIZE, ALIGN) \

#define STORE_BY_PIECES_P(SIZE, ALIGN) \

  (move_by_pieces_ninsns (SIZE, ALIGN, STORE_MAX_PIECES + 1) \

  (move_by_pieces_ninsns (SIZE, ALIGN, STORE_MAX_PIECES + 1) \

   < (unsigned int) MOVE_RATIO)

   < (unsigned int) MOVE_RATIO)

#endif

#endif

/* This array records the insn_code of insns to perform block moves.  */

/* This array records the insn_code of insns to perform block moves.  */

enum insn_code movmem_optab[NUM_MACHINE_MODES];

enum insn_code movmem_optab[NUM_MACHINE_MODES];

/* This array records the insn_code of insns to perform block sets.  */

/* This array records the insn_code of insns to perform block sets.  */

enum insn_code setmem_optab[NUM_MACHINE_MODES];

enum insn_code setmem_optab[NUM_MACHINE_MODES];

/* These arrays record the insn_code of three different kinds of insns

/* These arrays record the insn_code of three different kinds of insns

   to perform block compares.  */

   to perform block compares.  */

enum insn_code cmpstr_optab[NUM_MACHINE_MODES];

enum insn_code cmpstr_optab[NUM_MACHINE_MODES];

enum insn_code cmpstrn_optab[NUM_MACHINE_MODES];

enum insn_code cmpstrn_optab[NUM_MACHINE_MODES];

enum insn_code cmpmem_optab[NUM_MACHINE_MODES];

enum insn_code cmpmem_optab[NUM_MACHINE_MODES];

/* Synchronization primitives.  */

/* Synchronization primitives.  */

enum insn_code sync_add_optab[NUM_MACHINE_MODES];

enum insn_code sync_add_optab[NUM_MACHINE_MODES];

enum insn_code sync_sub_optab[NUM_MACHINE_MODES];

enum insn_code sync_sub_optab[NUM_MACHINE_MODES];

enum insn_code sync_ior_optab[NUM_MACHINE_MODES];

enum insn_code sync_ior_optab[NUM_MACHINE_MODES];

enum insn_code sync_and_optab[NUM_MACHINE_MODES];

enum insn_code sync_and_optab[NUM_MACHINE_MODES];

enum insn_code sync_xor_optab[NUM_MACHINE_MODES];

enum insn_code sync_xor_optab[NUM_MACHINE_MODES];

enum insn_code sync_nand_optab[NUM_MACHINE_MODES];

enum insn_code sync_nand_optab[NUM_MACHINE_MODES];

enum insn_code sync_old_add_optab[NUM_MACHINE_MODES];

enum insn_code sync_old_add_optab[NUM_MACHINE_MODES];

enum insn_code sync_old_sub_optab[NUM_MACHINE_MODES];

enum insn_code sync_old_sub_optab[NUM_MACHINE_MODES];

enum insn_code sync_old_ior_optab[NUM_MACHINE_MODES];

enum insn_code sync_old_ior_optab[NUM_MACHINE_MODES];

enum insn_code sync_old_and_optab[NUM_MACHINE_MODES];

enum insn_code sync_old_and_optab[NUM_MACHINE_MODES];

enum insn_code sync_old_xor_optab[NUM_MACHINE_MODES];

enum insn_code sync_old_xor_optab[NUM_MACHINE_MODES];

enum insn_code sync_old_nand_optab[NUM_MACHINE_MODES];

enum insn_code sync_old_nand_optab[NUM_MACHINE_MODES];

enum insn_code sync_new_add_optab[NUM_MACHINE_MODES];

enum insn_code sync_new_add_optab[NUM_MACHINE_MODES];

enum insn_code sync_new_sub_optab[NUM_MACHINE_MODES];

enum insn_code sync_new_sub_optab[NUM_MACHINE_MODES];

enum insn_code sync_new_ior_optab[NUM_MACHINE_MODES];

enum insn_code sync_new_ior_optab[NUM_MACHINE_MODES];

enum insn_code sync_new_and_optab[NUM_MACHINE_MODES];

enum insn_code sync_new_and_optab[NUM_MACHINE_MODES];

enum insn_code sync_new_xor_optab[NUM_MACHINE_MODES];

enum insn_code sync_new_xor_optab[NUM_MACHINE_MODES];

enum insn_code sync_new_nand_optab[NUM_MACHINE_MODES];

enum insn_code sync_new_nand_optab[NUM_MACHINE_MODES];

enum insn_code sync_compare_and_swap[NUM_MACHINE_MODES];

enum insn_code sync_compare_and_swap[NUM_MACHINE_MODES];

enum insn_code sync_compare_and_swap_cc[NUM_MACHINE_MODES];

enum insn_code sync_compare_and_swap_cc[NUM_MACHINE_MODES];

enum insn_code sync_lock_test_and_set[NUM_MACHINE_MODES];

enum insn_code sync_lock_test_and_set[NUM_MACHINE_MODES];

enum insn_code sync_lock_release[NUM_MACHINE_MODES];

enum insn_code sync_lock_release[NUM_MACHINE_MODES];

/* SLOW_UNALIGNED_ACCESS is nonzero if unaligned accesses are very slow.  */

/* SLOW_UNALIGNED_ACCESS is nonzero if unaligned accesses are very slow.  */

#ifndef SLOW_UNALIGNED_ACCESS

#ifndef SLOW_UNALIGNED_ACCESS

#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT

#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT

#endif

#endif

/* This is run once per compilation to set up which modes can be used

/* This is run once per compilation to set up which modes can be used

   directly in memory and to initialize the block move optab.  */

   directly in memory and to initialize the block move optab.  */

void

void

init_expr_once (void)

init_expr_once (void)

{

{

  rtx insn, pat;

  rtx insn, pat;

  enum machine_mode mode;

  enum machine_mode mode;

  int num_clobbers;

  int num_clobbers;

  rtx mem, mem1;

  rtx mem, mem1;

  rtx reg;

  rtx reg;

  /* Try indexing by frame ptr and try by stack ptr.

  /* Try indexing by frame ptr and try by stack ptr.

     It is known that on the Convex the stack ptr isn't a valid index.

     It is known that on the Convex the stack ptr isn't a valid index.

     With luck, one or the other is valid on any machine.  */

     With luck, one or the other is valid on any machine.  */

  mem = gen_rtx_MEM (VOIDmode, stack_pointer_rtx);

  mem = gen_rtx_MEM (VOIDmode, stack_pointer_rtx);

  mem1 = gen_rtx_MEM (VOIDmode, frame_pointer_rtx);

  mem1 = gen_rtx_MEM (VOIDmode, frame_pointer_rtx);

  /* A scratch register we can modify in-place below to avoid

  /* A scratch register we can modify in-place below to avoid

     useless RTL allocations.  */

     useless RTL allocations.  */

  reg = gen_rtx_REG (VOIDmode, -1);

  reg = gen_rtx_REG (VOIDmode, -1);

  insn = rtx_alloc (INSN);

  insn = rtx_alloc (INSN);

  pat = gen_rtx_SET (0, NULL_RTX, NULL_RTX);

  pat = gen_rtx_SET (0, NULL_RTX, NULL_RTX);

  PATTERN (insn) = pat;

  PATTERN (insn) = pat;

  for (mode = VOIDmode; (int) mode < NUM_MACHINE_MODES;

  for (mode = VOIDmode; (int) mode < NUM_MACHINE_MODES;

       mode = (enum machine_mode) ((int) mode + 1))

       mode = (enum machine_mode) ((int) mode + 1))

    {

    {

      int regno;

      int regno;

      direct_load[(int) mode] = direct_store[(int) mode] = 0;

      direct_load[(int) mode] = direct_store[(int) mode] = 0;

      PUT_MODE (mem, mode);

      PUT_MODE (mem, mode);

      PUT_MODE (mem1, mode);

      PUT_MODE (mem1, mode);

      PUT_MODE (reg, mode);

      PUT_MODE (reg, mode);

      /* See if there is some register that can be used in this mode and

      /* See if there is some register that can be used in this mode and

         directly loaded or stored from memory.  */

         directly loaded or stored from memory.  */

      if (mode != VOIDmode && mode != BLKmode)

      if (mode != VOIDmode && mode != BLKmode)

        for (regno = 0; regno < FIRST_PSEUDO_REGISTER

        for (regno = 0; regno < FIRST_PSEUDO_REGISTER

             && (direct_load[(int) mode] == 0 || direct_store[(int) mode] == 0);

             && (direct_load[(int) mode] == 0 || direct_store[(int) mode] == 0);

             regno++)

             regno++)

          {

          {

            if (! HARD_REGNO_MODE_OK (regno, mode))

            if (! HARD_REGNO_MODE_OK (regno, mode))

              continue;

              continue;

            REGNO (reg) = regno;

            REGNO (reg) = regno;

            SET_SRC (pat) = mem;

            SET_SRC (pat) = mem;

            SET_DEST (pat) = reg;

            SET_DEST (pat) = reg;

            if (recog (pat, insn, &num_clobbers) >= 0)

            if (recog (pat, insn, &num_clobbers) >= 0)

              direct_load[(int) mode] = 1;

              direct_load[(int) mode] = 1;

            SET_SRC (pat) = mem1;

            SET_SRC (pat) = mem1;

            SET_DEST (pat) = reg;

            SET_DEST (pat) = reg;

            if (recog (pat, insn, &num_clobbers) >= 0)

            if (recog (pat, insn, &num_clobbers) >= 0)

              direct_load[(int) mode] = 1;

              direct_load[(int) mode] = 1;

            SET_SRC (pat) = reg;

            SET_SRC (pat) = reg;

            SET_DEST (pat) = mem;

            SET_DEST (pat) = mem;

            if (recog (pat, insn, &num_clobbers) >= 0)

            if (recog (pat, insn, &num_clobbers) >= 0)

              direct_store[(int) mode] = 1;

              direct_store[(int) mode] = 1;

            SET_SRC (pat) = reg;

            SET_SRC (pat) = reg;

            SET_DEST (pat) = mem1;

            SET_DEST (pat) = mem1;

            if (recog (pat, insn, &num_clobbers) >= 0)

            if (recog (pat, insn, &num_clobbers) >= 0)

              direct_store[(int) mode] = 1;

              direct_store[(int) mode] = 1;

          }

          }

    }

    }

  mem = gen_rtx_MEM (VOIDmode, gen_rtx_raw_REG (Pmode, 10000));

  mem = gen_rtx_MEM (VOIDmode, gen_rtx_raw_REG (Pmode, 10000));

  for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;

  for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;

       mode = GET_MODE_WIDER_MODE (mode))

       mode = GET_MODE_WIDER_MODE (mode))

    {

    {

      enum machine_mode srcmode;

      enum machine_mode srcmode;

      for (srcmode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); srcmode != mode;

      for (srcmode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); srcmode != mode;

           srcmode = GET_MODE_WIDER_MODE (srcmode))

           srcmode = GET_MODE_WIDER_MODE (srcmode))

        {

        {

          enum insn_code ic;

          enum insn_code ic;

          ic = can_extend_p (mode, srcmode, 0);

          ic = can_extend_p (mode, srcmode, 0);

          if (ic == CODE_FOR_nothing)

          if (ic == CODE_FOR_nothing)

            continue;

            continue;

          PUT_MODE (mem, srcmode);

          PUT_MODE (mem, srcmode);

          if ((*insn_data[ic].operand[1].predicate) (mem, srcmode))

          if ((*insn_data[ic].operand[1].predicate) (mem, srcmode))

            float_extend_from_mem[mode][srcmode] = true;

            float_extend_from_mem[mode][srcmode] = true;

        }

        }

    }

    }

}

}

/* This is run at the start of compiling a function.  */

/* This is run at the start of compiling a function.  */

void

void

init_expr (void)

init_expr (void)

{

{

  cfun->expr = ggc_alloc_cleared (sizeof (struct expr_status));

  cfun->expr = ggc_alloc_cleared (sizeof (struct expr_status));

}

}

/* Copy data from FROM to TO, where the machine modes are not the same.

/* Copy data from FROM to TO, where the machine modes are not the same.

   Both modes may be integer, or both may be floating.

   Both modes may be integer, or both may be floating.

   UNSIGNEDP should be nonzero if FROM is an unsigned type.

   UNSIGNEDP should be nonzero if FROM is an unsigned type.

   This causes zero-extension instead of sign-extension.  */

   This causes zero-extension instead of sign-extension.  */

void

void

convert_move (rtx to, rtx from, int unsignedp)

convert_move (rtx to, rtx from, int unsignedp)

{

{

  enum machine_mode to_mode = GET_MODE (to);

  enum machine_mode to_mode = GET_MODE (to);

  enum machine_mode from_mode = GET_MODE (from);

  enum machine_mode from_mode = GET_MODE (from);

  int to_real = SCALAR_FLOAT_MODE_P (to_mode);

  int to_real = SCALAR_FLOAT_MODE_P (to_mode);

  int from_real = SCALAR_FLOAT_MODE_P (from_mode);

  int from_real = SCALAR_FLOAT_MODE_P (from_mode);

  enum insn_code code;

  enum insn_code code;

  rtx libcall;

  rtx libcall;

  /* rtx code for making an equivalent value.  */

  /* rtx code for making an equivalent value.  */

  enum rtx_code equiv_code = (unsignedp < 0 ? UNKNOWN

  enum rtx_code equiv_code = (unsignedp < 0 ? UNKNOWN

                              : (unsignedp ? ZERO_EXTEND : SIGN_EXTEND));

                              : (unsignedp ? ZERO_EXTEND : SIGN_EXTEND));

  gcc_assert (to_real == from_real);

  gcc_assert (to_real == from_real);

  /* If the source and destination are already the same, then there's

  /* If the source and destination are already the same, then there's

     nothing to do.  */

     nothing to do.  */

  if (to == from)

  if (to == from)

    return;

    return;

  /* If FROM is a SUBREG that indicates that we have already done at least

  /* If FROM is a SUBREG that indicates that we have already done at least

     the required extension, strip it.  We don't handle such SUBREGs as

     the required extension, strip it.  We don't handle such SUBREGs as

     TO here.  */

     TO here.  */

  if (GET_CODE (from) == SUBREG && SUBREG_PROMOTED_VAR_P (from)

  if (GET_CODE (from) == SUBREG && SUBREG_PROMOTED_VAR_P (from)

      && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (from)))

      && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (from)))

          >= GET_MODE_SIZE (to_mode))

          >= GET_MODE_SIZE (to_mode))

      && SUBREG_PROMOTED_UNSIGNED_P (from) == unsignedp)

      && SUBREG_PROMOTED_UNSIGNED_P (from) == unsignedp)

    from = gen_lowpart (to_mode, from), from_mode = to_mode;

    from = gen_lowpart (to_mode, from), from_mode = to_mode;

  gcc_assert (GET_CODE (to) != SUBREG || !SUBREG_PROMOTED_VAR_P (to));

  gcc_assert (GET_CODE (to) != SUBREG || !SUBREG_PROMOTED_VAR_P (to));

  if (to_mode == from_mode

  if (to_mode == from_mode

      || (from_mode == VOIDmode && CONSTANT_P (from)))

      || (from_mode == VOIDmode && CONSTANT_P (from)))

    {

    {

      emit_move_insn (to, from);

      emit_move_insn (to, from);

      return;

      return;

    }

    }

  if (VECTOR_MODE_P (to_mode) || VECTOR_MODE_P (from_mode))

  if (VECTOR_MODE_P (to_mode) || VECTOR_MODE_P (from_mode))

    {

    {

      gcc_assert (GET_MODE_BITSIZE (from_mode) == GET_MODE_BITSIZE (to_mode));

      gcc_assert (GET_MODE_BITSIZE (from_mode) == GET_MODE_BITSIZE (to_mode));

      if (VECTOR_MODE_P (to_mode))

      if (VECTOR_MODE_P (to_mode))

        from = simplify_gen_subreg (to_mode, from, GET_MODE (from), 0);

        from = simplify_gen_subreg (to_mode, from, GET_MODE (from), 0);

      else

      else

        to = simplify_gen_subreg (from_mode, to, GET_MODE (to), 0);

        to = simplify_gen_subreg (from_mode, to, GET_MODE (to), 0);

      emit_move_insn (to, from);

      emit_move_insn (to, from);

      return;

      return;

    }

    }

  if (GET_CODE (to) == CONCAT && GET_CODE (from) == CONCAT)

  if (GET_CODE (to) == CONCAT && GET_CODE (from) == CONCAT)

    {

    {

      convert_move (XEXP (to, 0), XEXP (from, 0), unsignedp);

      convert_move (XEXP (to, 0), XEXP (from, 0), unsignedp);

      convert_move (XEXP (to, 1), XEXP (from, 1), unsignedp);

      convert_move (XEXP (to, 1), XEXP (from, 1), unsignedp);

      return;

      return;

    }

    }

  if (to_real)

  if (to_real)

    {

    {

      rtx value, insns;

      rtx value, insns;

      convert_optab tab;

      convert_optab tab;

      gcc_assert ((GET_MODE_PRECISION (from_mode)

      gcc_assert ((GET_MODE_PRECISION (from_mode)

                   != GET_MODE_PRECISION (to_mode))

                   != GET_MODE_PRECISION (to_mode))

                  || (DECIMAL_FLOAT_MODE_P (from_mode)

                  || (DECIMAL_FLOAT_MODE_P (from_mode)

                      != DECIMAL_FLOAT_MODE_P (to_mode)));

                      != DECIMAL_FLOAT_MODE_P (to_mode)));

      if (GET_MODE_PRECISION (from_mode) == GET_MODE_PRECISION (to_mode))

      if (GET_MODE_PRECISION (from_mode) == GET_MODE_PRECISION (to_mode))

        /* Conversion between decimal float and binary float, same size.  */

        /* Conversion between decimal float and binary float, same size.  */

        tab = DECIMAL_FLOAT_MODE_P (from_mode) ? trunc_optab : sext_optab;

        tab = DECIMAL_FLOAT_MODE_P (from_mode) ? trunc_optab : sext_optab;

      else if (GET_MODE_PRECISION (from_mode) < GET_MODE_PRECISION (to_mode))

      else if (GET_MODE_PRECISION (from_mode) < GET_MODE_PRECISION (to_mode))

        tab = sext_optab;

        tab = sext_optab;

      else

      else

        tab = trunc_optab;

        tab = trunc_optab;

      /* Try converting directly if the insn is supported.  */

      /* Try converting directly if the insn is supported.  */

      code = tab->handlers[to_mode][from_mode].insn_code;

      code = tab->handlers[to_mode][from_mode].insn_code;

      if (code != CODE_FOR_nothing)

      if (code != CODE_FOR_nothing)

        {

        {

          emit_unop_insn (code, to, from,

          emit_unop_insn (code, to, from,

                          tab == sext_optab ? FLOAT_EXTEND : FLOAT_TRUNCATE);

                          tab == sext_optab ? FLOAT_EXTEND : FLOAT_TRUNCATE);

          return;

          return;

        }

        }

      /* Otherwise use a libcall.  */

      /* Otherwise use a libcall.  */

      libcall = tab->handlers[to_mode][from_mode].libfunc;

      libcall = tab->handlers[to_mode][from_mode].libfunc;

      /* Is this conversion implemented yet?  */

      /* Is this conversion implemented yet?  */

      gcc_assert (libcall);

      gcc_assert (libcall);

      start_sequence ();

      start_sequence ();

      value = emit_library_call_value (libcall, NULL_RTX, LCT_CONST, to_mode,

      value = emit_library_call_value (libcall, NULL_RTX, LCT_CONST, to_mode,

                                       1, from, from_mode);

                                       1, from, from_mode);

      insns = get_insns ();

      insns = get_insns ();

      end_sequence ();

      end_sequence ();

      emit_libcall_block (insns, to, value,

      emit_libcall_block (insns, to, value,

                          tab == trunc_optab ? gen_rtx_FLOAT_TRUNCATE (to_mode,

                          tab == trunc_optab ? gen_rtx_FLOAT_TRUNCATE (to_mode,

                                                                       from)

                                                                       from)

                          : gen_rtx_FLOAT_EXTEND (to_mode, from));

                          : gen_rtx_FLOAT_EXTEND (to_mode, from));

      return;

      return;

    }

    }

  /* Handle pointer conversion.  */                     /* SPEE 900220.  */

  /* Handle pointer conversion.  */                     /* SPEE 900220.  */

  /* Targets are expected to provide conversion insns between PxImode and

  /* Targets are expected to provide conversion insns between PxImode and

     xImode for all MODE_PARTIAL_INT modes they use, but no others.  */

     xImode for all MODE_PARTIAL_INT modes they use, but no others.  */

  if (GET_MODE_CLASS (to_mode) == MODE_PARTIAL_INT)

  if (GET_MODE_CLASS (to_mode) == MODE_PARTIAL_INT)

    {

    {

      enum machine_mode full_mode

      enum machine_mode full_mode

        = smallest_mode_for_size (GET_MODE_BITSIZE (to_mode), MODE_INT);

        = smallest_mode_for_size (GET_MODE_BITSIZE (to_mode), MODE_INT);

      gcc_assert (trunc_optab->handlers[to_mode][full_mode].insn_code

      gcc_assert (trunc_optab->handlers[to_mode][full_mode].insn_code

                  != CODE_FOR_nothing);

                  != CODE_FOR_nothing);

      if (full_mode != from_mode)

      if (full_mode != from_mode)

        from = convert_to_mode (full_mode, from, unsignedp);

        from = convert_to_mode (full_mode, from, unsignedp);

      emit_unop_insn (trunc_optab->handlers[to_mode][full_mode].insn_code,

      emit_unop_insn (trunc_optab->handlers[to_mode][full_mode].insn_code,

                      to, from, UNKNOWN);

                      to, from, UNKNOWN);

      return;

      return;

    }

    }

  if (GET_MODE_CLASS (from_mode) == MODE_PARTIAL_INT)

  if (GET_MODE_CLASS (from_mode) == MODE_PARTIAL_INT)

    {

    {

      rtx new_from;

      rtx new_from;

      enum machine_mode full_mode

      enum machine_mode full_mode

        = smallest_mode_for_size (GET_MODE_BITSIZE (from_mode), MODE_INT);

        = smallest_mode_for_size (GET_MODE_BITSIZE (from_mode), MODE_INT);

      gcc_assert (sext_optab->handlers[full_mode][from_mode].insn_code

      gcc_assert (sext_optab->handlers[full_mode][from_mode].insn_code

                  != CODE_FOR_nothing);

                  != CODE_FOR_nothing);

      if (to_mode == full_mode)

      if (to_mode == full_mode)

        {

        {

          emit_unop_insn (sext_optab->handlers[full_mode][from_mode].insn_code,

          emit_unop_insn (sext_optab->handlers[full_mode][from_mode].insn_code,

                          to, from, UNKNOWN);

                          to, from, UNKNOWN);

          return;

          return;

        }

        }

      new_from = gen_reg_rtx (full_mode);

      new_from = gen_reg_rtx (full_mode);

      emit_unop_insn (sext_optab->handlers[full_mode][from_mode].insn_code,

      emit_unop_insn (sext_optab->handlers[full_mode][from_mode].insn_code,

                      new_from, from, UNKNOWN);

                      new_from, from, UNKNOWN);

      /* else proceed to integer conversions below.  */

      /* else proceed to integer conversions below.  */

      from_mode = full_mode;

      from_mode = full_mode;

      from = new_from;

      from = new_from;

    }

    }

  /* Now both modes are integers.  */

  /* Now both modes are integers.  */

  /* Handle expanding beyond a word.  */

  /* Handle expanding beyond a word.  */

  if (GET_MODE_BITSIZE (from_mode) < GET_MODE_BITSIZE (to_mode)

  if (GET_MODE_BITSIZE (from_mode) < GET_MODE_BITSIZE (to_mode)

      && GET_MODE_BITSIZE (to_mode) > BITS_PER_WORD)

      && GET_MODE_BITSIZE (to_mode) > BITS_PER_WORD)

    {

    {

      rtx insns;

      rtx insns;

      rtx lowpart;

      rtx lowpart;

      rtx fill_value;

      rtx fill_value;

      rtx lowfrom;

      rtx lowfrom;

      int i;

      int i;

      enum machine_mode lowpart_mode;

      enum machine_mode lowpart_mode;

      int nwords = CEIL (GET_MODE_SIZE (to_mode), UNITS_PER_WORD);

      int nwords = CEIL (GET_MODE_SIZE (to_mode), UNITS_PER_WORD);

      /* Try converting directly if the insn is supported.  */

      /* Try converting directly if the insn is supported.  */

      if ((code = can_extend_p (to_mode, from_mode, unsignedp))

      if ((code = can_extend_p (to_mode, from_mode, unsignedp))

          != CODE_FOR_nothing)

          != CODE_FOR_nothing)

        {

        {

          /* If FROM is a SUBREG, put it into a register.  Do this

          /* If FROM is a SUBREG, put it into a register.  Do this

             so that we always generate the same set of insns for

             so that we always generate the same set of insns for

             better cse'ing; if an intermediate assignment occurred,

             better cse'ing; if an intermediate assignment occurred,

             we won't be doing the operation directly on the SUBREG.  */

             we won't be doing the operation directly on the SUBREG.  */

          if (optimize > 0 && GET_CODE (from) == SUBREG)

          if (optimize > 0 && GET_CODE (from) == SUBREG)

            from = force_reg (from_mode, from);

            from = force_reg (from_mode, from);

          emit_unop_insn (code, to, from, equiv_code);

          emit_unop_insn (code, to, from, equiv_code);

          return;

          return;

        }

        }

      /* Next, try converting via full word.  */

      /* Next, try converting via full word.  */

      else if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD

      else if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD

               && ((code = can_extend_p (to_mode, word_mode, unsignedp))

               && ((code = can_extend_p (to_mode, word_mode, unsignedp))

                   != CODE_FOR_nothing))

                   != CODE_FOR_nothing))

        {

        {

          if (REG_P (to))

          if (REG_P (to))

            {

            {

              if (reg_overlap_mentioned_p (to, from))

              if (reg_overlap_mentioned_p (to, from))

                from = force_reg (from_mode, from);