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

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

2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.

This file is part of GCC.

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

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

version.

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

Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA

02110-1301, USA. */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "machmode.h"

#include "real.h"

#include "rtl.h"

#include "tree.h"

#include "flags.h"

#include "regs.h"

#include "hard-reg-set.h"

#include "except.h"

#include "function.h"

#include "insn-config.h"

#include "insn-attr.h"

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

#include "expr.h"

#include "optabs.h"

#include "libfuncs.h"

#include "recog.h"

#include "reload.h"

#include "output.h"

#include "typeclass.h"

#include "toplev.h"

#include "ggc.h"

#include "langhooks.h"

#include "intl.h"

#include "tm_p.h"

#include "tree-iterator.h"

#include "tree-pass.h"

#include "tree-flow.h"

#include "target.h"

#include "timevar.h"

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

from first to last or from last to first.

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

only if we have push insns. */

#ifdef PUSH_ROUNDING

#ifndef PUSH_ARGS_REVERSED

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

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

#endif

#endif

#endif

#ifndef STACK_PUSH_CODE

#ifdef STACK_GROWS_DOWNWARD

#define STACK_PUSH_CODE PRE_DEC

#else

#define STACK_PUSH_CODE PRE_INC

#endif

#endif

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

around volatile memory references, and we are willing to

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

indirect addresses so a useful potential cse is generated;

if it is used only once, instruction combination will produce

the same indirect address eventually. */

int cse_not_expected;

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

be performed. */

struct move_by_pieces

};

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

be performed. */

struct store_by_pieces

};

static unsigned HOST_WIDE_INT move_by_pieces_ninsns (unsigned HOST_WIDE_INT,

unsigned int,

unsigned int);

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

struct move_by_pieces *);

static bool block_move_libcall_safe_for_call_parm (void);

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

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

static tree emit_block_move_libcall_fn (int);

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 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_2 (rtx (*) (rtx, ...), enum machine_mode,

struct store_by_pieces *);

static rtx clear_storage_via_libcall (rtx, rtx, bool);

static tree clear_storage_libcall_fn (int);

static rtx compress_float_constant (rtx, rtx);

static rtx get_subtarget (rtx);

static void store_constructor_field (rtx, unsigned HOST_WIDE_INT,

HOST_WIDE_INT, enum machine_mode,

tree, tree, int, 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,

tree, tree, int);

static unsigned HOST_WIDE_INT highest_pow2_factor_for_target (tree, tree);

static int is_aligning_offset (tree, tree);

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

enum expand_modifier);

static rtx reduce_to_bit_field_precision (rtx, rtx, tree);

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

#ifdef PUSH_ROUNDING

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

#endif

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

static rtx const_vector_from_tree (tree);

static void write_complex_part (rtx, rtx, bool);

/* 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

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

static char direct_load[NUM_MACHINE_MODES];

static char direct_store[NUM_MACHINE_MODES];

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

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

to perform a structure copy. */

#ifndef MOVE_BY_PIECES_P

#define MOVE_BY_PIECES_P(SIZE, ALIGN) \

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

< (unsigned int) MOVE_RATIO)

#endif

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

called to clear storage. */

#ifndef CLEAR_BY_PIECES_P

#define CLEAR_BY_PIECES_P(SIZE, ALIGN) \

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

< (unsigned int) CLEAR_RATIO)

#endif

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

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

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

#ifndef STORE_BY_PIECES_P

#define STORE_BY_PIECES_P(SIZE, ALIGN) \

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

< (unsigned int) MOVE_RATIO)

#endif

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

enum insn_code movmem_optab[NUM_MACHINE_MODES];

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

enum insn_code setmem_optab[NUM_MACHINE_MODES];

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

to perform block compares. */

enum insn_code cmpstr_optab[NUM_MACHINE_MODES];

enum insn_code cmpstrn_optab[NUM_MACHINE_MODES];

enum insn_code cmpmem_optab[NUM_MACHINE_MODES];

/* Synchronization primitives. */

enum insn_code sync_add_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_and_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_old_add_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_and_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_new_add_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_and_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_compare_and_swap[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_release[NUM_MACHINE_MODES];

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

#ifndef SLOW_UNALIGNED_ACCESS

#define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT

#endif



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

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

void

init_expr_once (void)

{

rtx insn, pat;

enum machine_mode mode;

int num_clobbers;

rtx mem, mem1;

rtx reg;

/* 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.

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

mem = gen_rtx_MEM (VOIDmode, stack_pointer_rtx);

mem1 = gen_rtx_MEM (VOIDmode, frame_pointer_rtx);

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

useless RTL allocations. */

reg = gen_rtx_REG (VOIDmode, -1);

insn = rtx_alloc (INSN);

pat = gen_rtx_SET (0, NULL_RTX, NULL_RTX);

PATTERN (insn) = pat;

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

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

{

int regno;

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

PUT_MODE (mem, mode);

PUT_MODE (mem1, mode);

PUT_MODE (reg, mode);

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

directly loaded or stored from memory. */

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

for (regno = 0; regno < FIRST_PSEUDO_REGISTER

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

regno++)

{

if (! HARD_REGNO_MODE_OK (regno, mode))

continue;

REGNO (reg) = regno;

SET_SRC (pat) = mem;

SET_DEST (pat) = reg;

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

direct_load[(int) mode] = 1;

SET_SRC (pat) = mem1;

SET_DEST (pat) = reg;

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

direct_load[(int) mode] = 1;

SET_SRC (pat) = reg;

SET_DEST (pat) = mem;

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

direct_store[(int) mode] = 1;

SET_SRC (pat) = reg;

SET_DEST (pat) = mem1;

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

direct_store[(int) mode] = 1;

}

}

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

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

mode = GET_MODE_WIDER_MODE (mode))

{

enum machine_mode srcmode;

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

srcmode = GET_MODE_WIDER_MODE (srcmode))

{

enum insn_code ic;

ic = can_extend_p (mode, srcmode, 0);

if (ic == CODE_FOR_nothing)

continue;

PUT_MODE (mem, srcmode);

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

float_extend_from_mem[mode][srcmode] = true;

}

}

}

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

void

init_expr (void)

{

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

}



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

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

UNSIGNEDP should be nonzero if FROM is an unsigned type.

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

void

convert_move (rtx to, rtx from, int unsignedp)

{

enum machine_mode to_mode = GET_MODE (to);

enum machine_mode from_mode = GET_MODE (from);

int to_real = GET_MODE_CLASS (to_mode) == MODE_FLOAT;

int from_real = GET_MODE_CLASS (from_mode) == MODE_FLOAT;

enum insn_code code;

rtx libcall;

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

enum rtx_code equiv_code = (unsignedp < 0 ? UNKNOWN

: (unsignedp ? ZERO_EXTEND : SIGN_EXTEND));

gcc_assert (to_real == from_real);

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

nothing to do. */

if (to == from)

return;

/* 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

TO here. */

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

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

>= GET_MODE_SIZE (to_mode))

&& SUBREG_PROMOTED_UNSIGNED_P (from) == unsignedp)

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

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

if (to_mode == from_mode

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

{

emit_move_insn (to, from);

return;

}

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

{

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

if (VECTOR_MODE_P (to_mode))

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

else

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

emit_move_insn (to, from);

return;

}

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

{

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

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

return;

}

if (to_real)

{

rtx value, insns;

convert_optab tab;

gcc_assert (GET_MODE_PRECISION (from_mode)

!= GET_MODE_PRECISION (to_mode));

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

tab = sext_optab;

else

tab = trunc_optab;

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

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

if (code != CODE_FOR_nothing)

{

emit_unop_insn (code, to, from,

tab == sext_optab ? FLOAT_EXTEND : FLOAT_TRUNCATE);

return;

}

/* Otherwise use a libcall. */

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

/* Is this conversion implemented yet? */

gcc_assert (libcall);

start_sequence ();

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

1, from, from_mode);

insns = get_insns ();

end_sequence ();

emit_libcall_block (insns, to, value,

tab == trunc_optab ? gen_rtx_FLOAT_TRUNCATE (to_mode,

from)

: gen_rtx_FLOAT_EXTEND (to_mode, from));

return;

}

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

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

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

if (GET_MODE_CLASS (to_mode) == MODE_PARTIAL_INT)

{

enum machine_mode full_mode

= smallest_mode_for_size (GET_MODE_BITSIZE (to_mode), MODE_INT);

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

!= CODE_FOR_nothing);

if (full_mode != from_mode)

from = convert_to_mode (full_mode, from, unsignedp);

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

to, from, UNKNOWN);

return;

}

if (GET_MODE_CLASS (from_mode) == MODE_PARTIAL_INT)

{

rtx new_from;

enum machine_mode full_mode

= smallest_mode_for_size (GET_MODE_BITSIZE (from_mode), MODE_INT);

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

!= CODE_FOR_nothing);

if (to_mode == full_mode)

{

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

to, from, UNKNOWN);

return;

}

new_from = gen_reg_rtx (full_mode);

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

new_from, from, UNKNOWN);

/* else proceed to integer conversions below. */

from_mode = full_mode;

from = new_from;

}

/* Now both modes are integers. */

/* Handle expanding beyond a word. */

if (GET_MODE_BITSIZE (from_mode) < GET_MODE_BITSIZE (to_mode)

&& GET_MODE_BITSIZE (to_mode) > BITS_PER_WORD)

{

rtx insns;

rtx lowpart;

rtx fill_value;

rtx lowfrom;

int i;

enum machine_mode lowpart_mode;

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

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

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

!= CODE_FOR_nothing)

{

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

so that we always generate the same set of insns for

better cse'ing; if an intermediate assignment occurred,

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

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

from = force_reg (from_mode, from);

emit_unop_insn (code, to, from, equiv_code);

return;

}

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

else if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD

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

!= CODE_FOR_nothing))

{

if (REG_P (to))

{

if (reg_overlap_mentioned_p (to, from))

from = force_reg (from_mode, from);

emit_insn (gen_rtx_CLOBBER (VOIDmode, to));

}

convert_move (gen_lowpart (word_mode, to), from, unsignedp);

emit_unop_insn (code, to,

gen_lowpart (word_mode, to), equiv_code);

return;

}

/* No special multiword conversion insn; do it by hand. */

start_sequence ();

/* Since we will turn this into a no conflict block, we must ensure

that the source does not overlap the target. */

if (reg_overlap_mentioned_p (to, from))

from = force_reg (from_mode, from);

/* Get a copy of FROM widened to a word, if necessary. */

if (GET_MODE_BITSIZE (from_mode) < BITS_PER_WORD)

lowpart_mode = word_mode;

else

lowpart_mode = from_mode;

lowfrom = convert_to_mode (lowpart_mode, from, unsignedp);

lowpart = gen_lowpart (lowpart_mode, to);

emit_move_insn (lowpart, lowfrom);

/* Compute the value to put in each remaining word. */

if (unsignedp)

fill_value = const0_rtx;

else

{

#ifdef HAVE_slt

if (HAVE_slt

&& insn_data[(int) CODE_FOR_slt].operand[0].mode == word_mode

&& STORE_FLAG_VALUE == -1)

{

emit_cmp_insn (lowfrom, const0_rtx, NE, NULL_RTX,

lowpart_mode, 0);

fill_value = gen_reg_rtx (word_mode);

emit_insn (gen_slt (fill_value));

}

else

#endif

{

fill_value

= expand_shift (RSHIFT_EXPR, lowpart_mode, lowfrom,

size_int (GET_MODE_BITSIZE (lowpart_mode) - 1),

NULL_RTX, 0);

fill_value = convert_to_mode (word_mode, fill_value, 1);

}

}

/* Fill the remaining words. */

for (i = GET_MODE_SIZE (lowpart_mode) / UNITS_PER_WORD; i < nwords; i++)

{

int index = (WORDS_BIG_ENDIAN ? nwords - i - 1 : i);

rtx subword = operand_subword (to, index, 1, to_mode);

gcc_assert (subword);

if (fill_value != subword)

emit_move_insn (subword, fill_value);

}

insns = get_insns ();

end_sequence ();

emit_no_conflict_block (insns, to, from, NULL_RTX,

gen_rtx_fmt_e (equiv_code, to_mode, copy_rtx (from)));

return;

}

/* Truncating multi-word to a word or less. */

if (GET_MODE_BITSIZE (from_mode) > BITS_PER_WORD

&& GET_MODE_BITSIZE (to_mode) <= BITS_PER_WORD)

{

if (!((MEM_P (from)

&& ! MEM_VOLATILE_P (from)

&& direct_load[(int) to_mode]

&& ! mode_dependent_address_p (XEXP (from, 0)))

|| REG_P (from)

|| GET_CODE (from) == SUBREG))

from = force_reg (from_mode, from);

convert_move (to, gen_lowpart (word_mode, from), 0);

return;

}

/* Now follow all the conversions between integers

no more than a word long. */

/* For truncation, usually we can just refer to FROM in a narrower mode. */

if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode)

&& TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),

GET_MODE_BITSIZE (from_mode)))

{

if (!((MEM_P (from)

&& ! MEM_VOLATILE_P (from)

&& direct_load[(int) to_mode]

&& ! mode_dependent_address_p (XEXP (from, 0)))

|| REG_P (from)

|| GET_CODE (from) == SUBREG))

from = force_reg (from_mode, from);

if (REG_P (from) && REGNO (from) < FIRST_PSEUDO_REGISTER

&& ! HARD_REGNO_MODE_OK (REGNO (from), to_mode))

from = copy_to_reg (from);

emit_move_insn (to, gen_lowpart (to_mode, from));

return;

}

/* Handle extension. */

if (GET_MODE_BITSIZE (to_mode) > GET_MODE_BITSIZE (from_mode))

{

/* Convert directly if that works. */

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

!= CODE_FOR_nothing)

{

emit_unop_insn (code, to, from, equiv_code);

return;

}

else

{

enum machine_mode intermediate;

rtx tmp;

tree shift_amount;

/* Search for a mode to convert via. */

for (intermediate = from_mode; intermediate != VOIDmode;

intermediate = GET_MODE_WIDER_MODE (intermediate))

if (((can_extend_p (to_mode, intermediate, unsignedp)

!= CODE_FOR_nothing)

|| (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (intermediate)

&& TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (to_mode),

GET_MODE_BITSIZE (intermediate))))

&& (can_extend_p (intermediate, from_mode, unsignedp)

!= CODE_FOR_nothing))

{

convert_move (to, convert_to_mode (intermediate, from,

unsignedp), unsignedp);

return;

}

/* No suitable intermediate mode.

Generate what we need with shifts. */

shift_amount = build_int_cst (NULL_TREE,

GET_MODE_BITSIZE (to_mode)

- GET_MODE_BITSIZE (from_mode));

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

tmp = expand_shift (LSHIFT_EXPR, to_mode, from, shift_amount,

to, unsignedp);

tmp = expand_shift (RSHIFT_EXPR, to_mode, tmp, shift_amount,

to, unsignedp);

if (tmp != to)

emit_move_insn (to, tmp);

return;

}

}

/* Support special truncate insns for certain modes. */

if (trunc_optab->handlers[to_mode][from_mode].insn_code != CODE_FOR_nothing)

{

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

to, from, UNKNOWN);

return;

}

/* Handle truncation of volatile memrefs, and so on;

the things that couldn't be truncated directly,

and for which there was no special instruction.

??? Code above formerly short-circuited this, for most integer

mode pairs, with a force_reg in from_mode followed by a recursive

call to this routine. Appears always to have been wrong. */

if (GET_MODE_BITSIZE (to_mode) < GET_MODE_BITSIZE (from_mode))

{

rtx temp = force_reg (to_mode, gen_lowpart (to_mode, from));

emit_move_insn (to, temp);

return;

}

/* Mode combination is not recognized. */

gcc_unreachable ();

}

/* Return an rtx for a value that would result

from converting X to mode MODE.

Both X and MODE may be floating, or both integer.

UNSIGNEDP is nonzero if X is an unsigned value.

This can be done by referring to a part of X in place

or by copying to a new temporary with conversion. */

rtx

convert_to_mode (enum machine_mode mode, rtx x, int unsignedp)

{

return convert_modes (mode, VOIDmode, x, unsignedp);

}

/* Return an rtx for a value that would result

from converting X from mode OLDMODE to mode MODE.

Both modes may be floating, or both integer.

UNSIGNEDP is nonzero if X is an unsigned value.

This can be done by referring to a part of X in place

or by copying to a new temporary with conversion.

You can give VOIDmode for OLDMODE, if you are sure X has a nonvoid mode. */

rtx

convert_modes (enum machine_mode mode, enum machine_mode oldmode, rtx x, int unsignedp)

{

rtx temp;

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

the required extension, strip it. */

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

&& GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) >= GET_MODE_SIZE (mode)

&& SUBREG_PROMOTED_UNSIGNED_P (x) == unsignedp)

x = gen_lowpart (mode, x);

if (GET_MODE (x) != VOIDmode)

oldmode = GET_MODE (x);

if (mode == oldmode)

return x;

/* There is one case that we must handle specially: If we are converting

a CONST_INT into a mode whose size is twice HOST_BITS_PER_WIDE_INT and

we are to interpret the constant as unsigned, gen_lowpart will do

the wrong if the constant appears negative. What we want to do is

make the high-order word of the constant zero, not all ones. */

if (unsignedp && GET_MODE_CLASS (mode) == MODE_INT

&& GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT

&& GET_CODE (x) == CONST_INT && INTVAL (x) < 0)

{

HOST_WIDE_INT val = INTVAL (x);

if (oldmode != VOIDmode

&& HOST_BITS_PER_WIDE_INT > GET_MODE_BITSIZE (oldmode))

{

int width = GET_MODE_BITSIZE (oldmode);

/* We need to zero extend VAL. */

val &= ((HOST_WIDE_INT) 1 << width) - 1;

}

return immed_double_const (val, (HOST_WIDE_INT) 0, mode);

}

/* We can do this with a gen_lowpart if both desired and current modes

are integer, and this is either a constant integer, a register, or a

non-volatile MEM. Except for the constant case where MODE is no

wider than HOST_BITS_PER_WIDE_INT, we must be narrowing the operand. */

if ((GET_CODE (x) == CONST_INT

&& GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)

|| (GET_MODE_CLASS (mode) == MODE_INT

&& GET_MODE_CLASS (oldmode) == MODE_INT

&& (GET_CODE (x) == CONST_DOUBLE

|| (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (oldmode)

&& ((MEM_P (x) && ! MEM_VOLATILE_P (x)

&& direct_load[(int) mode])

|| (REG_P (x)

&& (! HARD_REGISTER_P (x)

|| HARD_REGNO_MODE_OK (REGNO (x), mode))

&& TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),

GET_MODE_BITSIZE (GET_MODE (x)))))))))

{

/* ?? If we don't know OLDMODE, we have to assume here that

X does not need sign- or zero-extension. This may not be

the case, but it's the best we can do. */

if (GET_CODE (x) == CONST_INT && oldmode != VOIDmode

&& GET_MODE_SIZE (mode) > GET_MODE_SIZE (oldmode))

{

HOST_WIDE_INT val = INTVAL (x);

int width = GET_MODE_BITSIZE (oldmode);

/* We must sign or zero-extend in this case. Start by

zero-extending, then sign extend if we need to. */

val &= ((HOST_WIDE_INT) 1 << width) - 1;

if (! unsignedp

&& (val & ((HOST_WIDE_INT) 1 << (width - 1))))

val |= (HOST_WIDE_INT) (-1) << width;

return gen_int_mode (val, mode);

}

return gen_lowpart (mode, x);

}

/* Converting from integer constant into mode is always equivalent to an

subreg operation. */

if (VECTOR_MODE_P (mode) && GET_MODE (x) == VOIDmode)

{

gcc_assert (GET_MODE_BITSIZE (mode) == GET_MODE_BITSIZE (oldmode));

return simplify_gen_subreg (mode, x, oldmode, 0);

}

temp = gen_reg_rtx (mode);

convert_move (temp, x, unsignedp);

return temp;

}



/* STORE_MAX_PIECES is the number of bytes at a time that we can

store efficiently. Due to internal GCC limitations, this is

MOVE_MAX_PIECES limited by the number of bytes GCC can represent

for an immediate constant. */

#define STORE_MAX_PIECES MIN (MOVE_MAX_PIECES, 2 * sizeof (HOST_WIDE_INT))

/* Determine whether the LEN bytes can be moved by using several move

instructions. Return nonzero if a call to move_by_pieces should

succeed. */

int

can_move_by_pieces (unsigned HOST_WIDE_INT len,

unsigned int align ATTRIBUTE_UNUSED)

{

return MOVE_BY_PIECES_P (len, align);

}

/* Generate several move instructions to copy LEN bytes from block FROM to

block TO. (These are MEM rtx's with BLKmode).

If PUSH_ROUNDING is defined and TO is NULL, emit_single_push_insn is

used to push FROM to the stack.

ALIGN is maximum stack alignment we can assume.

If ENDP is 0 return to, if ENDP is 1 return memory at the end ala

mempcpy, and if ENDP is 2 return memory the end minus one byte ala

stpcpy. */

rtx

move_by_pieces (rtx to, rtx from, unsigned HOST_WIDE_INT len,

unsigned int align, int endp)

{

struct move_by_pieces data;

rtx to_addr, from_addr = XEXP (from, 0);

unsigned int max_size = MOVE_MAX_PIECES + 1;

enum machine_mode mode = VOIDmode, tmode;

enum insn_code icode;

align = MIN (to ? MEM_ALIGN (to) : align, MEM_ALIGN (from));

data.offset = 0;

data.from_addr = from_addr;

if (to)

{

to_addr = XEXP (to, 0);

data.to = to;

data.autinc_to

= (GET_CODE (to_addr) == PRE_INC || GET_CODE (to_addr) == PRE_DEC

|| GET_CODE (to_addr) == POST_INC || GET_CODE (to_addr) == POST_DEC);

data.reverse

= (GET_CODE (to_addr) == PRE_DEC || GET_CODE (to_addr) == POST_DEC);

}

else

{

to_addr = NULL_RTX;

data.to = NULL_RTX;

data.autinc_to = 1;

#ifdef STACK_GROWS_DOWNWARD

data.reverse = 1;

#else

data.reverse = 0;

#endif

}

data.to_addr = to_addr;

data.from = from;

data.autinc_from

= (GET_CODE (from_addr) == PRE_INC || GET_CODE (from_addr) == PRE_DEC

|| GET_CODE (from_addr) == POST_INC

|| GET_CODE (from_addr) == POST_DEC);

data.explicit_inc_from = 0;

data.explicit_inc_to = 0;

if (data.reverse) data.offset = len;

data.len = len;

/* If copying requires more than two move insns,

copy addresses to registers (to make displacements shorter)

and use post-increment if available. */

if (!(data.autinc_from && data.autinc_to)

&& move_by_pieces_ninsns (len, align, max_size) > 2)

{

/* Find the mode of the largest move... */

for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);

tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))

if (GET_MODE_SIZE (tmode) < max_size)

mode = tmode;

if (USE_LOAD_PRE_DECREMENT (mode) && data.reverse && ! data.autinc_from)

{

data.from_addr = copy_addr_to_reg (plus_constant (from_addr, len));

data.autinc_from = 1;

data.explicit_inc_from = -1;

}

if (USE_LOAD_POST_INCREMENT (mode) && ! data.autinc_from)

{

data.from_addr = copy_addr_to_reg (from_addr);

data.autinc_from = 1;

data.explicit_inc_from = 1;

}

if (!data.autinc_from && CONSTANT_P (from_addr))

data.from_addr = copy_addr_to_reg (from_addr);

if (USE_STORE_PRE_DECREMENT (mode) && data.reverse && ! data.autinc_to)

{

data.to_addr = copy_addr_to_reg (plus_constant (to_addr, len));

data.autinc_to = 1;

data.explicit_inc_to = -1;

}

if (USE_STORE_POST_INCREMENT (mode) && ! data.reverse && ! data.autinc_to)

{

data.to_addr = copy_addr_to_reg (to_addr);

data.autinc_to = 1;

data.explicit_inc_to = 1;

}

if (!data.autinc_to && CONSTANT_P (to_addr))

data.to_addr = copy_addr_to_reg (to_addr);

}

tmode = mode_for_size (MOVE_MAX_PIECES * BITS_PER_UNIT, MODE_INT, 1);

if (align >= GET_MODE_ALIGNMENT (tmode))

align = GET_MODE_ALIGNMENT (tmode);

else

{

enum machine_mode xmode;

for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT), xmode = tmode;

tmode != VOIDmode;

xmode = tmode, tmode = GET_MODE_WIDER_MODE (tmode))

if (GET_MODE_SIZE (tmode) > MOVE_MAX_PIECES

|| SLOW_UNALIGNED_ACCESS (tmode, align))

break;

align = MAX (align, GET_MODE_ALIGNMENT (xmode));

}

/* First move what we can in the largest integer mode, then go to

successively smaller modes. */

while (max_size > 1)

{

for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);

tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))

if (GET_MODE_SIZE (tmode) < max_size)

mode = tmode;

if (mode == VOIDmode)

break;

icode = mov_optab->handlers[(int) mode].insn_code;

if (icode != CODE_FOR_nothing && align >= GET_MODE_ALIGNMENT (mode))

move_by_pieces_1 (GEN_FCN (icode), mode, &data);

max_size = GET_MODE_SIZE (mode);

}

/* The code above should have handled everything. */

gcc_assert (!data.len);

if (endp)

{

rtx to1;

gcc_assert (!data.reverse);

if (data.autinc_to)

{

if (endp == 2)

{

if (HAVE_POST_INCREMENT && data.explicit_inc_to > 0)