/* Emit RTL for the GCC expander.
|
/* Emit RTL for the GCC expander.
|
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
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/>. */
|
|
|
|
|
/* Middle-to-low level generation of rtx code and insns.
|
/* Middle-to-low level generation of rtx code and insns.
|
|
|
This file contains support functions for creating rtl expressions
|
This file contains support functions for creating rtl expressions
|
and manipulating them in the doubly-linked chain of insns.
|
and manipulating them in the doubly-linked chain of insns.
|
|
|
The patterns of the insns are created by machine-dependent
|
The patterns of the insns are created by machine-dependent
|
routines in insn-emit.c, which is generated automatically from
|
routines in insn-emit.c, which is generated automatically from
|
the machine description. These routines make the individual rtx's
|
the machine description. These routines make the individual rtx's
|
of the pattern with `gen_rtx_fmt_ee' and others in genrtl.[ch],
|
of the pattern with `gen_rtx_fmt_ee' and others in genrtl.[ch],
|
which are automatically generated from rtl.def; what is machine
|
which are automatically generated from rtl.def; what is machine
|
dependent is the kind of rtx's they make and what arguments they
|
dependent is the kind of rtx's they make and what arguments they
|
use. */
|
use. */
|
|
|
#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 "toplev.h"
|
#include "toplev.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "function.h"
|
#include "function.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "regs.h"
|
#include "regs.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "hashtab.h"
|
#include "hashtab.h"
|
#include "insn-config.h"
|
#include "insn-config.h"
|
#include "recog.h"
|
#include "recog.h"
|
#include "real.h"
|
#include "real.h"
|
#include "fixed-value.h"
|
#include "fixed-value.h"
|
#include "bitmap.h"
|
#include "bitmap.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "debug.h"
|
#include "debug.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "df.h"
|
#include "df.h"
|
#include "params.h"
|
#include "params.h"
|
#include "target.h"
|
#include "target.h"
|
|
|
/* Commonly used modes. */
|
/* Commonly used modes. */
|
|
|
enum machine_mode byte_mode; /* Mode whose width is BITS_PER_UNIT. */
|
enum machine_mode byte_mode; /* Mode whose width is BITS_PER_UNIT. */
|
enum machine_mode word_mode; /* Mode whose width is BITS_PER_WORD. */
|
enum machine_mode word_mode; /* Mode whose width is BITS_PER_WORD. */
|
enum machine_mode double_mode; /* Mode whose width is DOUBLE_TYPE_SIZE. */
|
enum machine_mode double_mode; /* Mode whose width is DOUBLE_TYPE_SIZE. */
|
enum machine_mode ptr_mode; /* Mode whose width is POINTER_SIZE. */
|
enum machine_mode ptr_mode; /* Mode whose width is POINTER_SIZE. */
|
|
|
/* Datastructures maintained for currently processed function in RTL form. */
|
/* Datastructures maintained for currently processed function in RTL form. */
|
|
|
struct rtl_data x_rtl;
|
struct rtl_data x_rtl;
|
|
|
/* Indexed by pseudo register number, gives the rtx for that pseudo.
|
/* Indexed by pseudo register number, gives the rtx for that pseudo.
|
Allocated in parallel with regno_pointer_align.
|
Allocated in parallel with regno_pointer_align.
|
FIXME: We could put it into emit_status struct, but gengtype is not able to deal
|
FIXME: We could put it into emit_status struct, but gengtype is not able to deal
|
with length attribute nested in top level structures. */
|
with length attribute nested in top level structures. */
|
|
|
rtx * regno_reg_rtx;
|
rtx * regno_reg_rtx;
|
|
|
/* This is *not* reset after each function. It gives each CODE_LABEL
|
/* This is *not* reset after each function. It gives each CODE_LABEL
|
in the entire compilation a unique label number. */
|
in the entire compilation a unique label number. */
|
|
|
static GTY(()) int label_num = 1;
|
static GTY(()) int label_num = 1;
|
|
|
/* Commonly used rtx's, so that we only need space for one copy.
|
/* Commonly used rtx's, so that we only need space for one copy.
|
These are initialized once for the entire compilation.
|
These are initialized once for the entire compilation.
|
All of these are unique; no other rtx-object will be equal to any
|
All of these are unique; no other rtx-object will be equal to any
|
of these. */
|
of these. */
|
|
|
rtx global_rtl[GR_MAX];
|
rtx global_rtl[GR_MAX];
|
|
|
/* Commonly used RTL for hard registers. These objects are not necessarily
|
/* Commonly used RTL for hard registers. These objects are not necessarily
|
unique, so we allocate them separately from global_rtl. They are
|
unique, so we allocate them separately from global_rtl. They are
|
initialized once per compilation unit, then copied into regno_reg_rtx
|
initialized once per compilation unit, then copied into regno_reg_rtx
|
at the beginning of each function. */
|
at the beginning of each function. */
|
static GTY(()) rtx static_regno_reg_rtx[FIRST_PSEUDO_REGISTER];
|
static GTY(()) rtx static_regno_reg_rtx[FIRST_PSEUDO_REGISTER];
|
|
|
/* We record floating-point CONST_DOUBLEs in each floating-point mode for
|
/* We record floating-point CONST_DOUBLEs in each floating-point mode for
|
the values of 0, 1, and 2. For the integer entries and VOIDmode, we
|
the values of 0, 1, and 2. For the integer entries and VOIDmode, we
|
record a copy of const[012]_rtx. */
|
record a copy of const[012]_rtx. */
|
|
|
rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE];
|
rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE];
|
|
|
rtx const_true_rtx;
|
rtx const_true_rtx;
|
|
|
REAL_VALUE_TYPE dconst0;
|
REAL_VALUE_TYPE dconst0;
|
REAL_VALUE_TYPE dconst1;
|
REAL_VALUE_TYPE dconst1;
|
REAL_VALUE_TYPE dconst2;
|
REAL_VALUE_TYPE dconst2;
|
REAL_VALUE_TYPE dconstm1;
|
REAL_VALUE_TYPE dconstm1;
|
REAL_VALUE_TYPE dconsthalf;
|
REAL_VALUE_TYPE dconsthalf;
|
|
|
/* Record fixed-point constant 0 and 1. */
|
/* Record fixed-point constant 0 and 1. */
|
FIXED_VALUE_TYPE fconst0[MAX_FCONST0];
|
FIXED_VALUE_TYPE fconst0[MAX_FCONST0];
|
FIXED_VALUE_TYPE fconst1[MAX_FCONST1];
|
FIXED_VALUE_TYPE fconst1[MAX_FCONST1];
|
|
|
/* All references to the following fixed hard registers go through
|
/* All references to the following fixed hard registers go through
|
these unique rtl objects. On machines where the frame-pointer and
|
these unique rtl objects. On machines where the frame-pointer and
|
arg-pointer are the same register, they use the same unique object.
|
arg-pointer are the same register, they use the same unique object.
|
|
|
After register allocation, other rtl objects which used to be pseudo-regs
|
After register allocation, other rtl objects which used to be pseudo-regs
|
may be clobbered to refer to the frame-pointer register.
|
may be clobbered to refer to the frame-pointer register.
|
But references that were originally to the frame-pointer can be
|
But references that were originally to the frame-pointer can be
|
distinguished from the others because they contain frame_pointer_rtx.
|
distinguished from the others because they contain frame_pointer_rtx.
|
|
|
When to use frame_pointer_rtx and hard_frame_pointer_rtx is a little
|
When to use frame_pointer_rtx and hard_frame_pointer_rtx is a little
|
tricky: until register elimination has taken place hard_frame_pointer_rtx
|
tricky: until register elimination has taken place hard_frame_pointer_rtx
|
should be used if it is being set, and frame_pointer_rtx otherwise. After
|
should be used if it is being set, and frame_pointer_rtx otherwise. After
|
register elimination hard_frame_pointer_rtx should always be used.
|
register elimination hard_frame_pointer_rtx should always be used.
|
On machines where the two registers are same (most) then these are the
|
On machines where the two registers are same (most) then these are the
|
same.
|
same.
|
|
|
In an inline procedure, the stack and frame pointer rtxs may not be
|
In an inline procedure, the stack and frame pointer rtxs may not be
|
used for anything else. */
|
used for anything else. */
|
rtx pic_offset_table_rtx; /* (REG:Pmode PIC_OFFSET_TABLE_REGNUM) */
|
rtx pic_offset_table_rtx; /* (REG:Pmode PIC_OFFSET_TABLE_REGNUM) */
|
|
|
/* This is used to implement __builtin_return_address for some machines.
|
/* This is used to implement __builtin_return_address for some machines.
|
See for instance the MIPS port. */
|
See for instance the MIPS port. */
|
rtx return_address_pointer_rtx; /* (REG:Pmode RETURN_ADDRESS_POINTER_REGNUM) */
|
rtx return_address_pointer_rtx; /* (REG:Pmode RETURN_ADDRESS_POINTER_REGNUM) */
|
|
|
/* We make one copy of (const_int C) where C is in
|
/* We make one copy of (const_int C) where C is in
|
[- MAX_SAVED_CONST_INT, MAX_SAVED_CONST_INT]
|
[- MAX_SAVED_CONST_INT, MAX_SAVED_CONST_INT]
|
to save space during the compilation and simplify comparisons of
|
to save space during the compilation and simplify comparisons of
|
integers. */
|
integers. */
|
|
|
rtx const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];
|
rtx const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1];
|
|
|
/* A hash table storing CONST_INTs whose absolute value is greater
|
/* A hash table storing CONST_INTs whose absolute value is greater
|
than MAX_SAVED_CONST_INT. */
|
than MAX_SAVED_CONST_INT. */
|
|
|
static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
|
static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
|
htab_t const_int_htab;
|
htab_t const_int_htab;
|
|
|
/* A hash table storing memory attribute structures. */
|
/* A hash table storing memory attribute structures. */
|
static GTY ((if_marked ("ggc_marked_p"), param_is (struct mem_attrs)))
|
static GTY ((if_marked ("ggc_marked_p"), param_is (struct mem_attrs)))
|
htab_t mem_attrs_htab;
|
htab_t mem_attrs_htab;
|
|
|
/* A hash table storing register attribute structures. */
|
/* A hash table storing register attribute structures. */
|
static GTY ((if_marked ("ggc_marked_p"), param_is (struct reg_attrs)))
|
static GTY ((if_marked ("ggc_marked_p"), param_is (struct reg_attrs)))
|
htab_t reg_attrs_htab;
|
htab_t reg_attrs_htab;
|
|
|
/* A hash table storing all CONST_DOUBLEs. */
|
/* A hash table storing all CONST_DOUBLEs. */
|
static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
|
static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
|
htab_t const_double_htab;
|
htab_t const_double_htab;
|
|
|
/* A hash table storing all CONST_FIXEDs. */
|
/* A hash table storing all CONST_FIXEDs. */
|
static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
|
static GTY ((if_marked ("ggc_marked_p"), param_is (struct rtx_def)))
|
htab_t const_fixed_htab;
|
htab_t const_fixed_htab;
|
|
|
#define first_insn (crtl->emit.x_first_insn)
|
#define first_insn (crtl->emit.x_first_insn)
|
#define last_insn (crtl->emit.x_last_insn)
|
#define last_insn (crtl->emit.x_last_insn)
|
#define cur_insn_uid (crtl->emit.x_cur_insn_uid)
|
#define cur_insn_uid (crtl->emit.x_cur_insn_uid)
|
#define cur_debug_insn_uid (crtl->emit.x_cur_debug_insn_uid)
|
#define cur_debug_insn_uid (crtl->emit.x_cur_debug_insn_uid)
|
#define last_location (crtl->emit.x_last_location)
|
#define last_location (crtl->emit.x_last_location)
|
#define first_label_num (crtl->emit.x_first_label_num)
|
#define first_label_num (crtl->emit.x_first_label_num)
|
|
|
static rtx make_call_insn_raw (rtx);
|
static rtx make_call_insn_raw (rtx);
|
static rtx change_address_1 (rtx, enum machine_mode, rtx, int);
|
static rtx change_address_1 (rtx, enum machine_mode, rtx, int);
|
static void set_used_decls (tree);
|
static void set_used_decls (tree);
|
static void mark_label_nuses (rtx);
|
static void mark_label_nuses (rtx);
|
static hashval_t const_int_htab_hash (const void *);
|
static hashval_t const_int_htab_hash (const void *);
|
static int const_int_htab_eq (const void *, const void *);
|
static int const_int_htab_eq (const void *, const void *);
|
static hashval_t const_double_htab_hash (const void *);
|
static hashval_t const_double_htab_hash (const void *);
|
static int const_double_htab_eq (const void *, const void *);
|
static int const_double_htab_eq (const void *, const void *);
|
static rtx lookup_const_double (rtx);
|
static rtx lookup_const_double (rtx);
|
static hashval_t const_fixed_htab_hash (const void *);
|
static hashval_t const_fixed_htab_hash (const void *);
|
static int const_fixed_htab_eq (const void *, const void *);
|
static int const_fixed_htab_eq (const void *, const void *);
|
static rtx lookup_const_fixed (rtx);
|
static rtx lookup_const_fixed (rtx);
|
static hashval_t mem_attrs_htab_hash (const void *);
|
static hashval_t mem_attrs_htab_hash (const void *);
|
static int mem_attrs_htab_eq (const void *, const void *);
|
static int mem_attrs_htab_eq (const void *, const void *);
|
static mem_attrs *get_mem_attrs (alias_set_type, tree, rtx, rtx, unsigned int,
|
static mem_attrs *get_mem_attrs (alias_set_type, tree, rtx, rtx, unsigned int,
|
addr_space_t, enum machine_mode);
|
addr_space_t, enum machine_mode);
|
static hashval_t reg_attrs_htab_hash (const void *);
|
static hashval_t reg_attrs_htab_hash (const void *);
|
static int reg_attrs_htab_eq (const void *, const void *);
|
static int reg_attrs_htab_eq (const void *, const void *);
|
static reg_attrs *get_reg_attrs (tree, int);
|
static reg_attrs *get_reg_attrs (tree, int);
|
static rtx gen_const_vector (enum machine_mode, int);
|
static rtx gen_const_vector (enum machine_mode, int);
|
static void copy_rtx_if_shared_1 (rtx *orig);
|
static void copy_rtx_if_shared_1 (rtx *orig);
|
|
|
/* Probability of the conditional branch currently proceeded by try_split.
|
/* Probability of the conditional branch currently proceeded by try_split.
|
Set to -1 otherwise. */
|
Set to -1 otherwise. */
|
int split_branch_probability = -1;
|
int split_branch_probability = -1;
|
|
|
/* Returns a hash code for X (which is a really a CONST_INT). */
|
/* Returns a hash code for X (which is a really a CONST_INT). */
|
|
|
static hashval_t
|
static hashval_t
|
const_int_htab_hash (const void *x)
|
const_int_htab_hash (const void *x)
|
{
|
{
|
return (hashval_t) INTVAL ((const_rtx) x);
|
return (hashval_t) INTVAL ((const_rtx) x);
|
}
|
}
|
|
|
/* Returns nonzero if the value represented by X (which is really a
|
/* Returns nonzero if the value represented by X (which is really a
|
CONST_INT) is the same as that given by Y (which is really a
|
CONST_INT) is the same as that given by Y (which is really a
|
HOST_WIDE_INT *). */
|
HOST_WIDE_INT *). */
|
|
|
static int
|
static int
|
const_int_htab_eq (const void *x, const void *y)
|
const_int_htab_eq (const void *x, const void *y)
|
{
|
{
|
return (INTVAL ((const_rtx) x) == *((const HOST_WIDE_INT *) y));
|
return (INTVAL ((const_rtx) x) == *((const HOST_WIDE_INT *) y));
|
}
|
}
|
|
|
/* Returns a hash code for X (which is really a CONST_DOUBLE). */
|
/* Returns a hash code for X (which is really a CONST_DOUBLE). */
|
static hashval_t
|
static hashval_t
|
const_double_htab_hash (const void *x)
|
const_double_htab_hash (const void *x)
|
{
|
{
|
const_rtx const value = (const_rtx) x;
|
const_rtx const value = (const_rtx) x;
|
hashval_t h;
|
hashval_t h;
|
|
|
if (GET_MODE (value) == VOIDmode)
|
if (GET_MODE (value) == VOIDmode)
|
h = CONST_DOUBLE_LOW (value) ^ CONST_DOUBLE_HIGH (value);
|
h = CONST_DOUBLE_LOW (value) ^ CONST_DOUBLE_HIGH (value);
|
else
|
else
|
{
|
{
|
h = real_hash (CONST_DOUBLE_REAL_VALUE (value));
|
h = real_hash (CONST_DOUBLE_REAL_VALUE (value));
|
/* MODE is used in the comparison, so it should be in the hash. */
|
/* MODE is used in the comparison, so it should be in the hash. */
|
h ^= GET_MODE (value);
|
h ^= GET_MODE (value);
|
}
|
}
|
return h;
|
return h;
|
}
|
}
|
|
|
/* Returns nonzero if the value represented by X (really a ...)
|
/* Returns nonzero if the value represented by X (really a ...)
|
is the same as that represented by Y (really a ...) */
|
is the same as that represented by Y (really a ...) */
|
static int
|
static int
|
const_double_htab_eq (const void *x, const void *y)
|
const_double_htab_eq (const void *x, const void *y)
|
{
|
{
|
const_rtx const a = (const_rtx)x, b = (const_rtx)y;
|
const_rtx const a = (const_rtx)x, b = (const_rtx)y;
|
|
|
if (GET_MODE (a) != GET_MODE (b))
|
if (GET_MODE (a) != GET_MODE (b))
|
return 0;
|
return 0;
|
if (GET_MODE (a) == VOIDmode)
|
if (GET_MODE (a) == VOIDmode)
|
return (CONST_DOUBLE_LOW (a) == CONST_DOUBLE_LOW (b)
|
return (CONST_DOUBLE_LOW (a) == CONST_DOUBLE_LOW (b)
|
&& CONST_DOUBLE_HIGH (a) == CONST_DOUBLE_HIGH (b));
|
&& CONST_DOUBLE_HIGH (a) == CONST_DOUBLE_HIGH (b));
|
else
|
else
|
return real_identical (CONST_DOUBLE_REAL_VALUE (a),
|
return real_identical (CONST_DOUBLE_REAL_VALUE (a),
|
CONST_DOUBLE_REAL_VALUE (b));
|
CONST_DOUBLE_REAL_VALUE (b));
|
}
|
}
|
|
|
/* Returns a hash code for X (which is really a CONST_FIXED). */
|
/* Returns a hash code for X (which is really a CONST_FIXED). */
|
|
|
static hashval_t
|
static hashval_t
|
const_fixed_htab_hash (const void *x)
|
const_fixed_htab_hash (const void *x)
|
{
|
{
|
const_rtx const value = (const_rtx) x;
|
const_rtx const value = (const_rtx) x;
|
hashval_t h;
|
hashval_t h;
|
|
|
h = fixed_hash (CONST_FIXED_VALUE (value));
|
h = fixed_hash (CONST_FIXED_VALUE (value));
|
/* MODE is used in the comparison, so it should be in the hash. */
|
/* MODE is used in the comparison, so it should be in the hash. */
|
h ^= GET_MODE (value);
|
h ^= GET_MODE (value);
|
return h;
|
return h;
|
}
|
}
|
|
|
/* Returns nonzero if the value represented by X (really a ...)
|
/* Returns nonzero if the value represented by X (really a ...)
|
is the same as that represented by Y (really a ...). */
|
is the same as that represented by Y (really a ...). */
|
|
|
static int
|
static int
|
const_fixed_htab_eq (const void *x, const void *y)
|
const_fixed_htab_eq (const void *x, const void *y)
|
{
|
{
|
const_rtx const a = (const_rtx) x, b = (const_rtx) y;
|
const_rtx const a = (const_rtx) x, b = (const_rtx) y;
|
|
|
if (GET_MODE (a) != GET_MODE (b))
|
if (GET_MODE (a) != GET_MODE (b))
|
return 0;
|
return 0;
|
return fixed_identical (CONST_FIXED_VALUE (a), CONST_FIXED_VALUE (b));
|
return fixed_identical (CONST_FIXED_VALUE (a), CONST_FIXED_VALUE (b));
|
}
|
}
|
|
|
/* Returns a hash code for X (which is a really a mem_attrs *). */
|
/* Returns a hash code for X (which is a really a mem_attrs *). */
|
|
|
static hashval_t
|
static hashval_t
|
mem_attrs_htab_hash (const void *x)
|
mem_attrs_htab_hash (const void *x)
|
{
|
{
|
const mem_attrs *const p = (const mem_attrs *) x;
|
const mem_attrs *const p = (const mem_attrs *) x;
|
|
|
return (p->alias ^ (p->align * 1000)
|
return (p->alias ^ (p->align * 1000)
|
^ (p->addrspace * 4000)
|
^ (p->addrspace * 4000)
|
^ ((p->offset ? INTVAL (p->offset) : 0) * 50000)
|
^ ((p->offset ? INTVAL (p->offset) : 0) * 50000)
|
^ ((p->size ? INTVAL (p->size) : 0) * 2500000)
|
^ ((p->size ? INTVAL (p->size) : 0) * 2500000)
|
^ (size_t) iterative_hash_expr (p->expr, 0));
|
^ (size_t) iterative_hash_expr (p->expr, 0));
|
}
|
}
|
|
|
/* Returns nonzero if the value represented by X (which is really a
|
/* Returns nonzero if the value represented by X (which is really a
|
mem_attrs *) is the same as that given by Y (which is also really a
|
mem_attrs *) is the same as that given by Y (which is also really a
|
mem_attrs *). */
|
mem_attrs *). */
|
|
|
static int
|
static int
|
mem_attrs_htab_eq (const void *x, const void *y)
|
mem_attrs_htab_eq (const void *x, const void *y)
|
{
|
{
|
const mem_attrs *const p = (const mem_attrs *) x;
|
const mem_attrs *const p = (const mem_attrs *) x;
|
const mem_attrs *const q = (const mem_attrs *) y;
|
const mem_attrs *const q = (const mem_attrs *) y;
|
|
|
return (p->alias == q->alias && p->offset == q->offset
|
return (p->alias == q->alias && p->offset == q->offset
|
&& p->size == q->size && p->align == q->align
|
&& p->size == q->size && p->align == q->align
|
&& p->addrspace == q->addrspace
|
&& p->addrspace == q->addrspace
|
&& (p->expr == q->expr
|
&& (p->expr == q->expr
|
|| (p->expr != NULL_TREE && q->expr != NULL_TREE
|
|| (p->expr != NULL_TREE && q->expr != NULL_TREE
|
&& operand_equal_p (p->expr, q->expr, 0))));
|
&& operand_equal_p (p->expr, q->expr, 0))));
|
}
|
}
|
|
|
/* Allocate a new mem_attrs structure and insert it into the hash table if
|
/* Allocate a new mem_attrs structure and insert it into the hash table if
|
one identical to it is not already in the table. We are doing this for
|
one identical to it is not already in the table. We are doing this for
|
MEM of mode MODE. */
|
MEM of mode MODE. */
|
|
|
static mem_attrs *
|
static mem_attrs *
|
get_mem_attrs (alias_set_type alias, tree expr, rtx offset, rtx size,
|
get_mem_attrs (alias_set_type alias, tree expr, rtx offset, rtx size,
|
unsigned int align, addr_space_t addrspace, enum machine_mode mode)
|
unsigned int align, addr_space_t addrspace, enum machine_mode mode)
|
{
|
{
|
mem_attrs attrs;
|
mem_attrs attrs;
|
void **slot;
|
void **slot;
|
|
|
/* If everything is the default, we can just return zero.
|
/* If everything is the default, we can just return zero.
|
This must match what the corresponding MEM_* macros return when the
|
This must match what the corresponding MEM_* macros return when the
|
field is not present. */
|
field is not present. */
|
if (alias == 0 && expr == 0 && offset == 0 && addrspace == 0
|
if (alias == 0 && expr == 0 && offset == 0 && addrspace == 0
|
&& (size == 0
|
&& (size == 0
|
|| (mode != BLKmode && GET_MODE_SIZE (mode) == INTVAL (size)))
|
|| (mode != BLKmode && GET_MODE_SIZE (mode) == INTVAL (size)))
|
&& (STRICT_ALIGNMENT && mode != BLKmode
|
&& (STRICT_ALIGNMENT && mode != BLKmode
|
? align == GET_MODE_ALIGNMENT (mode) : align == BITS_PER_UNIT))
|
? align == GET_MODE_ALIGNMENT (mode) : align == BITS_PER_UNIT))
|
return 0;
|
return 0;
|
|
|
attrs.alias = alias;
|
attrs.alias = alias;
|
attrs.expr = expr;
|
attrs.expr = expr;
|
attrs.offset = offset;
|
attrs.offset = offset;
|
attrs.size = size;
|
attrs.size = size;
|
attrs.align = align;
|
attrs.align = align;
|
attrs.addrspace = addrspace;
|
attrs.addrspace = addrspace;
|
|
|
slot = htab_find_slot (mem_attrs_htab, &attrs, INSERT);
|
slot = htab_find_slot (mem_attrs_htab, &attrs, INSERT);
|
if (*slot == 0)
|
if (*slot == 0)
|
{
|
{
|
*slot = ggc_alloc (sizeof (mem_attrs));
|
*slot = ggc_alloc (sizeof (mem_attrs));
|
memcpy (*slot, &attrs, sizeof (mem_attrs));
|
memcpy (*slot, &attrs, sizeof (mem_attrs));
|
}
|
}
|
|
|
return (mem_attrs *) *slot;
|
return (mem_attrs *) *slot;
|
}
|
}
|
|
|
/* Returns a hash code for X (which is a really a reg_attrs *). */
|
/* Returns a hash code for X (which is a really a reg_attrs *). */
|
|
|
static hashval_t
|
static hashval_t
|
reg_attrs_htab_hash (const void *x)
|
reg_attrs_htab_hash (const void *x)
|
{
|
{
|
const reg_attrs *const p = (const reg_attrs *) x;
|
const reg_attrs *const p = (const reg_attrs *) x;
|
|
|
return ((p->offset * 1000) ^ (long) p->decl);
|
return ((p->offset * 1000) ^ (long) p->decl);
|
}
|
}
|
|
|
/* Returns nonzero if the value represented by X (which is really a
|
/* Returns nonzero if the value represented by X (which is really a
|
reg_attrs *) is the same as that given by Y (which is also really a
|
reg_attrs *) is the same as that given by Y (which is also really a
|
reg_attrs *). */
|
reg_attrs *). */
|
|
|
static int
|
static int
|
reg_attrs_htab_eq (const void *x, const void *y)
|
reg_attrs_htab_eq (const void *x, const void *y)
|
{
|
{
|
const reg_attrs *const p = (const reg_attrs *) x;
|
const reg_attrs *const p = (const reg_attrs *) x;
|
const reg_attrs *const q = (const reg_attrs *) y;
|
const reg_attrs *const q = (const reg_attrs *) y;
|
|
|
return (p->decl == q->decl && p->offset == q->offset);
|
return (p->decl == q->decl && p->offset == q->offset);
|
}
|
}
|
/* Allocate a new reg_attrs structure and insert it into the hash table if
|
/* Allocate a new reg_attrs structure and insert it into the hash table if
|
one identical to it is not already in the table. We are doing this for
|
one identical to it is not already in the table. We are doing this for
|
MEM of mode MODE. */
|
MEM of mode MODE. */
|
|
|
static reg_attrs *
|
static reg_attrs *
|
get_reg_attrs (tree decl, int offset)
|
get_reg_attrs (tree decl, int offset)
|
{
|
{
|
reg_attrs attrs;
|
reg_attrs attrs;
|
void **slot;
|
void **slot;
|
|
|
/* If everything is the default, we can just return zero. */
|
/* If everything is the default, we can just return zero. */
|
if (decl == 0 && offset == 0)
|
if (decl == 0 && offset == 0)
|
return 0;
|
return 0;
|
|
|
attrs.decl = decl;
|
attrs.decl = decl;
|
attrs.offset = offset;
|
attrs.offset = offset;
|
|
|
slot = htab_find_slot (reg_attrs_htab, &attrs, INSERT);
|
slot = htab_find_slot (reg_attrs_htab, &attrs, INSERT);
|
if (*slot == 0)
|
if (*slot == 0)
|
{
|
{
|
*slot = ggc_alloc (sizeof (reg_attrs));
|
*slot = ggc_alloc (sizeof (reg_attrs));
|
memcpy (*slot, &attrs, sizeof (reg_attrs));
|
memcpy (*slot, &attrs, sizeof (reg_attrs));
|
}
|
}
|
|
|
return (reg_attrs *) *slot;
|
return (reg_attrs *) *slot;
|
}
|
}
|
|
|
|
|
#if !HAVE_blockage
|
#if !HAVE_blockage
|
/* Generate an empty ASM_INPUT, which is used to block attempts to schedule
|
/* Generate an empty ASM_INPUT, which is used to block attempts to schedule
|
across this insn. */
|
across this insn. */
|
|
|
rtx
|
rtx
|
gen_blockage (void)
|
gen_blockage (void)
|
{
|
{
|
rtx x = gen_rtx_ASM_INPUT (VOIDmode, "");
|
rtx x = gen_rtx_ASM_INPUT (VOIDmode, "");
|
MEM_VOLATILE_P (x) = true;
|
MEM_VOLATILE_P (x) = true;
|
return x;
|
return x;
|
}
|
}
|
#endif
|
#endif
|
|
|
|
|
/* Generate a new REG rtx. Make sure ORIGINAL_REGNO is set properly, and
|
/* Generate a new REG rtx. Make sure ORIGINAL_REGNO is set properly, and
|
don't attempt to share with the various global pieces of rtl (such as
|
don't attempt to share with the various global pieces of rtl (such as
|
frame_pointer_rtx). */
|
frame_pointer_rtx). */
|
|
|
rtx
|
rtx
|
gen_raw_REG (enum machine_mode mode, int regno)
|
gen_raw_REG (enum machine_mode mode, int regno)
|
{
|
{
|
rtx x = gen_rtx_raw_REG (mode, regno);
|
rtx x = gen_rtx_raw_REG (mode, regno);
|
ORIGINAL_REGNO (x) = regno;
|
ORIGINAL_REGNO (x) = regno;
|
return x;
|
return x;
|
}
|
}
|
|
|
/* There are some RTL codes that require special attention; the generation
|
/* There are some RTL codes that require special attention; the generation
|
functions do the raw handling. If you add to this list, modify
|
functions do the raw handling. If you add to this list, modify
|
special_rtx in gengenrtl.c as well. */
|
special_rtx in gengenrtl.c as well. */
|
|
|
rtx
|
rtx
|
gen_rtx_CONST_INT (enum machine_mode mode ATTRIBUTE_UNUSED, HOST_WIDE_INT arg)
|
gen_rtx_CONST_INT (enum machine_mode mode ATTRIBUTE_UNUSED, HOST_WIDE_INT arg)
|
{
|
{
|
void **slot;
|
void **slot;
|
|
|
if (arg >= - MAX_SAVED_CONST_INT && arg <= MAX_SAVED_CONST_INT)
|
if (arg >= - MAX_SAVED_CONST_INT && arg <= MAX_SAVED_CONST_INT)
|
return const_int_rtx[arg + MAX_SAVED_CONST_INT];
|
return const_int_rtx[arg + MAX_SAVED_CONST_INT];
|
|
|
#if STORE_FLAG_VALUE != 1 && STORE_FLAG_VALUE != -1
|
#if STORE_FLAG_VALUE != 1 && STORE_FLAG_VALUE != -1
|
if (const_true_rtx && arg == STORE_FLAG_VALUE)
|
if (const_true_rtx && arg == STORE_FLAG_VALUE)
|
return const_true_rtx;
|
return const_true_rtx;
|
#endif
|
#endif
|
|
|
/* Look up the CONST_INT in the hash table. */
|
/* Look up the CONST_INT in the hash table. */
|
slot = htab_find_slot_with_hash (const_int_htab, &arg,
|
slot = htab_find_slot_with_hash (const_int_htab, &arg,
|
(hashval_t) arg, INSERT);
|
(hashval_t) arg, INSERT);
|
if (*slot == 0)
|
if (*slot == 0)
|
*slot = gen_rtx_raw_CONST_INT (VOIDmode, arg);
|
*slot = gen_rtx_raw_CONST_INT (VOIDmode, arg);
|
|
|
return (rtx) *slot;
|
return (rtx) *slot;
|
}
|
}
|
|
|
rtx
|
rtx
|
gen_int_mode (HOST_WIDE_INT c, enum machine_mode mode)
|
gen_int_mode (HOST_WIDE_INT c, enum machine_mode mode)
|
{
|
{
|
return GEN_INT (trunc_int_for_mode (c, mode));
|
return GEN_INT (trunc_int_for_mode (c, mode));
|
}
|
}
|
|
|
/* CONST_DOUBLEs might be created from pairs of integers, or from
|
/* CONST_DOUBLEs might be created from pairs of integers, or from
|
REAL_VALUE_TYPEs. Also, their length is known only at run time,
|
REAL_VALUE_TYPEs. Also, their length is known only at run time,
|
so we cannot use gen_rtx_raw_CONST_DOUBLE. */
|
so we cannot use gen_rtx_raw_CONST_DOUBLE. */
|
|
|
/* Determine whether REAL, a CONST_DOUBLE, already exists in the
|
/* Determine whether REAL, a CONST_DOUBLE, already exists in the
|
hash table. If so, return its counterpart; otherwise add it
|
hash table. If so, return its counterpart; otherwise add it
|
to the hash table and return it. */
|
to the hash table and return it. */
|
static rtx
|
static rtx
|
lookup_const_double (rtx real)
|
lookup_const_double (rtx real)
|
{
|
{
|
void **slot = htab_find_slot (const_double_htab, real, INSERT);
|
void **slot = htab_find_slot (const_double_htab, real, INSERT);
|
if (*slot == 0)
|
if (*slot == 0)
|
*slot = real;
|
*slot = real;
|
|
|
return (rtx) *slot;
|
return (rtx) *slot;
|
}
|
}
|
|
|
/* Return a CONST_DOUBLE rtx for a floating-point value specified by
|
/* Return a CONST_DOUBLE rtx for a floating-point value specified by
|
VALUE in mode MODE. */
|
VALUE in mode MODE. */
|
rtx
|
rtx
|
const_double_from_real_value (REAL_VALUE_TYPE value, enum machine_mode mode)
|
const_double_from_real_value (REAL_VALUE_TYPE value, enum machine_mode mode)
|
{
|
{
|
rtx real = rtx_alloc (CONST_DOUBLE);
|
rtx real = rtx_alloc (CONST_DOUBLE);
|
PUT_MODE (real, mode);
|
PUT_MODE (real, mode);
|
|
|
real->u.rv = value;
|
real->u.rv = value;
|
|
|
return lookup_const_double (real);
|
return lookup_const_double (real);
|
}
|
}
|
|
|
/* Determine whether FIXED, a CONST_FIXED, already exists in the
|
/* Determine whether FIXED, a CONST_FIXED, already exists in the
|
hash table. If so, return its counterpart; otherwise add it
|
hash table. If so, return its counterpart; otherwise add it
|
to the hash table and return it. */
|
to the hash table and return it. */
|
|
|
static rtx
|
static rtx
|
lookup_const_fixed (rtx fixed)
|
lookup_const_fixed (rtx fixed)
|
{
|
{
|
void **slot = htab_find_slot (const_fixed_htab, fixed, INSERT);
|
void **slot = htab_find_slot (const_fixed_htab, fixed, INSERT);
|
if (*slot == 0)
|
if (*slot == 0)
|
*slot = fixed;
|
*slot = fixed;
|
|
|
return (rtx) *slot;
|
return (rtx) *slot;
|
}
|
}
|
|
|
/* Return a CONST_FIXED rtx for a fixed-point value specified by
|
/* Return a CONST_FIXED rtx for a fixed-point value specified by
|
VALUE in mode MODE. */
|
VALUE in mode MODE. */
|
|
|
rtx
|
rtx
|
const_fixed_from_fixed_value (FIXED_VALUE_TYPE value, enum machine_mode mode)
|
const_fixed_from_fixed_value (FIXED_VALUE_TYPE value, enum machine_mode mode)
|
{
|
{
|
rtx fixed = rtx_alloc (CONST_FIXED);
|
rtx fixed = rtx_alloc (CONST_FIXED);
|
PUT_MODE (fixed, mode);
|
PUT_MODE (fixed, mode);
|
|
|
fixed->u.fv = value;
|
fixed->u.fv = value;
|
|
|
return lookup_const_fixed (fixed);
|
return lookup_const_fixed (fixed);
|
}
|
}
|
|
|
/* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair
|
/* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair
|
of ints: I0 is the low-order word and I1 is the high-order word.
|
of ints: I0 is the low-order word and I1 is the high-order word.
|
Do not use this routine for non-integer modes; convert to
|
Do not use this routine for non-integer modes; convert to
|
REAL_VALUE_TYPE and use CONST_DOUBLE_FROM_REAL_VALUE. */
|
REAL_VALUE_TYPE and use CONST_DOUBLE_FROM_REAL_VALUE. */
|
|
|
rtx
|
rtx
|
immed_double_const (HOST_WIDE_INT i0, HOST_WIDE_INT i1, enum machine_mode mode)
|
immed_double_const (HOST_WIDE_INT i0, HOST_WIDE_INT i1, enum machine_mode mode)
|
{
|
{
|
rtx value;
|
rtx value;
|
unsigned int i;
|
unsigned int i;
|
|
|
/* There are the following cases (note that there are no modes with
|
/* There are the following cases (note that there are no modes with
|
HOST_BITS_PER_WIDE_INT < GET_MODE_BITSIZE (mode) < 2 * HOST_BITS_PER_WIDE_INT):
|
HOST_BITS_PER_WIDE_INT < GET_MODE_BITSIZE (mode) < 2 * HOST_BITS_PER_WIDE_INT):
|
|
|
1) If GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT, then we use
|
1) If GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT, then we use
|
gen_int_mode.
|
gen_int_mode.
|
2) GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT, but the value of
|
2) GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT, but the value of
|
the integer fits into HOST_WIDE_INT anyway (i.e., i1 consists only
|
the integer fits into HOST_WIDE_INT anyway (i.e., i1 consists only
|
from copies of the sign bit, and sign of i0 and i1 are the same), then
|
from copies of the sign bit, and sign of i0 and i1 are the same), then
|
we return a CONST_INT for i0.
|
we return a CONST_INT for i0.
|
3) Otherwise, we create a CONST_DOUBLE for i0 and i1. */
|
3) Otherwise, we create a CONST_DOUBLE for i0 and i1. */
|
if (mode != VOIDmode)
|
if (mode != VOIDmode)
|
{
|
{
|
gcc_assert (GET_MODE_CLASS (mode) == MODE_INT
|
gcc_assert (GET_MODE_CLASS (mode) == MODE_INT
|
|| GET_MODE_CLASS (mode) == MODE_PARTIAL_INT
|
|| GET_MODE_CLASS (mode) == MODE_PARTIAL_INT
|
/* We can get a 0 for an error mark. */
|
/* We can get a 0 for an error mark. */
|
|| GET_MODE_CLASS (mode) == MODE_VECTOR_INT
|
|| GET_MODE_CLASS (mode) == MODE_VECTOR_INT
|
|| GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT);
|
|| GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT);
|
|
|
if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
|
if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
|
return gen_int_mode (i0, mode);
|
return gen_int_mode (i0, mode);
|
|
|
gcc_assert (GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT);
|
gcc_assert (GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT);
|
}
|
}
|
|
|
/* If this integer fits in one word, return a CONST_INT. */
|
/* If this integer fits in one word, return a CONST_INT. */
|
if ((i1 == 0 && i0 >= 0) || (i1 == ~0 && i0 < 0))
|
if ((i1 == 0 && i0 >= 0) || (i1 == ~0 && i0 < 0))
|
return GEN_INT (i0);
|
return GEN_INT (i0);
|
|
|
/* We use VOIDmode for integers. */
|
/* We use VOIDmode for integers. */
|
value = rtx_alloc (CONST_DOUBLE);
|
value = rtx_alloc (CONST_DOUBLE);
|
PUT_MODE (value, VOIDmode);
|
PUT_MODE (value, VOIDmode);
|
|
|
CONST_DOUBLE_LOW (value) = i0;
|
CONST_DOUBLE_LOW (value) = i0;
|
CONST_DOUBLE_HIGH (value) = i1;
|
CONST_DOUBLE_HIGH (value) = i1;
|
|
|
for (i = 2; i < (sizeof CONST_DOUBLE_FORMAT - 1); i++)
|
for (i = 2; i < (sizeof CONST_DOUBLE_FORMAT - 1); i++)
|
XWINT (value, i) = 0;
|
XWINT (value, i) = 0;
|
|
|
return lookup_const_double (value);
|
return lookup_const_double (value);
|
}
|
}
|
|
|
rtx
|
rtx
|
gen_rtx_REG (enum machine_mode mode, unsigned int regno)
|
gen_rtx_REG (enum machine_mode mode, unsigned int regno)
|
{
|
{
|
/* In case the MD file explicitly references the frame pointer, have
|
/* In case the MD file explicitly references the frame pointer, have
|
all such references point to the same frame pointer. This is
|
all such references point to the same frame pointer. This is
|
used during frame pointer elimination to distinguish the explicit
|
used during frame pointer elimination to distinguish the explicit
|
references to these registers from pseudos that happened to be
|
references to these registers from pseudos that happened to be
|
assigned to them.
|
assigned to them.
|
|
|
If we have eliminated the frame pointer or arg pointer, we will
|
If we have eliminated the frame pointer or arg pointer, we will
|
be using it as a normal register, for example as a spill
|
be using it as a normal register, for example as a spill
|
register. In such cases, we might be accessing it in a mode that
|
register. In such cases, we might be accessing it in a mode that
|
is not Pmode and therefore cannot use the pre-allocated rtx.
|
is not Pmode and therefore cannot use the pre-allocated rtx.
|
|
|
Also don't do this when we are making new REGs in reload, since
|
Also don't do this when we are making new REGs in reload, since
|
we don't want to get confused with the real pointers. */
|
we don't want to get confused with the real pointers. */
|
|
|
if (mode == Pmode && !reload_in_progress)
|
if (mode == Pmode && !reload_in_progress)
|
{
|
{
|
if (regno == FRAME_POINTER_REGNUM
|
if (regno == FRAME_POINTER_REGNUM
|
&& (!reload_completed || frame_pointer_needed))
|
&& (!reload_completed || frame_pointer_needed))
|
return frame_pointer_rtx;
|
return frame_pointer_rtx;
|
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
|
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
|
if (regno == HARD_FRAME_POINTER_REGNUM
|
if (regno == HARD_FRAME_POINTER_REGNUM
|
&& (!reload_completed || frame_pointer_needed))
|
&& (!reload_completed || frame_pointer_needed))
|
return hard_frame_pointer_rtx;
|
return hard_frame_pointer_rtx;
|
#endif
|
#endif
|
#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM && HARD_FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
|
#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM && HARD_FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
|
if (regno == ARG_POINTER_REGNUM)
|
if (regno == ARG_POINTER_REGNUM)
|
return arg_pointer_rtx;
|
return arg_pointer_rtx;
|
#endif
|
#endif
|
#ifdef RETURN_ADDRESS_POINTER_REGNUM
|
#ifdef RETURN_ADDRESS_POINTER_REGNUM
|
if (regno == RETURN_ADDRESS_POINTER_REGNUM)
|
if (regno == RETURN_ADDRESS_POINTER_REGNUM)
|
return return_address_pointer_rtx;
|
return return_address_pointer_rtx;
|
#endif
|
#endif
|
if (regno == (unsigned) PIC_OFFSET_TABLE_REGNUM
|
if (regno == (unsigned) PIC_OFFSET_TABLE_REGNUM
|
&& fixed_regs[PIC_OFFSET_TABLE_REGNUM])
|
&& fixed_regs[PIC_OFFSET_TABLE_REGNUM])
|
return pic_offset_table_rtx;
|
return pic_offset_table_rtx;
|
if (regno == STACK_POINTER_REGNUM)
|
if (regno == STACK_POINTER_REGNUM)
|
return stack_pointer_rtx;
|
return stack_pointer_rtx;
|
}
|
}
|
|
|
#if 0
|
#if 0
|
/* If the per-function register table has been set up, try to re-use
|
/* If the per-function register table has been set up, try to re-use
|
an existing entry in that table to avoid useless generation of RTL.
|
an existing entry in that table to avoid useless generation of RTL.
|
|
|
This code is disabled for now until we can fix the various backends
|
This code is disabled for now until we can fix the various backends
|
which depend on having non-shared hard registers in some cases. Long
|
which depend on having non-shared hard registers in some cases. Long
|
term we want to re-enable this code as it can significantly cut down
|
term we want to re-enable this code as it can significantly cut down
|
on the amount of useless RTL that gets generated.
|
on the amount of useless RTL that gets generated.
|
|
|
We'll also need to fix some code that runs after reload that wants to
|
We'll also need to fix some code that runs after reload that wants to
|
set ORIGINAL_REGNO. */
|
set ORIGINAL_REGNO. */
|
|
|
if (cfun
|
if (cfun
|
&& cfun->emit
|
&& cfun->emit
|
&& regno_reg_rtx
|
&& regno_reg_rtx
|
&& regno < FIRST_PSEUDO_REGISTER
|
&& regno < FIRST_PSEUDO_REGISTER
|
&& reg_raw_mode[regno] == mode)
|
&& reg_raw_mode[regno] == mode)
|
return regno_reg_rtx[regno];
|
return regno_reg_rtx[regno];
|
#endif
|
#endif
|
|
|
return gen_raw_REG (mode, regno);
|
return gen_raw_REG (mode, regno);
|
}
|
}
|
|
|
rtx
|
rtx
|
gen_rtx_MEM (enum machine_mode mode, rtx addr)
|
gen_rtx_MEM (enum machine_mode mode, rtx addr)
|
{
|
{
|
rtx rt = gen_rtx_raw_MEM (mode, addr);
|
rtx rt = gen_rtx_raw_MEM (mode, addr);
|
|
|
/* This field is not cleared by the mere allocation of the rtx, so
|
/* This field is not cleared by the mere allocation of the rtx, so
|
we clear it here. */
|
we clear it here. */
|
MEM_ATTRS (rt) = 0;
|
MEM_ATTRS (rt) = 0;
|
|
|
return rt;
|
return rt;
|
}
|
}
|
|
|
/* Generate a memory referring to non-trapping constant memory. */
|
/* Generate a memory referring to non-trapping constant memory. */
|
|
|
rtx
|
rtx
|
gen_const_mem (enum machine_mode mode, rtx addr)
|
gen_const_mem (enum machine_mode mode, rtx addr)
|
{
|
{
|
rtx mem = gen_rtx_MEM (mode, addr);
|
rtx mem = gen_rtx_MEM (mode, addr);
|
MEM_READONLY_P (mem) = 1;
|
MEM_READONLY_P (mem) = 1;
|
MEM_NOTRAP_P (mem) = 1;
|
MEM_NOTRAP_P (mem) = 1;
|
return mem;
|
return mem;
|
}
|
}
|
|
|
/* Generate a MEM referring to fixed portions of the frame, e.g., register
|
/* Generate a MEM referring to fixed portions of the frame, e.g., register
|
save areas. */
|
save areas. */
|
|
|
rtx
|
rtx
|
gen_frame_mem (enum machine_mode mode, rtx addr)
|
gen_frame_mem (enum machine_mode mode, rtx addr)
|
{
|
{
|
rtx mem = gen_rtx_MEM (mode, addr);
|
rtx mem = gen_rtx_MEM (mode, addr);
|
MEM_NOTRAP_P (mem) = 1;
|
MEM_NOTRAP_P (mem) = 1;
|
set_mem_alias_set (mem, get_frame_alias_set ());
|
set_mem_alias_set (mem, get_frame_alias_set ());
|
return mem;
|
return mem;
|
}
|
}
|
|
|
/* Generate a MEM referring to a temporary use of the stack, not part
|
/* Generate a MEM referring to a temporary use of the stack, not part
|
of the fixed stack frame. For example, something which is pushed
|
of the fixed stack frame. For example, something which is pushed
|
by a target splitter. */
|
by a target splitter. */
|
rtx
|
rtx
|
gen_tmp_stack_mem (enum machine_mode mode, rtx addr)
|
gen_tmp_stack_mem (enum machine_mode mode, rtx addr)
|
{
|
{
|
rtx mem = gen_rtx_MEM (mode, addr);
|
rtx mem = gen_rtx_MEM (mode, addr);
|
MEM_NOTRAP_P (mem) = 1;
|
MEM_NOTRAP_P (mem) = 1;
|
if (!cfun->calls_alloca)
|
if (!cfun->calls_alloca)
|
set_mem_alias_set (mem, get_frame_alias_set ());
|
set_mem_alias_set (mem, get_frame_alias_set ());
|
return mem;
|
return mem;
|
}
|
}
|
|
|
/* We want to create (subreg:OMODE (obj:IMODE) OFFSET). Return true if
|
/* We want to create (subreg:OMODE (obj:IMODE) OFFSET). Return true if
|
this construct would be valid, and false otherwise. */
|
this construct would be valid, and false otherwise. */
|
|
|
bool
|
bool
|
validate_subreg (enum machine_mode omode, enum machine_mode imode,
|
validate_subreg (enum machine_mode omode, enum machine_mode imode,
|
const_rtx reg, unsigned int offset)
|
const_rtx reg, unsigned int offset)
|
{
|
{
|
unsigned int isize = GET_MODE_SIZE (imode);
|
unsigned int isize = GET_MODE_SIZE (imode);
|
unsigned int osize = GET_MODE_SIZE (omode);
|
unsigned int osize = GET_MODE_SIZE (omode);
|
|
|
/* All subregs must be aligned. */
|
/* All subregs must be aligned. */
|
if (offset % osize != 0)
|
if (offset % osize != 0)
|
return false;
|
return false;
|
|
|
/* The subreg offset cannot be outside the inner object. */
|
/* The subreg offset cannot be outside the inner object. */
|
if (offset >= isize)
|
if (offset >= isize)
|
return false;
|
return false;
|
|
|
/* ??? This should not be here. Temporarily continue to allow word_mode
|
/* ??? This should not be here. Temporarily continue to allow word_mode
|
subregs of anything. The most common offender is (subreg:SI (reg:DF)).
|
subregs of anything. The most common offender is (subreg:SI (reg:DF)).
|
Generally, backends are doing something sketchy but it'll take time to
|
Generally, backends are doing something sketchy but it'll take time to
|
fix them all. */
|
fix them all. */
|
if (omode == word_mode)
|
if (omode == word_mode)
|
;
|
;
|
/* ??? Similarly, e.g. with (subreg:DF (reg:TI)). Though store_bit_field
|
/* ??? Similarly, e.g. with (subreg:DF (reg:TI)). Though store_bit_field
|
is the culprit here, and not the backends. */
|
is the culprit here, and not the backends. */
|
else if (osize >= UNITS_PER_WORD && isize >= osize)
|
else if (osize >= UNITS_PER_WORD && isize >= osize)
|
;
|
;
|
/* Allow component subregs of complex and vector. Though given the below
|
/* Allow component subregs of complex and vector. Though given the below
|
extraction rules, it's not always clear what that means. */
|
extraction rules, it's not always clear what that means. */
|
else if ((COMPLEX_MODE_P (imode) || VECTOR_MODE_P (imode))
|
else if ((COMPLEX_MODE_P (imode) || VECTOR_MODE_P (imode))
|
&& GET_MODE_INNER (imode) == omode)
|
&& GET_MODE_INNER (imode) == omode)
|
;
|
;
|
/* ??? x86 sse code makes heavy use of *paradoxical* vector subregs,
|
/* ??? x86 sse code makes heavy use of *paradoxical* vector subregs,
|
i.e. (subreg:V4SF (reg:SF) 0). This surely isn't the cleanest way to
|
i.e. (subreg:V4SF (reg:SF) 0). This surely isn't the cleanest way to
|
represent this. It's questionable if this ought to be represented at
|
represent this. It's questionable if this ought to be represented at
|
all -- why can't this all be hidden in post-reload splitters that make
|
all -- why can't this all be hidden in post-reload splitters that make
|
arbitrarily mode changes to the registers themselves. */
|
arbitrarily mode changes to the registers themselves. */
|
else if (VECTOR_MODE_P (omode) && GET_MODE_INNER (omode) == imode)
|
else if (VECTOR_MODE_P (omode) && GET_MODE_INNER (omode) == imode)
|
;
|
;
|
/* Subregs involving floating point modes are not allowed to
|
/* Subregs involving floating point modes are not allowed to
|
change size. Therefore (subreg:DI (reg:DF) 0) is fine, but
|
change size. Therefore (subreg:DI (reg:DF) 0) is fine, but
|
(subreg:SI (reg:DF) 0) isn't. */
|
(subreg:SI (reg:DF) 0) isn't. */
|
else if (FLOAT_MODE_P (imode) || FLOAT_MODE_P (omode))
|
else if (FLOAT_MODE_P (imode) || FLOAT_MODE_P (omode))
|
{
|
{
|
if (isize != osize)
|
if (isize != osize)
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Paradoxical subregs must have offset zero. */
|
/* Paradoxical subregs must have offset zero. */
|
if (osize > isize)
|
if (osize > isize)
|
return offset == 0;
|
return offset == 0;
|
|
|
/* This is a normal subreg. Verify that the offset is representable. */
|
/* This is a normal subreg. Verify that the offset is representable. */
|
|
|
/* For hard registers, we already have most of these rules collected in
|
/* For hard registers, we already have most of these rules collected in
|
subreg_offset_representable_p. */
|
subreg_offset_representable_p. */
|
if (reg && REG_P (reg) && HARD_REGISTER_P (reg))
|
if (reg && REG_P (reg) && HARD_REGISTER_P (reg))
|
{
|
{
|
unsigned int regno = REGNO (reg);
|
unsigned int regno = REGNO (reg);
|
|
|
#ifdef CANNOT_CHANGE_MODE_CLASS
|
#ifdef CANNOT_CHANGE_MODE_CLASS
|
if ((COMPLEX_MODE_P (imode) || VECTOR_MODE_P (imode))
|
if ((COMPLEX_MODE_P (imode) || VECTOR_MODE_P (imode))
|
&& GET_MODE_INNER (imode) == omode)
|
&& GET_MODE_INNER (imode) == omode)
|
;
|
;
|
else if (REG_CANNOT_CHANGE_MODE_P (regno, imode, omode))
|
else if (REG_CANNOT_CHANGE_MODE_P (regno, imode, omode))
|
return false;
|
return false;
|
#endif
|
#endif
|
|
|
return subreg_offset_representable_p (regno, imode, offset, omode);
|
return subreg_offset_representable_p (regno, imode, offset, omode);
|
}
|
}
|
|
|
/* For pseudo registers, we want most of the same checks. Namely:
|
/* For pseudo registers, we want most of the same checks. Namely:
|
If the register no larger than a word, the subreg must be lowpart.
|
If the register no larger than a word, the subreg must be lowpart.
|
If the register is larger than a word, the subreg must be the lowpart
|
If the register is larger than a word, the subreg must be the lowpart
|
of a subword. A subreg does *not* perform arbitrary bit extraction.
|
of a subword. A subreg does *not* perform arbitrary bit extraction.
|
Given that we've already checked mode/offset alignment, we only have
|
Given that we've already checked mode/offset alignment, we only have
|
to check subword subregs here. */
|
to check subword subregs here. */
|
if (osize < UNITS_PER_WORD)
|
if (osize < UNITS_PER_WORD)
|
{
|
{
|
enum machine_mode wmode = isize > UNITS_PER_WORD ? word_mode : imode;
|
enum machine_mode wmode = isize > UNITS_PER_WORD ? word_mode : imode;
|
unsigned int low_off = subreg_lowpart_offset (omode, wmode);
|
unsigned int low_off = subreg_lowpart_offset (omode, wmode);
|
if (offset % UNITS_PER_WORD != low_off)
|
if (offset % UNITS_PER_WORD != low_off)
|
return false;
|
return false;
|
}
|
}
|
return true;
|
return true;
|
}
|
}
|
|
|
rtx
|
rtx
|
gen_rtx_SUBREG (enum machine_mode mode, rtx reg, int offset)
|
gen_rtx_SUBREG (enum machine_mode mode, rtx reg, int offset)
|
{
|
{
|
gcc_assert (validate_subreg (mode, GET_MODE (reg), reg, offset));
|
gcc_assert (validate_subreg (mode, GET_MODE (reg), reg, offset));
|
return gen_rtx_raw_SUBREG (mode, reg, offset);
|
return gen_rtx_raw_SUBREG (mode, reg, offset);
|
}
|
}
|
|
|
/* Generate a SUBREG representing the least-significant part of REG if MODE
|
/* Generate a SUBREG representing the least-significant part of REG if MODE
|
is smaller than mode of REG, otherwise paradoxical SUBREG. */
|
is smaller than mode of REG, otherwise paradoxical SUBREG. */
|
|
|
rtx
|
rtx
|
gen_lowpart_SUBREG (enum machine_mode mode, rtx reg)
|
gen_lowpart_SUBREG (enum machine_mode mode, rtx reg)
|
{
|
{
|
enum machine_mode inmode;
|
enum machine_mode inmode;
|
|
|
inmode = GET_MODE (reg);
|
inmode = GET_MODE (reg);
|
if (inmode == VOIDmode)
|
if (inmode == VOIDmode)
|
inmode = mode;
|
inmode = mode;
|
return gen_rtx_SUBREG (mode, reg,
|
return gen_rtx_SUBREG (mode, reg,
|
subreg_lowpart_offset (mode, inmode));
|
subreg_lowpart_offset (mode, inmode));
|
}
|
}
|
|
|
|
|
/* Create an rtvec and stores within it the RTXen passed in the arguments. */
|
/* Create an rtvec and stores within it the RTXen passed in the arguments. */
|
|
|
rtvec
|
rtvec
|
gen_rtvec (int n, ...)
|
gen_rtvec (int n, ...)
|
{
|
{
|
int i;
|
int i;
|
rtvec rt_val;
|
rtvec rt_val;
|
va_list p;
|
va_list p;
|
|
|
va_start (p, n);
|
va_start (p, n);
|
|
|
/* Don't allocate an empty rtvec... */
|
/* Don't allocate an empty rtvec... */
|
if (n == 0)
|
if (n == 0)
|
return NULL_RTVEC;
|
return NULL_RTVEC;
|
|
|
rt_val = rtvec_alloc (n);
|
rt_val = rtvec_alloc (n);
|
|
|
for (i = 0; i < n; i++)
|
for (i = 0; i < n; i++)
|
rt_val->elem[i] = va_arg (p, rtx);
|
rt_val->elem[i] = va_arg (p, rtx);
|
|
|
va_end (p);
|
va_end (p);
|
return rt_val;
|
return rt_val;
|
}
|
}
|
|
|
rtvec
|
rtvec
|
gen_rtvec_v (int n, rtx *argp)
|
gen_rtvec_v (int n, rtx *argp)
|
{
|
{
|
int i;
|
int i;
|
rtvec rt_val;
|
rtvec rt_val;
|
|
|
/* Don't allocate an empty rtvec... */
|
/* Don't allocate an empty rtvec... */
|
if (n == 0)
|
if (n == 0)
|
return NULL_RTVEC;
|
return NULL_RTVEC;
|
|
|
rt_val = rtvec_alloc (n);
|
rt_val = rtvec_alloc (n);
|
|
|
for (i = 0; i < n; i++)
|
for (i = 0; i < n; i++)
|
rt_val->elem[i] = *argp++;
|
rt_val->elem[i] = *argp++;
|
|
|
return rt_val;
|
return rt_val;
|
}
|
}
|
|
|
/* Return the number of bytes between the start of an OUTER_MODE
|
/* Return the number of bytes between the start of an OUTER_MODE
|
in-memory value and the start of an INNER_MODE in-memory value,
|
in-memory value and the start of an INNER_MODE in-memory value,
|
given that the former is a lowpart of the latter. It may be a
|
given that the former is a lowpart of the latter. It may be a
|
paradoxical lowpart, in which case the offset will be negative
|
paradoxical lowpart, in which case the offset will be negative
|
on big-endian targets. */
|
on big-endian targets. */
|
|
|
int
|
int
|
byte_lowpart_offset (enum machine_mode outer_mode,
|
byte_lowpart_offset (enum machine_mode outer_mode,
|
enum machine_mode inner_mode)
|
enum machine_mode inner_mode)
|
{
|
{
|
if (GET_MODE_SIZE (outer_mode) < GET_MODE_SIZE (inner_mode))
|
if (GET_MODE_SIZE (outer_mode) < GET_MODE_SIZE (inner_mode))
|
return subreg_lowpart_offset (outer_mode, inner_mode);
|
return subreg_lowpart_offset (outer_mode, inner_mode);
|
else
|
else
|
return -subreg_lowpart_offset (inner_mode, outer_mode);
|
return -subreg_lowpart_offset (inner_mode, outer_mode);
|
}
|
}
|
|
|
/* Generate a REG rtx for a new pseudo register of mode MODE.
|
/* Generate a REG rtx for a new pseudo register of mode MODE.
|
This pseudo is assigned the next sequential register number. */
|
This pseudo is assigned the next sequential register number. */
|
|
|
rtx
|
rtx
|
gen_reg_rtx (enum machine_mode mode)
|
gen_reg_rtx (enum machine_mode mode)
|
{
|
{
|
rtx val;
|
rtx val;
|
unsigned int align = GET_MODE_ALIGNMENT (mode);
|
unsigned int align = GET_MODE_ALIGNMENT (mode);
|
|
|
gcc_assert (can_create_pseudo_p ());
|
gcc_assert (can_create_pseudo_p ());
|
|
|
/* If a virtual register with bigger mode alignment is generated,
|
/* If a virtual register with bigger mode alignment is generated,
|
increase stack alignment estimation because it might be spilled
|
increase stack alignment estimation because it might be spilled
|
to stack later. */
|
to stack later. */
|
if (SUPPORTS_STACK_ALIGNMENT
|
if (SUPPORTS_STACK_ALIGNMENT
|
&& crtl->stack_alignment_estimated < align
|
&& crtl->stack_alignment_estimated < align
|
&& !crtl->stack_realign_processed)
|
&& !crtl->stack_realign_processed)
|
{
|
{
|
unsigned int min_align = MINIMUM_ALIGNMENT (NULL, mode, align);
|
unsigned int min_align = MINIMUM_ALIGNMENT (NULL, mode, align);
|
if (crtl->stack_alignment_estimated < min_align)
|
if (crtl->stack_alignment_estimated < min_align)
|
crtl->stack_alignment_estimated = min_align;
|
crtl->stack_alignment_estimated = min_align;
|
}
|
}
|
|
|
if (generating_concat_p
|
if (generating_concat_p
|
&& (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
|
&& (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
|
|| GET_MODE_CLASS (mode) == MODE_COMPLEX_INT))
|
|| GET_MODE_CLASS (mode) == MODE_COMPLEX_INT))
|
{
|
{
|
/* For complex modes, don't make a single pseudo.
|
/* For complex modes, don't make a single pseudo.
|
Instead, make a CONCAT of two pseudos.
|
Instead, make a CONCAT of two pseudos.
|
This allows noncontiguous allocation of the real and imaginary parts,
|
This allows noncontiguous allocation of the real and imaginary parts,
|
which makes much better code. Besides, allocating DCmode
|
which makes much better code. Besides, allocating DCmode
|
pseudos overstrains reload on some machines like the 386. */
|
pseudos overstrains reload on some machines like the 386. */
|
rtx realpart, imagpart;
|
rtx realpart, imagpart;
|
enum machine_mode partmode = GET_MODE_INNER (mode);
|
enum machine_mode partmode = GET_MODE_INNER (mode);
|
|
|
realpart = gen_reg_rtx (partmode);
|
realpart = gen_reg_rtx (partmode);
|
imagpart = gen_reg_rtx (partmode);
|
imagpart = gen_reg_rtx (partmode);
|
return gen_rtx_CONCAT (mode, realpart, imagpart);
|
return gen_rtx_CONCAT (mode, realpart, imagpart);
|
}
|
}
|
|
|
/* Make sure regno_pointer_align, and regno_reg_rtx are large
|
/* Make sure regno_pointer_align, and regno_reg_rtx are large
|
enough to have an element for this pseudo reg number. */
|
enough to have an element for this pseudo reg number. */
|
|
|
if (reg_rtx_no == crtl->emit.regno_pointer_align_length)
|
if (reg_rtx_no == crtl->emit.regno_pointer_align_length)
|
{
|
{
|
int old_size = crtl->emit.regno_pointer_align_length;
|
int old_size = crtl->emit.regno_pointer_align_length;
|
char *tmp;
|
char *tmp;
|
rtx *new1;
|
rtx *new1;
|
|
|
tmp = XRESIZEVEC (char, crtl->emit.regno_pointer_align, old_size * 2);
|
tmp = XRESIZEVEC (char, crtl->emit.regno_pointer_align, old_size * 2);
|
memset (tmp + old_size, 0, old_size);
|
memset (tmp + old_size, 0, old_size);
|
crtl->emit.regno_pointer_align = (unsigned char *) tmp;
|
crtl->emit.regno_pointer_align = (unsigned char *) tmp;
|
|
|
new1 = GGC_RESIZEVEC (rtx, regno_reg_rtx, old_size * 2);
|
new1 = GGC_RESIZEVEC (rtx, regno_reg_rtx, old_size * 2);
|
memset (new1 + old_size, 0, old_size * sizeof (rtx));
|
memset (new1 + old_size, 0, old_size * sizeof (rtx));
|
regno_reg_rtx = new1;
|
regno_reg_rtx = new1;
|
|
|
crtl->emit.regno_pointer_align_length = old_size * 2;
|
crtl->emit.regno_pointer_align_length = old_size * 2;
|
}
|
}
|
|
|
val = gen_raw_REG (mode, reg_rtx_no);
|
val = gen_raw_REG (mode, reg_rtx_no);
|
regno_reg_rtx[reg_rtx_no++] = val;
|
regno_reg_rtx[reg_rtx_no++] = val;
|
return val;
|
return val;
|
}
|
}
|
|
|
/* Update NEW with the same attributes as REG, but with OFFSET added
|
/* Update NEW with the same attributes as REG, but with OFFSET added
|
to the REG_OFFSET. */
|
to the REG_OFFSET. */
|
|
|
static void
|
static void
|
update_reg_offset (rtx new_rtx, rtx reg, int offset)
|
update_reg_offset (rtx new_rtx, rtx reg, int offset)
|
{
|
{
|
REG_ATTRS (new_rtx) = get_reg_attrs (REG_EXPR (reg),
|
REG_ATTRS (new_rtx) = get_reg_attrs (REG_EXPR (reg),
|
REG_OFFSET (reg) + offset);
|
REG_OFFSET (reg) + offset);
|
}
|
}
|
|
|
/* Generate a register with same attributes as REG, but with OFFSET
|
/* Generate a register with same attributes as REG, but with OFFSET
|
added to the REG_OFFSET. */
|
added to the REG_OFFSET. */
|
|
|
rtx
|
rtx
|
gen_rtx_REG_offset (rtx reg, enum machine_mode mode, unsigned int regno,
|
gen_rtx_REG_offset (rtx reg, enum machine_mode mode, unsigned int regno,
|
int offset)
|
int offset)
|
{
|
{
|
rtx new_rtx = gen_rtx_REG (mode, regno);
|
rtx new_rtx = gen_rtx_REG (mode, regno);
|
|
|
update_reg_offset (new_rtx, reg, offset);
|
update_reg_offset (new_rtx, reg, offset);
|
return new_rtx;
|
return new_rtx;
|
}
|
}
|
|
|
/* Generate a new pseudo-register with the same attributes as REG, but
|
/* Generate a new pseudo-register with the same attributes as REG, but
|
with OFFSET added to the REG_OFFSET. */
|
with OFFSET added to the REG_OFFSET. */
|
|
|
rtx
|
rtx
|
gen_reg_rtx_offset (rtx reg, enum machine_mode mode, int offset)
|
gen_reg_rtx_offset (rtx reg, enum machine_mode mode, int offset)
|
{
|
{
|
rtx new_rtx = gen_reg_rtx (mode);
|
rtx new_rtx = gen_reg_rtx (mode);
|
|
|
update_reg_offset (new_rtx, reg, offset);
|
update_reg_offset (new_rtx, reg, offset);
|
return new_rtx;
|
return new_rtx;
|
}
|
}
|
|
|
/* Adjust REG in-place so that it has mode MODE. It is assumed that the
|
/* Adjust REG in-place so that it has mode MODE. It is assumed that the
|
new register is a (possibly paradoxical) lowpart of the old one. */
|
new register is a (possibly paradoxical) lowpart of the old one. */
|
|
|
void
|
void
|
adjust_reg_mode (rtx reg, enum machine_mode mode)
|
adjust_reg_mode (rtx reg, enum machine_mode mode)
|
{
|
{
|
update_reg_offset (reg, reg, byte_lowpart_offset (mode, GET_MODE (reg)));
|
update_reg_offset (reg, reg, byte_lowpart_offset (mode, GET_MODE (reg)));
|
PUT_MODE (reg, mode);
|
PUT_MODE (reg, mode);
|
}
|
}
|
|
|
/* Copy REG's attributes from X, if X has any attributes. If REG and X
|
/* Copy REG's attributes from X, if X has any attributes. If REG and X
|
have different modes, REG is a (possibly paradoxical) lowpart of X. */
|
have different modes, REG is a (possibly paradoxical) lowpart of X. */
|
|
|
void
|
void
|
set_reg_attrs_from_value (rtx reg, rtx x)
|
set_reg_attrs_from_value (rtx reg, rtx x)
|
{
|
{
|
int offset;
|
int offset;
|
|
|
/* Hard registers can be reused for multiple purposes within the same
|
/* Hard registers can be reused for multiple purposes within the same
|
function, so setting REG_ATTRS, REG_POINTER and REG_POINTER_ALIGN
|
function, so setting REG_ATTRS, REG_POINTER and REG_POINTER_ALIGN
|
on them is wrong. */
|
on them is wrong. */
|
if (HARD_REGISTER_P (reg))
|
if (HARD_REGISTER_P (reg))
|
return;
|
return;
|
|
|
offset = byte_lowpart_offset (GET_MODE (reg), GET_MODE (x));
|
offset = byte_lowpart_offset (GET_MODE (reg), GET_MODE (x));
|
if (MEM_P (x))
|
if (MEM_P (x))
|
{
|
{
|
if (MEM_OFFSET (x) && CONST_INT_P (MEM_OFFSET (x)))
|
if (MEM_OFFSET (x) && CONST_INT_P (MEM_OFFSET (x)))
|
REG_ATTRS (reg)
|
REG_ATTRS (reg)
|
= get_reg_attrs (MEM_EXPR (x), INTVAL (MEM_OFFSET (x)) + offset);
|
= get_reg_attrs (MEM_EXPR (x), INTVAL (MEM_OFFSET (x)) + offset);
|
if (MEM_POINTER (x))
|
if (MEM_POINTER (x))
|
mark_reg_pointer (reg, 0);
|
mark_reg_pointer (reg, 0);
|
}
|
}
|
else if (REG_P (x))
|
else if (REG_P (x))
|
{
|
{
|
if (REG_ATTRS (x))
|
if (REG_ATTRS (x))
|
update_reg_offset (reg, x, offset);
|
update_reg_offset (reg, x, offset);
|
if (REG_POINTER (x))
|
if (REG_POINTER (x))
|
mark_reg_pointer (reg, REGNO_POINTER_ALIGN (REGNO (x)));
|
mark_reg_pointer (reg, REGNO_POINTER_ALIGN (REGNO (x)));
|
}
|
}
|
}
|
}
|
|
|
/* Generate a REG rtx for a new pseudo register, copying the mode
|
/* Generate a REG rtx for a new pseudo register, copying the mode
|
and attributes from X. */
|
and attributes from X. */
|
|
|
rtx
|
rtx
|
gen_reg_rtx_and_attrs (rtx x)
|
gen_reg_rtx_and_attrs (rtx x)
|
{
|
{
|
rtx reg = gen_reg_rtx (GET_MODE (x));
|
rtx reg = gen_reg_rtx (GET_MODE (x));
|
set_reg_attrs_from_value (reg, x);
|
set_reg_attrs_from_value (reg, x);
|
return reg;
|
return reg;
|
}
|
}
|
|
|
/* Set the register attributes for registers contained in PARM_RTX.
|
/* Set the register attributes for registers contained in PARM_RTX.
|
Use needed values from memory attributes of MEM. */
|
Use needed values from memory attributes of MEM. */
|
|
|
void
|
void
|
set_reg_attrs_for_parm (rtx parm_rtx, rtx mem)
|
set_reg_attrs_for_parm (rtx parm_rtx, rtx mem)
|
{
|
{
|
if (REG_P (parm_rtx))
|
if (REG_P (parm_rtx))
|
set_reg_attrs_from_value (parm_rtx, mem);
|
set_reg_attrs_from_value (parm_rtx, mem);
|
else if (GET_CODE (parm_rtx) == PARALLEL)
|
else if (GET_CODE (parm_rtx) == PARALLEL)
|
{
|
{
|
/* Check for a NULL entry in the first slot, used to indicate that the
|
/* Check for a NULL entry in the first slot, used to indicate that the
|
parameter goes both on the stack and in registers. */
|
parameter goes both on the stack and in registers. */
|
int i = XEXP (XVECEXP (parm_rtx, 0, 0), 0) ? 0 : 1;
|
int i = XEXP (XVECEXP (parm_rtx, 0, 0), 0) ? 0 : 1;
|
for (; i < XVECLEN (parm_rtx, 0); i++)
|
for (; i < XVECLEN (parm_rtx, 0); i++)
|
{
|
{
|
rtx x = XVECEXP (parm_rtx, 0, i);
|
rtx x = XVECEXP (parm_rtx, 0, i);
|
if (REG_P (XEXP (x, 0)))
|
if (REG_P (XEXP (x, 0)))
|
REG_ATTRS (XEXP (x, 0))
|
REG_ATTRS (XEXP (x, 0))
|
= get_reg_attrs (MEM_EXPR (mem),
|
= get_reg_attrs (MEM_EXPR (mem),
|
INTVAL (XEXP (x, 1)));
|
INTVAL (XEXP (x, 1)));
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Set the REG_ATTRS for registers in value X, given that X represents
|
/* Set the REG_ATTRS for registers in value X, given that X represents
|
decl T. */
|
decl T. */
|
|
|
void
|
void
|
set_reg_attrs_for_decl_rtl (tree t, rtx x)
|
set_reg_attrs_for_decl_rtl (tree t, rtx x)
|
{
|
{
|
if (GET_CODE (x) == SUBREG)
|
if (GET_CODE (x) == SUBREG)
|
{
|
{
|
gcc_assert (subreg_lowpart_p (x));
|
gcc_assert (subreg_lowpart_p (x));
|
x = SUBREG_REG (x);
|
x = SUBREG_REG (x);
|
}
|
}
|
if (REG_P (x))
|
if (REG_P (x))
|
REG_ATTRS (x)
|
REG_ATTRS (x)
|
= get_reg_attrs (t, byte_lowpart_offset (GET_MODE (x),
|
= get_reg_attrs (t, byte_lowpart_offset (GET_MODE (x),
|
DECL_MODE (t)));
|
DECL_MODE (t)));
|
if (GET_CODE (x) == CONCAT)
|
if (GET_CODE (x) == CONCAT)
|
{
|
{
|
if (REG_P (XEXP (x, 0)))
|
if (REG_P (XEXP (x, 0)))
|
REG_ATTRS (XEXP (x, 0)) = get_reg_attrs (t, 0);
|
REG_ATTRS (XEXP (x, 0)) = get_reg_attrs (t, 0);
|
if (REG_P (XEXP (x, 1)))
|
if (REG_P (XEXP (x, 1)))
|
REG_ATTRS (XEXP (x, 1))
|
REG_ATTRS (XEXP (x, 1))
|
= get_reg_attrs (t, GET_MODE_UNIT_SIZE (GET_MODE (XEXP (x, 0))));
|
= get_reg_attrs (t, GET_MODE_UNIT_SIZE (GET_MODE (XEXP (x, 0))));
|
}
|
}
|
if (GET_CODE (x) == PARALLEL)
|
if (GET_CODE (x) == PARALLEL)
|
{
|
{
|
int i, start;
|
int i, start;
|
|
|
/* Check for a NULL entry, used to indicate that the parameter goes
|
/* Check for a NULL entry, used to indicate that the parameter goes
|
both on the stack and in registers. */
|
both on the stack and in registers. */
|
if (XEXP (XVECEXP (x, 0, 0), 0))
|
if (XEXP (XVECEXP (x, 0, 0), 0))
|
start = 0;
|
start = 0;
|
else
|
else
|
start = 1;
|
start = 1;
|
|
|
for (i = start; i < XVECLEN (x, 0); i++)
|
for (i = start; i < XVECLEN (x, 0); i++)
|
{
|
{
|
rtx y = XVECEXP (x, 0, i);
|
rtx y = XVECEXP (x, 0, i);
|
if (REG_P (XEXP (y, 0)))
|
if (REG_P (XEXP (y, 0)))
|
REG_ATTRS (XEXP (y, 0)) = get_reg_attrs (t, INTVAL (XEXP (y, 1)));
|
REG_ATTRS (XEXP (y, 0)) = get_reg_attrs (t, INTVAL (XEXP (y, 1)));
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Assign the RTX X to declaration T. */
|
/* Assign the RTX X to declaration T. */
|
|
|
void
|
void
|
set_decl_rtl (tree t, rtx x)
|
set_decl_rtl (tree t, rtx x)
|
{
|
{
|
DECL_WRTL_CHECK (t)->decl_with_rtl.rtl = x;
|
DECL_WRTL_CHECK (t)->decl_with_rtl.rtl = x;
|
if (x)
|
if (x)
|
set_reg_attrs_for_decl_rtl (t, x);
|
set_reg_attrs_for_decl_rtl (t, x);
|
}
|
}
|
|
|
/* Assign the RTX X to parameter declaration T. BY_REFERENCE_P is true
|
/* Assign the RTX X to parameter declaration T. BY_REFERENCE_P is true
|
if the ABI requires the parameter to be passed by reference. */
|
if the ABI requires the parameter to be passed by reference. */
|
|
|
void
|
void
|
set_decl_incoming_rtl (tree t, rtx x, bool by_reference_p)
|
set_decl_incoming_rtl (tree t, rtx x, bool by_reference_p)
|
{
|
{
|
DECL_INCOMING_RTL (t) = x;
|
DECL_INCOMING_RTL (t) = x;
|
if (x && !by_reference_p)
|
if (x && !by_reference_p)
|
set_reg_attrs_for_decl_rtl (t, x);
|
set_reg_attrs_for_decl_rtl (t, x);
|
}
|
}
|
|
|
/* Identify REG (which may be a CONCAT) as a user register. */
|
/* Identify REG (which may be a CONCAT) as a user register. */
|
|
|
void
|
void
|
mark_user_reg (rtx reg)
|
mark_user_reg (rtx reg)
|
{
|
{
|
if (GET_CODE (reg) == CONCAT)
|
if (GET_CODE (reg) == CONCAT)
|
{
|
{
|
REG_USERVAR_P (XEXP (reg, 0)) = 1;
|
REG_USERVAR_P (XEXP (reg, 0)) = 1;
|
REG_USERVAR_P (XEXP (reg, 1)) = 1;
|
REG_USERVAR_P (XEXP (reg, 1)) = 1;
|
}
|
}
|
else
|
else
|
{
|
{
|
gcc_assert (REG_P (reg));
|
gcc_assert (REG_P (reg));
|
REG_USERVAR_P (reg) = 1;
|
REG_USERVAR_P (reg) = 1;
|
}
|
}
|
}
|
}
|
|
|
/* Identify REG as a probable pointer register and show its alignment
|
/* Identify REG as a probable pointer register and show its alignment
|
as ALIGN, if nonzero. */
|
as ALIGN, if nonzero. */
|
|
|
void
|
void
|
mark_reg_pointer (rtx reg, int align)
|
mark_reg_pointer (rtx reg, int align)
|
{
|
{
|
if (! REG_POINTER (reg))
|
if (! REG_POINTER (reg))
|
{
|
{
|
REG_POINTER (reg) = 1;
|
REG_POINTER (reg) = 1;
|
|
|
if (align)
|
if (align)
|
REGNO_POINTER_ALIGN (REGNO (reg)) = align;
|
REGNO_POINTER_ALIGN (REGNO (reg)) = align;
|
}
|
}
|
else if (align && align < REGNO_POINTER_ALIGN (REGNO (reg)))
|
else if (align && align < REGNO_POINTER_ALIGN (REGNO (reg)))
|
/* We can no-longer be sure just how aligned this pointer is. */
|
/* We can no-longer be sure just how aligned this pointer is. */
|
REGNO_POINTER_ALIGN (REGNO (reg)) = align;
|
REGNO_POINTER_ALIGN (REGNO (reg)) = align;
|
}
|
}
|
|
|
/* Return 1 plus largest pseudo reg number used in the current function. */
|
/* Return 1 plus largest pseudo reg number used in the current function. */
|
|
|
int
|
int
|
max_reg_num (void)
|
max_reg_num (void)
|
{
|
{
|
return reg_rtx_no;
|
return reg_rtx_no;
|
}
|
}
|
|
|
/* Return 1 + the largest label number used so far in the current function. */
|
/* Return 1 + the largest label number used so far in the current function. */
|
|
|
int
|
int
|
max_label_num (void)
|
max_label_num (void)
|
{
|
{
|
return label_num;
|
return label_num;
|
}
|
}
|
|
|
/* Return first label number used in this function (if any were used). */
|
/* Return first label number used in this function (if any were used). */
|
|
|
int
|
int
|
get_first_label_num (void)
|
get_first_label_num (void)
|
{
|
{
|
return first_label_num;
|
return first_label_num;
|
}
|
}
|
|
|
/* If the rtx for label was created during the expansion of a nested
|
/* If the rtx for label was created during the expansion of a nested
|
function, then first_label_num won't include this label number.
|
function, then first_label_num won't include this label number.
|
Fix this now so that array indices work later. */
|
Fix this now so that array indices work later. */
|
|
|
void
|
void
|
maybe_set_first_label_num (rtx x)
|
maybe_set_first_label_num (rtx x)
|
{
|
{
|
if (CODE_LABEL_NUMBER (x) < first_label_num)
|
if (CODE_LABEL_NUMBER (x) < first_label_num)
|
first_label_num = CODE_LABEL_NUMBER (x);
|
first_label_num = CODE_LABEL_NUMBER (x);
|
}
|
}
|
|
|
/* Return a value representing some low-order bits of X, where the number
|
/* Return a value representing some low-order bits of X, where the number
|
of low-order bits is given by MODE. Note that no conversion is done
|
of low-order bits is given by MODE. Note that no conversion is done
|
between floating-point and fixed-point values, rather, the bit
|
between floating-point and fixed-point values, rather, the bit
|
representation is returned.
|
representation is returned.
|
|
|
This function handles the cases in common between gen_lowpart, below,
|
This function handles the cases in common between gen_lowpart, below,
|
and two variants in cse.c and combine.c. These are the cases that can
|
and two variants in cse.c and combine.c. These are the cases that can
|
be safely handled at all points in the compilation.
|
be safely handled at all points in the compilation.
|
|
|
If this is not a case we can handle, return 0. */
|
If this is not a case we can handle, return 0. */
|
|
|
rtx
|
rtx
|
gen_lowpart_common (enum machine_mode mode, rtx x)
|
gen_lowpart_common (enum machine_mode mode, rtx x)
|
{
|
{
|
int msize = GET_MODE_SIZE (mode);
|
int msize = GET_MODE_SIZE (mode);
|
int xsize;
|
int xsize;
|
int offset = 0;
|
int offset = 0;
|
enum machine_mode innermode;
|
enum machine_mode innermode;
|
|
|
/* Unfortunately, this routine doesn't take a parameter for the mode of X,
|
/* Unfortunately, this routine doesn't take a parameter for the mode of X,
|
so we have to make one up. Yuk. */
|
so we have to make one up. Yuk. */
|
innermode = GET_MODE (x);
|
innermode = GET_MODE (x);
|
if (CONST_INT_P (x)
|
if (CONST_INT_P (x)
|
&& msize * BITS_PER_UNIT <= HOST_BITS_PER_WIDE_INT)
|
&& msize * BITS_PER_UNIT <= HOST_BITS_PER_WIDE_INT)
|
innermode = mode_for_size (HOST_BITS_PER_WIDE_INT, MODE_INT, 0);
|
innermode = mode_for_size (HOST_BITS_PER_WIDE_INT, MODE_INT, 0);
|
else if (innermode == VOIDmode)
|
else if (innermode == VOIDmode)
|
innermode = mode_for_size (HOST_BITS_PER_WIDE_INT * 2, MODE_INT, 0);
|
innermode = mode_for_size (HOST_BITS_PER_WIDE_INT * 2, MODE_INT, 0);
|
|
|
xsize = GET_MODE_SIZE (innermode);
|
xsize = GET_MODE_SIZE (innermode);
|
|
|
gcc_assert (innermode != VOIDmode && innermode != BLKmode);
|
gcc_assert (innermode != VOIDmode && innermode != BLKmode);
|
|
|
if (innermode == mode)
|
if (innermode == mode)
|
return x;
|
return x;
|
|
|
/* MODE must occupy no more words than the mode of X. */
|
/* MODE must occupy no more words than the mode of X. */
|
if ((msize + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD
|
if ((msize + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD
|
> ((xsize + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))
|
> ((xsize + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))
|
return 0;
|
return 0;
|
|
|
/* Don't allow generating paradoxical FLOAT_MODE subregs. */
|
/* Don't allow generating paradoxical FLOAT_MODE subregs. */
|
if (SCALAR_FLOAT_MODE_P (mode) && msize > xsize)
|
if (SCALAR_FLOAT_MODE_P (mode) && msize > xsize)
|
return 0;
|
return 0;
|
|
|
offset = subreg_lowpart_offset (mode, innermode);
|
offset = subreg_lowpart_offset (mode, innermode);
|
|
|
if ((GET_CODE (x) == ZERO_EXTEND || GET_CODE (x) == SIGN_EXTEND)
|
if ((GET_CODE (x) == ZERO_EXTEND || GET_CODE (x) == SIGN_EXTEND)
|
&& (GET_MODE_CLASS (mode) == MODE_INT
|
&& (GET_MODE_CLASS (mode) == MODE_INT
|
|| GET_MODE_CLASS (mode) == MODE_PARTIAL_INT))
|
|| GET_MODE_CLASS (mode) == MODE_PARTIAL_INT))
|
{
|
{
|
/* If we are getting the low-order part of something that has been
|
/* If we are getting the low-order part of something that has been
|
sign- or zero-extended, we can either just use the object being
|
sign- or zero-extended, we can either just use the object being
|
extended or make a narrower extension. If we want an even smaller
|
extended or make a narrower extension. If we want an even smaller
|
piece than the size of the object being extended, call ourselves
|
piece than the size of the object being extended, call ourselves
|
recursively.
|
recursively.
|
|
|
This case is used mostly by combine and cse. */
|
This case is used mostly by combine and cse. */
|
|
|
if (GET_MODE (XEXP (x, 0)) == mode)
|
if (GET_MODE (XEXP (x, 0)) == mode)
|
return XEXP (x, 0);
|
return XEXP (x, 0);
|
else if (msize < GET_MODE_SIZE (GET_MODE (XEXP (x, 0))))
|
else if (msize < GET_MODE_SIZE (GET_MODE (XEXP (x, 0))))
|
return gen_lowpart_common (mode, XEXP (x, 0));
|
return gen_lowpart_common (mode, XEXP (x, 0));
|
else if (msize < xsize)
|
else if (msize < xsize)
|
return gen_rtx_fmt_e (GET_CODE (x), mode, XEXP (x, 0));
|
return gen_rtx_fmt_e (GET_CODE (x), mode, XEXP (x, 0));
|
}
|
}
|
else if (GET_CODE (x) == SUBREG || REG_P (x)
|
else if (GET_CODE (x) == SUBREG || REG_P (x)
|
|| GET_CODE (x) == CONCAT || GET_CODE (x) == CONST_VECTOR
|
|| GET_CODE (x) == CONCAT || GET_CODE (x) == CONST_VECTOR
|
|| GET_CODE (x) == CONST_DOUBLE || CONST_INT_P (x))
|
|| GET_CODE (x) == CONST_DOUBLE || CONST_INT_P (x))
|
return simplify_gen_subreg (mode, x, innermode, offset);
|
return simplify_gen_subreg (mode, x, innermode, offset);
|
|
|
/* Otherwise, we can't do this. */
|
/* Otherwise, we can't do this. */
|
return 0;
|
return 0;
|
}
|
}
|
|
|
rtx
|
rtx
|
gen_highpart (enum machine_mode mode, rtx x)
|
gen_highpart (enum machine_mode mode, rtx x)
|
{
|
{
|
unsigned int msize = GET_MODE_SIZE (mode);
|
unsigned int msize = GET_MODE_SIZE (mode);
|
rtx result;
|
rtx result;
|
|
|
/* This case loses if X is a subreg. To catch bugs early,
|
/* This case loses if X is a subreg. To catch bugs early,
|
complain if an invalid MODE is used even in other cases. */
|
complain if an invalid MODE is used even in other cases. */
|
gcc_assert (msize <= UNITS_PER_WORD
|
gcc_assert (msize <= UNITS_PER_WORD
|
|| msize == (unsigned int) GET_MODE_UNIT_SIZE (GET_MODE (x)));
|
|| msize == (unsigned int) GET_MODE_UNIT_SIZE (GET_MODE (x)));
|
|
|
result = simplify_gen_subreg (mode, x, GET_MODE (x),
|
result = simplify_gen_subreg (mode, x, GET_MODE (x),
|
subreg_highpart_offset (mode, GET_MODE (x)));
|
subreg_highpart_offset (mode, GET_MODE (x)));
|
gcc_assert (result);
|
gcc_assert (result);
|
|
|
/* simplify_gen_subreg is not guaranteed to return a valid operand for
|
/* simplify_gen_subreg is not guaranteed to return a valid operand for
|
the target if we have a MEM. gen_highpart must return a valid operand,
|
the target if we have a MEM. gen_highpart must return a valid operand,
|
emitting code if necessary to do so. */
|
emitting code if necessary to do so. */
|
if (MEM_P (result))
|
if (MEM_P (result))
|
{
|
{
|
result = validize_mem (result);
|
result = validize_mem (result);
|
gcc_assert (result);
|
gcc_assert (result);
|
}
|
}
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Like gen_highpart, but accept mode of EXP operand in case EXP can
|
/* Like gen_highpart, but accept mode of EXP operand in case EXP can
|
be VOIDmode constant. */
|
be VOIDmode constant. */
|
rtx
|
rtx
|
gen_highpart_mode (enum machine_mode outermode, enum machine_mode innermode, rtx exp)
|
gen_highpart_mode (enum machine_mode outermode, enum machine_mode innermode, rtx exp)
|
{
|
{
|
if (GET_MODE (exp) != VOIDmode)
|
if (GET_MODE (exp) != VOIDmode)
|
{
|
{
|
gcc_assert (GET_MODE (exp) == innermode);
|
gcc_assert (GET_MODE (exp) == innermode);
|
return gen_highpart (outermode, exp);
|
return gen_highpart (outermode, exp);
|
}
|
}
|
return simplify_gen_subreg (outermode, exp, innermode,
|
return simplify_gen_subreg (outermode, exp, innermode,
|
subreg_highpart_offset (outermode, innermode));
|
subreg_highpart_offset (outermode, innermode));
|
}
|
}
|
|
|
/* Return the SUBREG_BYTE for an OUTERMODE lowpart of an INNERMODE value. */
|
/* Return the SUBREG_BYTE for an OUTERMODE lowpart of an INNERMODE value. */
|
|
|
unsigned int
|
unsigned int
|
subreg_lowpart_offset (enum machine_mode outermode, enum machine_mode innermode)
|
subreg_lowpart_offset (enum machine_mode outermode, enum machine_mode innermode)
|
{
|
{
|
unsigned int offset = 0;
|
unsigned int offset = 0;
|
int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
|
int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
|
|
|
if (difference > 0)
|
if (difference > 0)
|
{
|
{
|
if (WORDS_BIG_ENDIAN)
|
if (WORDS_BIG_ENDIAN)
|
offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
|
offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
|
if (BYTES_BIG_ENDIAN)
|
if (BYTES_BIG_ENDIAN)
|
offset += difference % UNITS_PER_WORD;
|
offset += difference % UNITS_PER_WORD;
|
}
|
}
|
|
|
return offset;
|
return offset;
|
}
|
}
|
|
|
/* Return offset in bytes to get OUTERMODE high part
|
/* Return offset in bytes to get OUTERMODE high part
|
of the value in mode INNERMODE stored in memory in target format. */
|
of the value in mode INNERMODE stored in memory in target format. */
|
unsigned int
|
unsigned int
|
subreg_highpart_offset (enum machine_mode outermode, enum machine_mode innermode)
|
subreg_highpart_offset (enum machine_mode outermode, enum machine_mode innermode)
|
{
|
{
|
unsigned int offset = 0;
|
unsigned int offset = 0;
|
int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
|
int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
|
|
|
gcc_assert (GET_MODE_SIZE (innermode) >= GET_MODE_SIZE (outermode));
|
gcc_assert (GET_MODE_SIZE (innermode) >= GET_MODE_SIZE (outermode));
|
|
|
if (difference > 0)
|
if (difference > 0)
|
{
|
{
|
if (! WORDS_BIG_ENDIAN)
|
if (! WORDS_BIG_ENDIAN)
|
offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
|
offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
|
if (! BYTES_BIG_ENDIAN)
|
if (! BYTES_BIG_ENDIAN)
|
offset += difference % UNITS_PER_WORD;
|
offset += difference % UNITS_PER_WORD;
|
}
|
}
|
|
|
return offset;
|
return offset;
|
}
|
}
|
|
|
/* Return 1 iff X, assumed to be a SUBREG,
|
/* Return 1 iff X, assumed to be a SUBREG,
|
refers to the least significant part of its containing reg.
|
refers to the least significant part of its containing reg.
|
If X is not a SUBREG, always return 1 (it is its own low part!). */
|
If X is not a SUBREG, always return 1 (it is its own low part!). */
|
|
|
int
|
int
|
subreg_lowpart_p (const_rtx x)
|
subreg_lowpart_p (const_rtx x)
|
{
|
{
|
if (GET_CODE (x) != SUBREG)
|
if (GET_CODE (x) != SUBREG)
|
return 1;
|
return 1;
|
else if (GET_MODE (SUBREG_REG (x)) == VOIDmode)
|
else if (GET_MODE (SUBREG_REG (x)) == VOIDmode)
|
return 0;
|
return 0;
|
|
|
return (subreg_lowpart_offset (GET_MODE (x), GET_MODE (SUBREG_REG (x)))
|
return (subreg_lowpart_offset (GET_MODE (x), GET_MODE (SUBREG_REG (x)))
|
== SUBREG_BYTE (x));
|
== SUBREG_BYTE (x));
|
}
|
}
|
|
|
/* Return subword OFFSET of operand OP.
|
/* Return subword OFFSET of operand OP.
|
The word number, OFFSET, is interpreted as the word number starting
|
The word number, OFFSET, is interpreted as the word number starting
|
at the low-order address. OFFSET 0 is the low-order word if not
|
at the low-order address. OFFSET 0 is the low-order word if not
|
WORDS_BIG_ENDIAN, otherwise it is the high-order word.
|
WORDS_BIG_ENDIAN, otherwise it is the high-order word.
|
|
|
If we cannot extract the required word, we return zero. Otherwise,
|
If we cannot extract the required word, we return zero. Otherwise,
|
an rtx corresponding to the requested word will be returned.
|
an rtx corresponding to the requested word will be returned.
|
|
|
VALIDATE_ADDRESS is nonzero if the address should be validated. Before
|
VALIDATE_ADDRESS is nonzero if the address should be validated. Before
|
reload has completed, a valid address will always be returned. After
|
reload has completed, a valid address will always be returned. After
|
reload, if a valid address cannot be returned, we return zero.
|
reload, if a valid address cannot be returned, we return zero.
|
|
|
If VALIDATE_ADDRESS is zero, we simply form the required address; validating
|
If VALIDATE_ADDRESS is zero, we simply form the required address; validating
|
it is the responsibility of the caller.
|
it is the responsibility of the caller.
|
|
|
MODE is the mode of OP in case it is a CONST_INT.
|
MODE is the mode of OP in case it is a CONST_INT.
|
|
|
??? This is still rather broken for some cases. The problem for the
|
??? This is still rather broken for some cases. The problem for the
|
moment is that all callers of this thing provide no 'goal mode' to
|
moment is that all callers of this thing provide no 'goal mode' to
|
tell us to work with. This exists because all callers were written
|
tell us to work with. This exists because all callers were written
|
in a word based SUBREG world.
|
in a word based SUBREG world.
|
Now use of this function can be deprecated by simplify_subreg in most
|
Now use of this function can be deprecated by simplify_subreg in most
|
cases.
|
cases.
|
*/
|
*/
|
|
|
rtx
|
rtx
|
operand_subword (rtx op, unsigned int offset, int validate_address, enum machine_mode mode)
|
operand_subword (rtx op, unsigned int offset, int validate_address, enum machine_mode mode)
|
{
|
{
|
if (mode == VOIDmode)
|
if (mode == VOIDmode)
|
mode = GET_MODE (op);
|
mode = GET_MODE (op);
|
|
|
gcc_assert (mode != VOIDmode);
|
gcc_assert (mode != VOIDmode);
|
|
|
/* If OP is narrower than a word, fail. */
|
/* If OP is narrower than a word, fail. */
|
if (mode != BLKmode
|
if (mode != BLKmode
|
&& (GET_MODE_SIZE (mode) < UNITS_PER_WORD))
|
&& (GET_MODE_SIZE (mode) < UNITS_PER_WORD))
|
return 0;
|
return 0;
|
|
|
/* If we want a word outside OP, return zero. */
|
/* If we want a word outside OP, return zero. */
|
if (mode != BLKmode
|
if (mode != BLKmode
|
&& (offset + 1) * UNITS_PER_WORD > GET_MODE_SIZE (mode))
|
&& (offset + 1) * UNITS_PER_WORD > GET_MODE_SIZE (mode))
|
return const0_rtx;
|
return const0_rtx;
|
|
|
/* Form a new MEM at the requested address. */
|
/* Form a new MEM at the requested address. */
|
if (MEM_P (op))
|
if (MEM_P (op))
|
{
|
{
|
rtx new_rtx = adjust_address_nv (op, word_mode, offset * UNITS_PER_WORD);
|
rtx new_rtx = adjust_address_nv (op, word_mode, offset * UNITS_PER_WORD);
|
|
|
if (! validate_address)
|
if (! validate_address)
|
return new_rtx;
|
return new_rtx;
|
|
|
else if (reload_completed)
|
else if (reload_completed)
|
{
|
{
|
if (! strict_memory_address_addr_space_p (word_mode,
|
if (! strict_memory_address_addr_space_p (word_mode,
|
XEXP (new_rtx, 0),
|
XEXP (new_rtx, 0),
|
MEM_ADDR_SPACE (op)))
|
MEM_ADDR_SPACE (op)))
|
return 0;
|
return 0;
|
}
|
}
|
else
|
else
|
return replace_equiv_address (new_rtx, XEXP (new_rtx, 0));
|
return replace_equiv_address (new_rtx, XEXP (new_rtx, 0));
|
}
|
}
|
|
|
/* Rest can be handled by simplify_subreg. */
|
/* Rest can be handled by simplify_subreg. */
|
return simplify_gen_subreg (word_mode, op, mode, (offset * UNITS_PER_WORD));
|
return simplify_gen_subreg (word_mode, op, mode, (offset * UNITS_PER_WORD));
|
}
|
}
|
|
|
/* Similar to `operand_subword', but never return 0. If we can't
|
/* Similar to `operand_subword', but never return 0. If we can't
|
extract the required subword, put OP into a register and try again.
|
extract the required subword, put OP into a register and try again.
|
The second attempt must succeed. We always validate the address in
|
The second attempt must succeed. We always validate the address in
|
this case.
|
this case.
|
|
|
MODE is the mode of OP, in case it is CONST_INT. */
|
MODE is the mode of OP, in case it is CONST_INT. */
|
|
|
rtx
|
rtx
|
operand_subword_force (rtx op, unsigned int offset, enum machine_mode mode)
|
operand_subword_force (rtx op, unsigned int offset, enum machine_mode mode)
|
{
|
{
|
rtx result = operand_subword (op, offset, 1, mode);
|
rtx result = operand_subword (op, offset, 1, mode);
|
|
|
if (result)
|
if (result)
|
return result;
|
return result;
|
|
|
if (mode != BLKmode && mode != VOIDmode)
|
if (mode != BLKmode && mode != VOIDmode)
|
{
|
{
|
/* If this is a register which can not be accessed by words, copy it
|
/* If this is a register which can not be accessed by words, copy it
|
to a pseudo register. */
|
to a pseudo register. */
|
if (REG_P (op))
|
if (REG_P (op))
|
op = copy_to_reg (op);
|
op = copy_to_reg (op);
|
else
|
else
|
op = force_reg (mode, op);
|
op = force_reg (mode, op);
|
}
|
}
|
|
|
result = operand_subword (op, offset, 1, mode);
|
result = operand_subword (op, offset, 1, mode);
|
gcc_assert (result);
|
gcc_assert (result);
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Returns 1 if both MEM_EXPR can be considered equal
|
/* Returns 1 if both MEM_EXPR can be considered equal
|
and 0 otherwise. */
|
and 0 otherwise. */
|
|
|
int
|
int
|
mem_expr_equal_p (const_tree expr1, const_tree expr2)
|
mem_expr_equal_p (const_tree expr1, const_tree expr2)
|
{
|
{
|
if (expr1 == expr2)
|
if (expr1 == expr2)
|
return 1;
|
return 1;
|
|
|
if (! expr1 || ! expr2)
|
if (! expr1 || ! expr2)
|
return 0;
|
return 0;
|
|
|
if (TREE_CODE (expr1) != TREE_CODE (expr2))
|
if (TREE_CODE (expr1) != TREE_CODE (expr2))
|
return 0;
|
return 0;
|
|
|
return operand_equal_p (expr1, expr2, 0);
|
return operand_equal_p (expr1, expr2, 0);
|
}
|
}
|
|
|
/* Return OFFSET if XEXP (MEM, 0) - OFFSET is known to be ALIGN
|
/* Return OFFSET if XEXP (MEM, 0) - OFFSET is known to be ALIGN
|
bits aligned for 0 <= OFFSET < ALIGN / BITS_PER_UNIT, or
|
bits aligned for 0 <= OFFSET < ALIGN / BITS_PER_UNIT, or
|
-1 if not known. */
|
-1 if not known. */
|
|
|
int
|
int
|
get_mem_align_offset (rtx mem, unsigned int align)
|
get_mem_align_offset (rtx mem, unsigned int align)
|
{
|
{
|
tree expr;
|
tree expr;
|
unsigned HOST_WIDE_INT offset;
|
unsigned HOST_WIDE_INT offset;
|
|
|
/* This function can't use
|
/* This function can't use
|
if (!MEM_EXPR (mem) || !MEM_OFFSET (mem)
|
if (!MEM_EXPR (mem) || !MEM_OFFSET (mem)
|
|| !CONST_INT_P (MEM_OFFSET (mem))
|
|| !CONST_INT_P (MEM_OFFSET (mem))
|
|| (get_object_alignment (MEM_EXPR (mem), MEM_ALIGN (mem), align)
|
|| (get_object_alignment (MEM_EXPR (mem), MEM_ALIGN (mem), align)
|
< align))
|
< align))
|
return -1;
|
return -1;
|
else
|
else
|
return (- INTVAL (MEM_OFFSET (mem))) & (align / BITS_PER_UNIT - 1);
|
return (- INTVAL (MEM_OFFSET (mem))) & (align / BITS_PER_UNIT - 1);
|
for two reasons:
|
for two reasons:
|
- COMPONENT_REFs in MEM_EXPR can have NULL first operand,
|
- COMPONENT_REFs in MEM_EXPR can have NULL first operand,
|
for <variable>. get_inner_reference doesn't handle it and
|
for <variable>. get_inner_reference doesn't handle it and
|
even if it did, the alignment in that case needs to be determined
|
even if it did, the alignment in that case needs to be determined
|
from DECL_FIELD_CONTEXT's TYPE_ALIGN.
|
from DECL_FIELD_CONTEXT's TYPE_ALIGN.
|
- it would do suboptimal job for COMPONENT_REFs, even if MEM_EXPR
|
- it would do suboptimal job for COMPONENT_REFs, even if MEM_EXPR
|
isn't sufficiently aligned, the object it is in might be. */
|
isn't sufficiently aligned, the object it is in might be. */
|
gcc_assert (MEM_P (mem));
|
gcc_assert (MEM_P (mem));
|
expr = MEM_EXPR (mem);
|
expr = MEM_EXPR (mem);
|
if (expr == NULL_TREE
|
if (expr == NULL_TREE
|
|| MEM_OFFSET (mem) == NULL_RTX
|
|| MEM_OFFSET (mem) == NULL_RTX
|
|| !CONST_INT_P (MEM_OFFSET (mem)))
|
|| !CONST_INT_P (MEM_OFFSET (mem)))
|
return -1;
|
return -1;
|
|
|
offset = INTVAL (MEM_OFFSET (mem));
|
offset = INTVAL (MEM_OFFSET (mem));
|
if (DECL_P (expr))
|
if (DECL_P (expr))
|
{
|
{
|
if (DECL_ALIGN (expr) < align)
|
if (DECL_ALIGN (expr) < align)
|
return -1;
|
return -1;
|
}
|
}
|
else if (INDIRECT_REF_P (expr))
|
else if (INDIRECT_REF_P (expr))
|
{
|
{
|
if (TYPE_ALIGN (TREE_TYPE (expr)) < (unsigned int) align)
|
if (TYPE_ALIGN (TREE_TYPE (expr)) < (unsigned int) align)
|
return -1;
|
return -1;
|
}
|
}
|
else if (TREE_CODE (expr) == COMPONENT_REF)
|
else if (TREE_CODE (expr) == COMPONENT_REF)
|
{
|
{
|
while (1)
|
while (1)
|
{
|
{
|
tree inner = TREE_OPERAND (expr, 0);
|
tree inner = TREE_OPERAND (expr, 0);
|
tree field = TREE_OPERAND (expr, 1);
|
tree field = TREE_OPERAND (expr, 1);
|
tree byte_offset = component_ref_field_offset (expr);
|
tree byte_offset = component_ref_field_offset (expr);
|
tree bit_offset = DECL_FIELD_BIT_OFFSET (field);
|
tree bit_offset = DECL_FIELD_BIT_OFFSET (field);
|
|
|
if (!byte_offset
|
if (!byte_offset
|
|| !host_integerp (byte_offset, 1)
|
|| !host_integerp (byte_offset, 1)
|
|| !host_integerp (bit_offset, 1))
|
|| !host_integerp (bit_offset, 1))
|
return -1;
|
return -1;
|
|
|
offset += tree_low_cst (byte_offset, 1);
|
offset += tree_low_cst (byte_offset, 1);
|
offset += tree_low_cst (bit_offset, 1) / BITS_PER_UNIT;
|
offset += tree_low_cst (bit_offset, 1) / BITS_PER_UNIT;
|
|
|
if (inner == NULL_TREE)
|
if (inner == NULL_TREE)
|
{
|
{
|
if (TYPE_ALIGN (DECL_FIELD_CONTEXT (field))
|
if (TYPE_ALIGN (DECL_FIELD_CONTEXT (field))
|
< (unsigned int) align)
|
< (unsigned int) align)
|
return -1;
|
return -1;
|
break;
|
break;
|
}
|
}
|
else if (DECL_P (inner))
|
else if (DECL_P (inner))
|
{
|
{
|
if (DECL_ALIGN (inner) < align)
|
if (DECL_ALIGN (inner) < align)
|
return -1;
|
return -1;
|
break;
|
break;
|
}
|
}
|
else if (TREE_CODE (inner) != COMPONENT_REF)
|
else if (TREE_CODE (inner) != COMPONENT_REF)
|
return -1;
|
return -1;
|
expr = inner;
|
expr = inner;
|
}
|
}
|
}
|
}
|
else
|
else
|
return -1;
|
return -1;
|
|
|
return offset & ((align / BITS_PER_UNIT) - 1);
|
return offset & ((align / BITS_PER_UNIT) - 1);
|
}
|
}
|
|
|
/* Given REF (a MEM) and T, either the type of X or the expression
|
/* Given REF (a MEM) and T, either the type of X or the expression
|
corresponding to REF, set the memory attributes. OBJECTP is nonzero
|
corresponding to REF, set the memory attributes. OBJECTP is nonzero
|
if we are making a new object of this type. BITPOS is nonzero if
|
if we are making a new object of this type. BITPOS is nonzero if
|
there is an offset outstanding on T that will be applied later. */
|
there is an offset outstanding on T that will be applied later. */
|
|
|
void
|
void
|
set_mem_attributes_minus_bitpos (rtx ref, tree t, int objectp,
|
set_mem_attributes_minus_bitpos (rtx ref, tree t, int objectp,
|
HOST_WIDE_INT bitpos)
|
HOST_WIDE_INT bitpos)
|
{
|
{
|
alias_set_type alias = MEM_ALIAS_SET (ref);
|
alias_set_type alias = MEM_ALIAS_SET (ref);
|
tree expr = MEM_EXPR (ref);
|
tree expr = MEM_EXPR (ref);
|
rtx offset = MEM_OFFSET (ref);
|
rtx offset = MEM_OFFSET (ref);
|
rtx size = MEM_SIZE (ref);
|
rtx size = MEM_SIZE (ref);
|
unsigned int align = MEM_ALIGN (ref);
|
unsigned int align = MEM_ALIGN (ref);
|
HOST_WIDE_INT apply_bitpos = 0;
|
HOST_WIDE_INT apply_bitpos = 0;
|
tree type;
|
tree type;
|
|
|
/* It can happen that type_for_mode was given a mode for which there
|
/* It can happen that type_for_mode was given a mode for which there
|
is no language-level type. In which case it returns NULL, which
|
is no language-level type. In which case it returns NULL, which
|
we can see here. */
|
we can see here. */
|
if (t == NULL_TREE)
|
if (t == NULL_TREE)
|
return;
|
return;
|
|
|
type = TYPE_P (t) ? t : TREE_TYPE (t);
|
type = TYPE_P (t) ? t : TREE_TYPE (t);
|
if (type == error_mark_node)
|
if (type == error_mark_node)
|
return;
|
return;
|
|
|
/* If we have already set DECL_RTL = ref, get_alias_set will get the
|
/* If we have already set DECL_RTL = ref, get_alias_set will get the
|
wrong answer, as it assumes that DECL_RTL already has the right alias
|
wrong answer, as it assumes that DECL_RTL already has the right alias
|
info. Callers should not set DECL_RTL until after the call to
|
info. Callers should not set DECL_RTL until after the call to
|
set_mem_attributes. */
|
set_mem_attributes. */
|
gcc_assert (!DECL_P (t) || ref != DECL_RTL_IF_SET (t));
|
gcc_assert (!DECL_P (t) || ref != DECL_RTL_IF_SET (t));
|
|
|
/* Get the alias set from the expression or type (perhaps using a
|
/* Get the alias set from the expression or type (perhaps using a
|
front-end routine) and use it. */
|
front-end routine) and use it. */
|
alias = get_alias_set (t);
|
alias = get_alias_set (t);
|
|
|
MEM_VOLATILE_P (ref) |= TYPE_VOLATILE (type);
|
MEM_VOLATILE_P (ref) |= TYPE_VOLATILE (type);
|
MEM_IN_STRUCT_P (ref)
|
MEM_IN_STRUCT_P (ref)
|
= AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE;
|
= AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE;
|
MEM_POINTER (ref) = POINTER_TYPE_P (type);
|
MEM_POINTER (ref) = POINTER_TYPE_P (type);
|
|
|
/* If we are making an object of this type, or if this is a DECL, we know
|
/* If we are making an object of this type, or if this is a DECL, we know
|
that it is a scalar if the type is not an aggregate. */
|
that it is a scalar if the type is not an aggregate. */
|
if ((objectp || DECL_P (t))
|
if ((objectp || DECL_P (t))
|
&& ! AGGREGATE_TYPE_P (type)
|
&& ! AGGREGATE_TYPE_P (type)
|
&& TREE_CODE (type) != COMPLEX_TYPE)
|
&& TREE_CODE (type) != COMPLEX_TYPE)
|
MEM_SCALAR_P (ref) = 1;
|
MEM_SCALAR_P (ref) = 1;
|
|
|
/* We can set the alignment from the type if we are making an object,
|
/* We can set the alignment from the type if we are making an object,
|
this is an INDIRECT_REF, or if TYPE_ALIGN_OK. */
|
this is an INDIRECT_REF, or if TYPE_ALIGN_OK. */
|
if (objectp || TREE_CODE (t) == INDIRECT_REF
|
if (objectp || TREE_CODE (t) == INDIRECT_REF
|
|| TREE_CODE (t) == ALIGN_INDIRECT_REF
|
|| TREE_CODE (t) == ALIGN_INDIRECT_REF
|
|| TYPE_ALIGN_OK (type))
|
|| TYPE_ALIGN_OK (type))
|
align = MAX (align, TYPE_ALIGN (type));
|
align = MAX (align, TYPE_ALIGN (type));
|
else
|
else
|
if (TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
|
if (TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
|
{
|
{
|
if (integer_zerop (TREE_OPERAND (t, 1)))
|
if (integer_zerop (TREE_OPERAND (t, 1)))
|
/* We don't know anything about the alignment. */
|
/* We don't know anything about the alignment. */
|
align = BITS_PER_UNIT;
|
align = BITS_PER_UNIT;
|
else
|
else
|
align = tree_low_cst (TREE_OPERAND (t, 1), 1);
|
align = tree_low_cst (TREE_OPERAND (t, 1), 1);
|
}
|
}
|
|
|
/* If the size is known, we can set that. */
|
/* If the size is known, we can set that. */
|
if (TYPE_SIZE_UNIT (type) && host_integerp (TYPE_SIZE_UNIT (type), 1))
|
if (TYPE_SIZE_UNIT (type) && host_integerp (TYPE_SIZE_UNIT (type), 1))
|
size = GEN_INT (tree_low_cst (TYPE_SIZE_UNIT (type), 1));
|
size = GEN_INT (tree_low_cst (TYPE_SIZE_UNIT (type), 1));
|
|
|
/* If T is not a type, we may be able to deduce some more information about
|
/* If T is not a type, we may be able to deduce some more information about
|
the expression. */
|
the expression. */
|
if (! TYPE_P (t))
|
if (! TYPE_P (t))
|
{
|
{
|
tree base;
|
tree base;
|
bool align_computed = false;
|
bool align_computed = false;
|
|
|
if (TREE_THIS_VOLATILE (t))
|
if (TREE_THIS_VOLATILE (t))
|
MEM_VOLATILE_P (ref) = 1;
|
MEM_VOLATILE_P (ref) = 1;
|
|
|
/* Now remove any conversions: they don't change what the underlying
|
/* Now remove any conversions: they don't change what the underlying
|
object is. Likewise for SAVE_EXPR. */
|
object is. Likewise for SAVE_EXPR. */
|
while (CONVERT_EXPR_P (t)
|
while (CONVERT_EXPR_P (t)
|
|| TREE_CODE (t) == VIEW_CONVERT_EXPR
|
|| TREE_CODE (t) == VIEW_CONVERT_EXPR
|
|| TREE_CODE (t) == SAVE_EXPR)
|
|| TREE_CODE (t) == SAVE_EXPR)
|
t = TREE_OPERAND (t, 0);
|
t = TREE_OPERAND (t, 0);
|
|
|
/* We may look through structure-like accesses for the purposes of
|
/* We may look through structure-like accesses for the purposes of
|
examining TREE_THIS_NOTRAP, but not array-like accesses. */
|
examining TREE_THIS_NOTRAP, but not array-like accesses. */
|
base = t;
|
base = t;
|
while (TREE_CODE (base) == COMPONENT_REF
|
while (TREE_CODE (base) == COMPONENT_REF
|
|| TREE_CODE (base) == REALPART_EXPR
|
|| TREE_CODE (base) == REALPART_EXPR
|
|| TREE_CODE (base) == IMAGPART_EXPR
|
|| TREE_CODE (base) == IMAGPART_EXPR
|
|| TREE_CODE (base) == BIT_FIELD_REF)
|
|| TREE_CODE (base) == BIT_FIELD_REF)
|
base = TREE_OPERAND (base, 0);
|
base = TREE_OPERAND (base, 0);
|
|
|
if (DECL_P (base))
|
if (DECL_P (base))
|
{
|
{
|
if (CODE_CONTAINS_STRUCT (TREE_CODE (base), TS_DECL_WITH_VIS))
|
if (CODE_CONTAINS_STRUCT (TREE_CODE (base), TS_DECL_WITH_VIS))
|
MEM_NOTRAP_P (ref) = !DECL_WEAK (base);
|
MEM_NOTRAP_P (ref) = !DECL_WEAK (base);
|
else
|
else
|
MEM_NOTRAP_P (ref) = 1;
|
MEM_NOTRAP_P (ref) = 1;
|
}
|
}
|
else
|
else
|
MEM_NOTRAP_P (ref) = TREE_THIS_NOTRAP (base);
|
MEM_NOTRAP_P (ref) = TREE_THIS_NOTRAP (base);
|
|
|
base = get_base_address (base);
|
base = get_base_address (base);
|
if (base && DECL_P (base)
|
if (base && DECL_P (base)
|
&& TREE_READONLY (base)
|
&& TREE_READONLY (base)
|
&& (TREE_STATIC (base) || DECL_EXTERNAL (base)))
|
&& (TREE_STATIC (base) || DECL_EXTERNAL (base)))
|
{
|
{
|
tree base_type = TREE_TYPE (base);
|
tree base_type = TREE_TYPE (base);
|
gcc_assert (!(base_type && TYPE_NEEDS_CONSTRUCTING (base_type))
|
gcc_assert (!(base_type && TYPE_NEEDS_CONSTRUCTING (base_type))
|
|| DECL_ARTIFICIAL (base));
|
|| DECL_ARTIFICIAL (base));
|
MEM_READONLY_P (ref) = 1;
|
MEM_READONLY_P (ref) = 1;
|
}
|
}
|
|
|
/* If this expression uses it's parent's alias set, mark it such
|
/* If this expression uses it's parent's alias set, mark it such
|
that we won't change it. */
|
that we won't change it. */
|
if (component_uses_parent_alias_set (t))
|
if (component_uses_parent_alias_set (t))
|
MEM_KEEP_ALIAS_SET_P (ref) = 1;
|
MEM_KEEP_ALIAS_SET_P (ref) = 1;
|
|
|
/* If this is a decl, set the attributes of the MEM from it. */
|
/* If this is a decl, set the attributes of the MEM from it. */
|
if (DECL_P (t))
|
if (DECL_P (t))
|
{
|
{
|
expr = t;
|
expr = t;
|
offset = const0_rtx;
|
offset = const0_rtx;
|
apply_bitpos = bitpos;
|
apply_bitpos = bitpos;
|
size = (DECL_SIZE_UNIT (t)
|
size = (DECL_SIZE_UNIT (t)
|
&& host_integerp (DECL_SIZE_UNIT (t), 1)
|
&& host_integerp (DECL_SIZE_UNIT (t), 1)
|
? GEN_INT (tree_low_cst (DECL_SIZE_UNIT (t), 1)) : 0);
|
? GEN_INT (tree_low_cst (DECL_SIZE_UNIT (t), 1)) : 0);
|
align = DECL_ALIGN (t);
|
align = DECL_ALIGN (t);
|
align_computed = true;
|
align_computed = true;
|
}
|
}
|
|
|
/* If this is a constant, we know the alignment. */
|
/* If this is a constant, we know the alignment. */
|
else if (CONSTANT_CLASS_P (t))
|
else if (CONSTANT_CLASS_P (t))
|
{
|
{
|
align = TYPE_ALIGN (type);
|
align = TYPE_ALIGN (type);
|
#ifdef CONSTANT_ALIGNMENT
|
#ifdef CONSTANT_ALIGNMENT
|
align = CONSTANT_ALIGNMENT (t, align);
|
align = CONSTANT_ALIGNMENT (t, align);
|
#endif
|
#endif
|
align_computed = true;
|
align_computed = true;
|
}
|
}
|
|
|
/* If this is a field reference and not a bit-field, record it. */
|
/* If this is a field reference and not a bit-field, record it. */
|
/* ??? There is some information that can be gleaned from bit-fields,
|
/* ??? There is some information that can be gleaned from bit-fields,
|
such as the word offset in the structure that might be modified.
|
such as the word offset in the structure that might be modified.
|
But skip it for now. */
|
But skip it for now. */
|
else if (TREE_CODE (t) == COMPONENT_REF
|
else if (TREE_CODE (t) == COMPONENT_REF
|
&& ! DECL_BIT_FIELD (TREE_OPERAND (t, 1)))
|
&& ! DECL_BIT_FIELD (TREE_OPERAND (t, 1)))
|
{
|
{
|
expr = t;
|
expr = t;
|
offset = const0_rtx;
|
offset = const0_rtx;
|
apply_bitpos = bitpos;
|
apply_bitpos = bitpos;
|
/* ??? Any reason the field size would be different than
|
/* ??? Any reason the field size would be different than
|
the size we got from the type? */
|
the size we got from the type? */
|
}
|
}
|
|
|
/* If this is an array reference, look for an outer field reference. */
|
/* If this is an array reference, look for an outer field reference. */
|
else if (TREE_CODE (t) == ARRAY_REF)
|
else if (TREE_CODE (t) == ARRAY_REF)
|
{
|
{
|
tree off_tree = size_zero_node;
|
tree off_tree = size_zero_node;
|
/* We can't modify t, because we use it at the end of the
|
/* We can't modify t, because we use it at the end of the
|
function. */
|
function. */
|
tree t2 = t;
|
tree t2 = t;
|
|
|
do
|
do
|
{
|
{
|
tree index = TREE_OPERAND (t2, 1);
|
tree index = TREE_OPERAND (t2, 1);
|
tree low_bound = array_ref_low_bound (t2);
|
tree low_bound = array_ref_low_bound (t2);
|
tree unit_size = array_ref_element_size (t2);
|
tree unit_size = array_ref_element_size (t2);
|
|
|
/* We assume all arrays have sizes that are a multiple of a byte.
|
/* We assume all arrays have sizes that are a multiple of a byte.
|
First subtract the lower bound, if any, in the type of the
|
First subtract the lower bound, if any, in the type of the
|
index, then convert to sizetype and multiply by the size of
|
index, then convert to sizetype and multiply by the size of
|
the array element. */
|
the array element. */
|
if (! integer_zerop (low_bound))
|
if (! integer_zerop (low_bound))
|
index = fold_build2 (MINUS_EXPR, TREE_TYPE (index),
|
index = fold_build2 (MINUS_EXPR, TREE_TYPE (index),
|
index, low_bound);
|
index, low_bound);
|
|
|
off_tree = size_binop (PLUS_EXPR,
|
off_tree = size_binop (PLUS_EXPR,
|
size_binop (MULT_EXPR,
|
size_binop (MULT_EXPR,
|
fold_convert (sizetype,
|
fold_convert (sizetype,
|
index),
|
index),
|
unit_size),
|
unit_size),
|
off_tree);
|
off_tree);
|
t2 = TREE_OPERAND (t2, 0);
|
t2 = TREE_OPERAND (t2, 0);
|
}
|
}
|
while (TREE_CODE (t2) == ARRAY_REF);
|
while (TREE_CODE (t2) == ARRAY_REF);
|
|
|
if (DECL_P (t2))
|
if (DECL_P (t2))
|
{
|
{
|
expr = t2;
|
expr = t2;
|
offset = NULL;
|
offset = NULL;
|
if (host_integerp (off_tree, 1))
|
if (host_integerp (off_tree, 1))
|
{
|
{
|
HOST_WIDE_INT ioff = tree_low_cst (off_tree, 1);
|
HOST_WIDE_INT ioff = tree_low_cst (off_tree, 1);
|
HOST_WIDE_INT aoff = (ioff & -ioff) * BITS_PER_UNIT;
|
HOST_WIDE_INT aoff = (ioff & -ioff) * BITS_PER_UNIT;
|
align = DECL_ALIGN (t2);
|
align = DECL_ALIGN (t2);
|
if (aoff && (unsigned HOST_WIDE_INT) aoff < align)
|
if (aoff && (unsigned HOST_WIDE_INT) aoff < align)
|
align = aoff;
|
align = aoff;
|
align_computed = true;
|
align_computed = true;
|
offset = GEN_INT (ioff);
|
offset = GEN_INT (ioff);
|
apply_bitpos = bitpos;
|
apply_bitpos = bitpos;
|
}
|
}
|
}
|
}
|
else if (TREE_CODE (t2) == COMPONENT_REF)
|
else if (TREE_CODE (t2) == COMPONENT_REF)
|
{
|
{
|
expr = t2;
|
expr = t2;
|
offset = NULL;
|
offset = NULL;
|
if (host_integerp (off_tree, 1))
|
if (host_integerp (off_tree, 1))
|
{
|
{
|
offset = GEN_INT (tree_low_cst (off_tree, 1));
|
offset = GEN_INT (tree_low_cst (off_tree, 1));
|
apply_bitpos = bitpos;
|
apply_bitpos = bitpos;
|
}
|
}
|
/* ??? Any reason the field size would be different than
|
/* ??? Any reason the field size would be different than
|
the size we got from the type? */
|
the size we got from the type? */
|
}
|
}
|
else if (flag_argument_noalias > 1
|
else if (flag_argument_noalias > 1
|
&& (INDIRECT_REF_P (t2))
|
&& (INDIRECT_REF_P (t2))
|
&& TREE_CODE (TREE_OPERAND (t2, 0)) == PARM_DECL)
|
&& TREE_CODE (TREE_OPERAND (t2, 0)) == PARM_DECL)
|
{
|
{
|
expr = t2;
|
expr = t2;
|
offset = NULL;
|
offset = NULL;
|
}
|
}
|
}
|
}
|
|
|
/* If this is a Fortran indirect argument reference, record the
|
/* If this is a Fortran indirect argument reference, record the
|
parameter decl. */
|
parameter decl. */
|
else if (flag_argument_noalias > 1
|
else if (flag_argument_noalias > 1
|
&& (INDIRECT_REF_P (t))
|
&& (INDIRECT_REF_P (t))
|
&& TREE_CODE (TREE_OPERAND (t, 0)) == PARM_DECL)
|
&& TREE_CODE (TREE_OPERAND (t, 0)) == PARM_DECL)
|
{
|
{
|
expr = t;
|
expr = t;
|
offset = NULL;
|
offset = NULL;
|
}
|
}
|
|
|
if (!align_computed && !INDIRECT_REF_P (t))
|
if (!align_computed && !INDIRECT_REF_P (t))
|
{
|
{
|
unsigned int obj_align
|
unsigned int obj_align
|
= get_object_alignment (t, align, BIGGEST_ALIGNMENT);
|
= get_object_alignment (t, align, BIGGEST_ALIGNMENT);
|
align = MAX (align, obj_align);
|
align = MAX (align, obj_align);
|
}
|
}
|
}
|
}
|
|
|
/* If we modified OFFSET based on T, then subtract the outstanding
|
/* If we modified OFFSET based on T, then subtract the outstanding
|
bit position offset. Similarly, increase the size of the accessed
|
bit position offset. Similarly, increase the size of the accessed
|
object to contain the negative offset. */
|
object to contain the negative offset. */
|
if (apply_bitpos)
|
if (apply_bitpos)
|
{
|
{
|
offset = plus_constant (offset, -(apply_bitpos / BITS_PER_UNIT));
|
offset = plus_constant (offset, -(apply_bitpos / BITS_PER_UNIT));
|
if (size)
|
if (size)
|
size = plus_constant (size, apply_bitpos / BITS_PER_UNIT);
|
size = plus_constant (size, apply_bitpos / BITS_PER_UNIT);
|
}
|
}
|
|
|
if (TREE_CODE (t) == ALIGN_INDIRECT_REF)
|
if (TREE_CODE (t) == ALIGN_INDIRECT_REF)
|
{
|
{
|
/* Force EXPR and OFFSET to NULL, since we don't know exactly what
|
/* Force EXPR and OFFSET to NULL, since we don't know exactly what
|
we're overlapping. */
|
we're overlapping. */
|
offset = NULL;
|
offset = NULL;
|
expr = NULL;
|
expr = NULL;
|
}
|
}
|
|
|
/* Now set the attributes we computed above. */
|
/* Now set the attributes we computed above. */
|
MEM_ATTRS (ref)
|
MEM_ATTRS (ref)
|
= get_mem_attrs (alias, expr, offset, size, align,
|
= get_mem_attrs (alias, expr, offset, size, align,
|
TYPE_ADDR_SPACE (type), GET_MODE (ref));
|
TYPE_ADDR_SPACE (type), GET_MODE (ref));
|
|
|
/* If this is already known to be a scalar or aggregate, we are done. */
|
/* If this is already known to be a scalar or aggregate, we are done. */
|
if (MEM_IN_STRUCT_P (ref) || MEM_SCALAR_P (ref))
|
if (MEM_IN_STRUCT_P (ref) || MEM_SCALAR_P (ref))
|
return;
|
return;
|
|
|
/* If it is a reference into an aggregate, this is part of an aggregate.
|
/* If it is a reference into an aggregate, this is part of an aggregate.
|
Otherwise we don't know. */
|
Otherwise we don't know. */
|
else if (TREE_CODE (t) == COMPONENT_REF || TREE_CODE (t) == ARRAY_REF
|
else if (TREE_CODE (t) == COMPONENT_REF || TREE_CODE (t) == ARRAY_REF
|
|| TREE_CODE (t) == ARRAY_RANGE_REF
|
|| TREE_CODE (t) == ARRAY_RANGE_REF
|
|| TREE_CODE (t) == BIT_FIELD_REF)
|
|| TREE_CODE (t) == BIT_FIELD_REF)
|
MEM_IN_STRUCT_P (ref) = 1;
|
MEM_IN_STRUCT_P (ref) = 1;
|
}
|
}
|
|
|
void
|
void
|
set_mem_attributes (rtx ref, tree t, int objectp)
|
set_mem_attributes (rtx ref, tree t, int objectp)
|
{
|
{
|
set_mem_attributes_minus_bitpos (ref, t, objectp, 0);
|
set_mem_attributes_minus_bitpos (ref, t, objectp, 0);
|
}
|
}
|
|
|
/* Set the alias set of MEM to SET. */
|
/* Set the alias set of MEM to SET. */
|
|
|
void
|
void
|
set_mem_alias_set (rtx mem, alias_set_type set)
|
set_mem_alias_set (rtx mem, alias_set_type set)
|
{
|
{
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
/* If the new and old alias sets don't conflict, something is wrong. */
|
/* If the new and old alias sets don't conflict, something is wrong. */
|
gcc_assert (alias_sets_conflict_p (set, MEM_ALIAS_SET (mem)));
|
gcc_assert (alias_sets_conflict_p (set, MEM_ALIAS_SET (mem)));
|
#endif
|
#endif
|
|
|
MEM_ATTRS (mem) = get_mem_attrs (set, MEM_EXPR (mem), MEM_OFFSET (mem),
|
MEM_ATTRS (mem) = get_mem_attrs (set, MEM_EXPR (mem), MEM_OFFSET (mem),
|
MEM_SIZE (mem), MEM_ALIGN (mem),
|
MEM_SIZE (mem), MEM_ALIGN (mem),
|
MEM_ADDR_SPACE (mem), GET_MODE (mem));
|
MEM_ADDR_SPACE (mem), GET_MODE (mem));
|
}
|
}
|
|
|
/* Set the address space of MEM to ADDRSPACE (target-defined). */
|
/* Set the address space of MEM to ADDRSPACE (target-defined). */
|
|
|
void
|
void
|
set_mem_addr_space (rtx mem, addr_space_t addrspace)
|
set_mem_addr_space (rtx mem, addr_space_t addrspace)
|
{
|
{
|
MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
|
MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
|
MEM_OFFSET (mem), MEM_SIZE (mem),
|
MEM_OFFSET (mem), MEM_SIZE (mem),
|
MEM_ALIGN (mem), addrspace, GET_MODE (mem));
|
MEM_ALIGN (mem), addrspace, GET_MODE (mem));
|
}
|
}
|
|
|
/* Set the alignment of MEM to ALIGN bits. */
|
/* Set the alignment of MEM to ALIGN bits. */
|
|
|
void
|
void
|
set_mem_align (rtx mem, unsigned int align)
|
set_mem_align (rtx mem, unsigned int align)
|
{
|
{
|
MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
|
MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
|
MEM_OFFSET (mem), MEM_SIZE (mem), align,
|
MEM_OFFSET (mem), MEM_SIZE (mem), align,
|
MEM_ADDR_SPACE (mem), GET_MODE (mem));
|
MEM_ADDR_SPACE (mem), GET_MODE (mem));
|
}
|
}
|
|
|
/* Set the expr for MEM to EXPR. */
|
/* Set the expr for MEM to EXPR. */
|
|
|
void
|
void
|
set_mem_expr (rtx mem, tree expr)
|
set_mem_expr (rtx mem, tree expr)
|
{
|
{
|
MEM_ATTRS (mem)
|
MEM_ATTRS (mem)
|
= get_mem_attrs (MEM_ALIAS_SET (mem), expr, MEM_OFFSET (mem),
|
= get_mem_attrs (MEM_ALIAS_SET (mem), expr, MEM_OFFSET (mem),
|
MEM_SIZE (mem), MEM_ALIGN (mem),
|
MEM_SIZE (mem), MEM_ALIGN (mem),
|
MEM_ADDR_SPACE (mem), GET_MODE (mem));
|
MEM_ADDR_SPACE (mem), GET_MODE (mem));
|
}
|
}
|
|
|
/* Set the offset of MEM to OFFSET. */
|
/* Set the offset of MEM to OFFSET. */
|
|
|
void
|
void
|
set_mem_offset (rtx mem, rtx offset)
|
set_mem_offset (rtx mem, rtx offset)
|
{
|
{
|
MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
|
MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
|
offset, MEM_SIZE (mem), MEM_ALIGN (mem),
|
offset, MEM_SIZE (mem), MEM_ALIGN (mem),
|
MEM_ADDR_SPACE (mem), GET_MODE (mem));
|
MEM_ADDR_SPACE (mem), GET_MODE (mem));
|
}
|
}
|
|
|
/* Set the size of MEM to SIZE. */
|
/* Set the size of MEM to SIZE. */
|
|
|
void
|
void
|
set_mem_size (rtx mem, rtx size)
|
set_mem_size (rtx mem, rtx size)
|
{
|
{
|
MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
|
MEM_ATTRS (mem) = get_mem_attrs (MEM_ALIAS_SET (mem), MEM_EXPR (mem),
|
MEM_OFFSET (mem), size, MEM_ALIGN (mem),
|
MEM_OFFSET (mem), size, MEM_ALIGN (mem),
|
MEM_ADDR_SPACE (mem), GET_MODE (mem));
|
MEM_ADDR_SPACE (mem), GET_MODE (mem));
|
}
|
}
|
|
|
/* Return a memory reference like MEMREF, but with its mode changed to MODE
|
/* Return a memory reference like MEMREF, but with its mode changed to MODE
|
and its address changed to ADDR. (VOIDmode means don't change the mode.
|
and its address changed to ADDR. (VOIDmode means don't change the mode.
|
NULL for ADDR means don't change the address.) VALIDATE is nonzero if the
|
NULL for ADDR means don't change the address.) VALIDATE is nonzero if the
|
returned memory location is required to be valid. The memory
|
returned memory location is required to be valid. The memory
|
attributes are not changed. */
|
attributes are not changed. */
|
|
|
static rtx
|
static rtx
|
change_address_1 (rtx memref, enum machine_mode mode, rtx addr, int validate)
|
change_address_1 (rtx memref, enum machine_mode mode, rtx addr, int validate)
|
{
|
{
|
addr_space_t as;
|
addr_space_t as;
|
rtx new_rtx;
|
rtx new_rtx;
|
|
|
gcc_assert (MEM_P (memref));
|
gcc_assert (MEM_P (memref));
|
as = MEM_ADDR_SPACE (memref);
|
as = MEM_ADDR_SPACE (memref);
|
if (mode == VOIDmode)
|
if (mode == VOIDmode)
|
mode = GET_MODE (memref);
|
mode = GET_MODE (memref);
|
if (addr == 0)
|
if (addr == 0)
|
addr = XEXP (memref, 0);
|
addr = XEXP (memref, 0);
|
if (mode == GET_MODE (memref) && addr == XEXP (memref, 0)
|
if (mode == GET_MODE (memref) && addr == XEXP (memref, 0)
|
&& (!validate || memory_address_addr_space_p (mode, addr, as)))
|
&& (!validate || memory_address_addr_space_p (mode, addr, as)))
|
return memref;
|
return memref;
|
|
|
if (validate)
|
if (validate)
|
{
|
{
|
if (reload_in_progress || reload_completed)
|
if (reload_in_progress || reload_completed)
|
gcc_assert (memory_address_addr_space_p (mode, addr, as));
|
gcc_assert (memory_address_addr_space_p (mode, addr, as));
|
else
|
else
|
addr = memory_address_addr_space (mode, addr, as);
|
addr = memory_address_addr_space (mode, addr, as);
|
}
|
}
|
|
|
if (rtx_equal_p (addr, XEXP (memref, 0)) && mode == GET_MODE (memref))
|
if (rtx_equal_p (addr, XEXP (memref, 0)) && mode == GET_MODE (memref))
|
return memref;
|
return memref;
|
|
|
new_rtx = gen_rtx_MEM (mode, addr);
|
new_rtx = gen_rtx_MEM (mode, addr);
|
MEM_COPY_ATTRIBUTES (new_rtx, memref);
|
MEM_COPY_ATTRIBUTES (new_rtx, memref);
|
return new_rtx;
|
return new_rtx;
|
}
|
}
|
|
|
/* Like change_address_1 with VALIDATE nonzero, but we are not saying in what
|
/* Like change_address_1 with VALIDATE nonzero, but we are not saying in what
|
way we are changing MEMREF, so we only preserve the alias set. */
|
way we are changing MEMREF, so we only preserve the alias set. */
|
|
|
rtx
|
rtx
|
change_address (rtx memref, enum machine_mode mode, rtx addr)
|
change_address (rtx memref, enum machine_mode mode, rtx addr)
|
{
|
{
|
rtx new_rtx = change_address_1 (memref, mode, addr, 1), size;
|
rtx new_rtx = change_address_1 (memref, mode, addr, 1), size;
|
enum machine_mode mmode = GET_MODE (new_rtx);
|
enum machine_mode mmode = GET_MODE (new_rtx);
|
unsigned int align;
|
unsigned int align;
|
|
|
size = mmode == BLKmode ? 0 : GEN_INT (GET_MODE_SIZE (mmode));
|
size = mmode == BLKmode ? 0 : GEN_INT (GET_MODE_SIZE (mmode));
|
align = mmode == BLKmode ? BITS_PER_UNIT : GET_MODE_ALIGNMENT (mmode);
|
align = mmode == BLKmode ? BITS_PER_UNIT : GET_MODE_ALIGNMENT (mmode);
|
|
|
/* If there are no changes, just return the original memory reference. */
|
/* If there are no changes, just return the original memory reference. */
|
if (new_rtx == memref)
|
if (new_rtx == memref)
|
{
|
{
|
if (MEM_ATTRS (memref) == 0
|
if (MEM_ATTRS (memref) == 0
|
|| (MEM_EXPR (memref) == NULL
|
|| (MEM_EXPR (memref) == NULL
|
&& MEM_OFFSET (memref) == NULL
|
&& MEM_OFFSET (memref) == NULL
|
&& MEM_SIZE (memref) == size
|
&& MEM_SIZE (memref) == size
|
&& MEM_ALIGN (memref) == align))
|
&& MEM_ALIGN (memref) == align))
|
return new_rtx;
|
return new_rtx;
|
|
|
new_rtx = gen_rtx_MEM (mmode, XEXP (memref, 0));
|
new_rtx = gen_rtx_MEM (mmode, XEXP (memref, 0));
|
MEM_COPY_ATTRIBUTES (new_rtx, memref);
|
MEM_COPY_ATTRIBUTES (new_rtx, memref);
|
}
|
}
|
|
|
MEM_ATTRS (new_rtx)
|
MEM_ATTRS (new_rtx)
|
= get_mem_attrs (MEM_ALIAS_SET (memref), 0, 0, size, align,
|
= get_mem_attrs (MEM_ALIAS_SET (memref), 0, 0, size, align,
|
MEM_ADDR_SPACE (memref), mmode);
|
MEM_ADDR_SPACE (memref), mmode);
|
|
|
return new_rtx;
|
return new_rtx;
|
}
|
}
|
|
|
/* Return a memory reference like MEMREF, but with its mode changed
|
/* Return a memory reference like MEMREF, but with its mode changed
|
to MODE and its address offset by OFFSET bytes. If VALIDATE is
|
to MODE and its address offset by OFFSET bytes. If VALIDATE is
|
nonzero, the memory address is forced to be valid.
|
nonzero, the memory address is forced to be valid.
|
If ADJUST is zero, OFFSET is only used to update MEM_ATTRS
|
If ADJUST is zero, OFFSET is only used to update MEM_ATTRS
|
and caller is responsible for adjusting MEMREF base register. */
|
and caller is responsible for adjusting MEMREF base register. */
|
|
|
rtx
|
rtx
|
adjust_address_1 (rtx memref, enum machine_mode mode, HOST_WIDE_INT offset,
|
adjust_address_1 (rtx memref, enum machine_mode mode, HOST_WIDE_INT offset,
|
int validate, int adjust)
|
int validate, int adjust)
|
{
|
{
|
rtx addr = XEXP (memref, 0);
|
rtx addr = XEXP (memref, 0);
|
rtx new_rtx;
|
rtx new_rtx;
|
rtx memoffset = MEM_OFFSET (memref);
|
rtx memoffset = MEM_OFFSET (memref);
|
rtx size = 0;
|
rtx size = 0;
|
unsigned int memalign = MEM_ALIGN (memref);
|
unsigned int memalign = MEM_ALIGN (memref);
|
addr_space_t as = MEM_ADDR_SPACE (memref);
|
addr_space_t as = MEM_ADDR_SPACE (memref);
|
enum machine_mode address_mode = targetm.addr_space.address_mode (as);
|
enum machine_mode address_mode = targetm.addr_space.address_mode (as);
|
int pbits;
|
int pbits;
|
|
|
/* If there are no changes, just return the original memory reference. */
|
/* If there are no changes, just return the original memory reference. */
|
if (mode == GET_MODE (memref) && !offset
|
if (mode == GET_MODE (memref) && !offset
|
&& (!validate || memory_address_addr_space_p (mode, addr, as)))
|
&& (!validate || memory_address_addr_space_p (mode, addr, as)))
|
return memref;
|
return memref;
|
|
|
/* ??? Prefer to create garbage instead of creating shared rtl.
|
/* ??? Prefer to create garbage instead of creating shared rtl.
|
This may happen even if offset is nonzero -- consider
|
This may happen even if offset is nonzero -- consider
|
(plus (plus reg reg) const_int) -- so do this always. */
|
(plus (plus reg reg) const_int) -- so do this always. */
|
addr = copy_rtx (addr);
|
addr = copy_rtx (addr);
|
|
|
/* Convert a possibly large offset to a signed value within the
|
/* Convert a possibly large offset to a signed value within the
|
range of the target address space. */
|
range of the target address space. */
|
pbits = GET_MODE_BITSIZE (address_mode);
|
pbits = GET_MODE_BITSIZE (address_mode);
|
if (HOST_BITS_PER_WIDE_INT > pbits)
|
if (HOST_BITS_PER_WIDE_INT > pbits)
|
{
|
{
|
int shift = HOST_BITS_PER_WIDE_INT - pbits;
|
int shift = HOST_BITS_PER_WIDE_INT - pbits;
|
offset = (((HOST_WIDE_INT) ((unsigned HOST_WIDE_INT) offset << shift))
|
offset = (((HOST_WIDE_INT) ((unsigned HOST_WIDE_INT) offset << shift))
|
>> shift);
|
>> shift);
|
}
|
}
|
|
|
if (adjust)
|
if (adjust)
|
{
|
{
|
/* If MEMREF is a LO_SUM and the offset is within the alignment of the
|
/* If MEMREF is a LO_SUM and the offset is within the alignment of the
|
object, we can merge it into the LO_SUM. */
|
object, we can merge it into the LO_SUM. */
|
if (GET_MODE (memref) != BLKmode && GET_CODE (addr) == LO_SUM
|
if (GET_MODE (memref) != BLKmode && GET_CODE (addr) == LO_SUM
|
&& offset >= 0
|
&& offset >= 0
|
&& (unsigned HOST_WIDE_INT) offset
|
&& (unsigned HOST_WIDE_INT) offset
|
< GET_MODE_ALIGNMENT (GET_MODE (memref)) / BITS_PER_UNIT)
|
< GET_MODE_ALIGNMENT (GET_MODE (memref)) / BITS_PER_UNIT)
|
addr = gen_rtx_LO_SUM (address_mode, XEXP (addr, 0),
|
addr = gen_rtx_LO_SUM (address_mode, XEXP (addr, 0),
|
plus_constant (XEXP (addr, 1), offset));
|
plus_constant (XEXP (addr, 1), offset));
|
else
|
else
|
addr = plus_constant (addr, offset);
|
addr = plus_constant (addr, offset);
|
}
|
}
|
|
|
new_rtx = change_address_1 (memref, mode, addr, validate);
|
new_rtx = change_address_1 (memref, mode, addr, validate);
|
|
|
/* If the address is a REG, change_address_1 rightfully returns memref,
|
/* If the address is a REG, change_address_1 rightfully returns memref,
|
but this would destroy memref's MEM_ATTRS. */
|
but this would destroy memref's MEM_ATTRS. */
|
if (new_rtx == memref && offset != 0)
|
if (new_rtx == memref && offset != 0)
|
new_rtx = copy_rtx (new_rtx);
|
new_rtx = copy_rtx (new_rtx);
|
|
|
/* Compute the new values of the memory attributes due to this adjustment.
|
/* Compute the new values of the memory attributes due to this adjustment.
|
We add the offsets and update the alignment. */
|
We add the offsets and update the alignment. */
|
if (memoffset)
|
if (memoffset)
|
memoffset = GEN_INT (offset + INTVAL (memoffset));
|
memoffset = GEN_INT (offset + INTVAL (memoffset));
|
|
|
/* Compute the new alignment by taking the MIN of the alignment and the
|
/* Compute the new alignment by taking the MIN of the alignment and the
|
lowest-order set bit in OFFSET, but don't change the alignment if OFFSET
|
lowest-order set bit in OFFSET, but don't change the alignment if OFFSET
|
if zero. */
|
if zero. */
|
if (offset != 0)
|
if (offset != 0)
|
memalign
|
memalign
|
= MIN (memalign,
|
= MIN (memalign,
|
(unsigned HOST_WIDE_INT) (offset & -offset) * BITS_PER_UNIT);
|
(unsigned HOST_WIDE_INT) (offset & -offset) * BITS_PER_UNIT);
|
|
|
/* We can compute the size in a number of ways. */
|
/* We can compute the size in a number of ways. */
|
if (GET_MODE (new_rtx) != BLKmode)
|
if (GET_MODE (new_rtx) != BLKmode)
|
size = GEN_INT (GET_MODE_SIZE (GET_MODE (new_rtx)));
|
size = GEN_INT (GET_MODE_SIZE (GET_MODE (new_rtx)));
|
else if (MEM_SIZE (memref))
|
else if (MEM_SIZE (memref))
|
size = plus_constant (MEM_SIZE (memref), -offset);
|
size = plus_constant (MEM_SIZE (memref), -offset);
|
|
|
MEM_ATTRS (new_rtx) = get_mem_attrs (MEM_ALIAS_SET (memref), MEM_EXPR (memref),
|
MEM_ATTRS (new_rtx) = get_mem_attrs (MEM_ALIAS_SET (memref), MEM_EXPR (memref),
|
memoffset, size, memalign, as,
|
memoffset, size, memalign, as,
|
GET_MODE (new_rtx));
|
GET_MODE (new_rtx));
|
|
|
/* At some point, we should validate that this offset is within the object,
|
/* At some point, we should validate that this offset is within the object,
|
if all the appropriate values are known. */
|
if all the appropriate values are known. */
|
return new_rtx;
|
return new_rtx;
|
}
|
}
|
|
|
/* Return a memory reference like MEMREF, but with its mode changed
|
/* Return a memory reference like MEMREF, but with its mode changed
|
to MODE and its address changed to ADDR, which is assumed to be
|
to MODE and its address changed to ADDR, which is assumed to be
|
MEMREF offset by OFFSET bytes. If VALIDATE is
|
MEMREF offset by OFFSET bytes. If VALIDATE is
|
nonzero, the memory address is forced to be valid. */
|
nonzero, the memory address is forced to be valid. */
|
|
|
rtx
|
rtx
|
adjust_automodify_address_1 (rtx memref, enum machine_mode mode, rtx addr,
|
adjust_automodify_address_1 (rtx memref, enum machine_mode mode, rtx addr,
|
HOST_WIDE_INT offset, int validate)
|
HOST_WIDE_INT offset, int validate)
|
{
|
{
|
memref = change_address_1 (memref, VOIDmode, addr, validate);
|
memref = change_address_1 (memref, VOIDmode, addr, validate);
|
return adjust_address_1 (memref, mode, offset, validate, 0);
|
return adjust_address_1 (memref, mode, offset, validate, 0);
|
}
|
}
|
|
|
/* Return a memory reference like MEMREF, but whose address is changed by
|
/* Return a memory reference like MEMREF, but whose address is changed by
|
adding OFFSET, an RTX, to it. POW2 is the highest power of two factor
|
adding OFFSET, an RTX, to it. POW2 is the highest power of two factor
|
known to be in OFFSET (possibly 1). */
|
known to be in OFFSET (possibly 1). */
|
|
|
rtx
|
rtx
|
offset_address (rtx memref, rtx offset, unsigned HOST_WIDE_INT pow2)
|
offset_address (rtx memref, rtx offset, unsigned HOST_WIDE_INT pow2)
|
{
|
{
|
rtx new_rtx, addr = XEXP (memref, 0);
|
rtx new_rtx, addr = XEXP (memref, 0);
|
addr_space_t as = MEM_ADDR_SPACE (memref);
|
addr_space_t as = MEM_ADDR_SPACE (memref);
|
enum machine_mode address_mode = targetm.addr_space.address_mode (as);
|
enum machine_mode address_mode = targetm.addr_space.address_mode (as);
|
|
|
new_rtx = simplify_gen_binary (PLUS, address_mode, addr, offset);
|
new_rtx = simplify_gen_binary (PLUS, address_mode, addr, offset);
|
|
|
/* At this point we don't know _why_ the address is invalid. It
|
/* At this point we don't know _why_ the address is invalid. It
|
could have secondary memory references, multiplies or anything.
|
could have secondary memory references, multiplies or anything.
|
|
|
However, if we did go and rearrange things, we can wind up not
|
However, if we did go and rearrange things, we can wind up not
|
being able to recognize the magic around pic_offset_table_rtx.
|
being able to recognize the magic around pic_offset_table_rtx.
|
This stuff is fragile, and is yet another example of why it is
|
This stuff is fragile, and is yet another example of why it is
|
bad to expose PIC machinery too early. */
|
bad to expose PIC machinery too early. */
|
if (! memory_address_addr_space_p (GET_MODE (memref), new_rtx, as)
|
if (! memory_address_addr_space_p (GET_MODE (memref), new_rtx, as)
|
&& GET_CODE (addr) == PLUS
|
&& GET_CODE (addr) == PLUS
|
&& XEXP (addr, 0) == pic_offset_table_rtx)
|
&& XEXP (addr, 0) == pic_offset_table_rtx)
|
{
|
{
|
addr = force_reg (GET_MODE (addr), addr);
|
addr = force_reg (GET_MODE (addr), addr);
|
new_rtx = simplify_gen_binary (PLUS, address_mode, addr, offset);
|
new_rtx = simplify_gen_binary (PLUS, address_mode, addr, offset);
|
}
|
}
|
|
|
update_temp_slot_address (XEXP (memref, 0), new_rtx);
|
update_temp_slot_address (XEXP (memref, 0), new_rtx);
|
new_rtx = change_address_1 (memref, VOIDmode, new_rtx, 1);
|
new_rtx = change_address_1 (memref, VOIDmode, new_rtx, 1);
|
|
|
/* If there are no changes, just return the original memory reference. */
|
/* If there are no changes, just return the original memory reference. */
|
if (new_rtx == memref)
|
if (new_rtx == memref)
|
return new_rtx;
|
return new_rtx;
|
|
|
/* Update the alignment to reflect the offset. Reset the offset, which
|
/* Update the alignment to reflect the offset. Reset the offset, which
|
we don't know. */
|
we don't know. */
|
MEM_ATTRS (new_rtx)
|
MEM_ATTRS (new_rtx)
|
= get_mem_attrs (MEM_ALIAS_SET (memref), MEM_EXPR (memref), 0, 0,
|
= get_mem_attrs (MEM_ALIAS_SET (memref), MEM_EXPR (memref), 0, 0,
|
MIN (MEM_ALIGN (memref), pow2 * BITS_PER_UNIT),
|
MIN (MEM_ALIGN (memref), pow2 * BITS_PER_UNIT),
|
as, GET_MODE (new_rtx));
|
as, GET_MODE (new_rtx));
|
return new_rtx;
|
return new_rtx;
|
}
|
}
|
|
|
/* Return a memory reference like MEMREF, but with its address changed to
|
/* Return a memory reference like MEMREF, but with its address changed to
|
ADDR. The caller is asserting that the actual piece of memory pointed
|
ADDR. The caller is asserting that the actual piece of memory pointed
|
to is the same, just the form of the address is being changed, such as
|
to is the same, just the form of the address is being changed, such as
|
by putting something into a register. */
|
by putting something into a register. */
|
|
|
rtx
|
rtx
|
replace_equiv_address (rtx memref, rtx addr)
|
replace_equiv_address (rtx memref, rtx addr)
|
{
|
{
|
/* change_address_1 copies the memory attribute structure without change
|
/* change_address_1 copies the memory attribute structure without change
|
and that's exactly what we want here. */
|
and that's exactly what we want here. */
|
update_temp_slot_address (XEXP (memref, 0), addr);
|
update_temp_slot_address (XEXP (memref, 0), addr);
|
return change_address_1 (memref, VOIDmode, addr, 1);
|
return change_address_1 (memref, VOIDmode, addr, 1);
|
}
|
}
|
|
|
/* Likewise, but the reference is not required to be valid. */
|
/* Likewise, but the reference is not required to be valid. */
|
|
|
rtx
|
rtx
|
replace_equiv_address_nv (rtx memref, rtx addr)
|
replace_equiv_address_nv (rtx memref, rtx addr)
|
{
|
{
|
return change_address_1 (memref, VOIDmode, addr, 0);
|
return change_address_1 (memref, VOIDmode, addr, 0);
|
}
|
}
|
|
|
/* Return a memory reference like MEMREF, but with its mode widened to
|
/* Return a memory reference like MEMREF, but with its mode widened to
|
MODE and offset by OFFSET. This would be used by targets that e.g.
|
MODE and offset by OFFSET. This would be used by targets that e.g.
|
cannot issue QImode memory operations and have to use SImode memory
|
cannot issue QImode memory operations and have to use SImode memory
|
operations plus masking logic. */
|
operations plus masking logic. */
|
|
|
rtx
|
rtx
|
widen_memory_access (rtx memref, enum machine_mode mode, HOST_WIDE_INT offset)
|
widen_memory_access (rtx memref, enum machine_mode mode, HOST_WIDE_INT offset)
|
{
|
{
|
rtx new_rtx = adjust_address_1 (memref, mode, offset, 1, 1);
|
rtx new_rtx = adjust_address_1 (memref, mode, offset, 1, 1);
|
tree expr = MEM_EXPR (new_rtx);
|
tree expr = MEM_EXPR (new_rtx);
|
rtx memoffset = MEM_OFFSET (new_rtx);
|
rtx memoffset = MEM_OFFSET (new_rtx);
|
unsigned int size = GET_MODE_SIZE (mode);
|
unsigned int size = GET_MODE_SIZE (mode);
|
|
|
/* If there are no changes, just return the original memory reference. */
|
/* If there are no changes, just return the original memory reference. */
|
if (new_rtx == memref)
|
if (new_rtx == memref)
|
return new_rtx;
|
return new_rtx;
|
|
|
/* If we don't know what offset we were at within the expression, then
|
/* If we don't know what offset we were at within the expression, then
|
we can't know if we've overstepped the bounds. */
|
we can't know if we've overstepped the bounds. */
|
if (! memoffset)
|
if (! memoffset)
|
expr = NULL_TREE;
|
expr = NULL_TREE;
|
|
|
while (expr)
|
while (expr)
|
{
|
{
|
if (TREE_CODE (expr) == COMPONENT_REF)
|
if (TREE_CODE (expr) == COMPONENT_REF)
|
{
|
{
|
tree field = TREE_OPERAND (expr, 1);
|
tree field = TREE_OPERAND (expr, 1);
|
tree offset = component_ref_field_offset (expr);
|
tree offset = component_ref_field_offset (expr);
|
|
|
if (! DECL_SIZE_UNIT (field))
|
if (! DECL_SIZE_UNIT (field))
|
{
|
{
|
expr = NULL_TREE;
|
expr = NULL_TREE;
|
break;
|
break;
|
}
|
}
|
|
|
/* Is the field at least as large as the access? If so, ok,
|
/* Is the field at least as large as the access? If so, ok,
|
otherwise strip back to the containing structure. */
|
otherwise strip back to the containing structure. */
|
if (TREE_CODE (DECL_SIZE_UNIT (field)) == INTEGER_CST
|
if (TREE_CODE (DECL_SIZE_UNIT (field)) == INTEGER_CST
|
&& compare_tree_int (DECL_SIZE_UNIT (field), size) >= 0
|
&& compare_tree_int (DECL_SIZE_UNIT (field), size) >= 0
|
&& INTVAL (memoffset) >= 0)
|
&& INTVAL (memoffset) >= 0)
|
break;
|
break;
|
|
|
if (! host_integerp (offset, 1))
|
if (! host_integerp (offset, 1))
|
{
|
{
|
expr = NULL_TREE;
|
expr = NULL_TREE;
|
break;
|
break;
|
}
|
}
|
|
|
expr = TREE_OPERAND (expr, 0);
|
expr = TREE_OPERAND (expr, 0);
|
memoffset
|
memoffset
|
= (GEN_INT (INTVAL (memoffset)
|
= (GEN_INT (INTVAL (memoffset)
|
+ tree_low_cst (offset, 1)
|
+ tree_low_cst (offset, 1)
|
+ (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
|
+ (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
|
/ BITS_PER_UNIT)));
|
/ BITS_PER_UNIT)));
|
}
|
}
|
/* Similarly for the decl. */
|
/* Similarly for the decl. */
|
else if (DECL_P (expr)
|
else if (DECL_P (expr)
|
&& DECL_SIZE_UNIT (expr)
|
&& DECL_SIZE_UNIT (expr)
|
&& TREE_CODE (DECL_SIZE_UNIT (expr)) == INTEGER_CST
|
&& TREE_CODE (DECL_SIZE_UNIT (expr)) == INTEGER_CST
|
&& compare_tree_int (DECL_SIZE_UNIT (expr), size) >= 0
|
&& compare_tree_int (DECL_SIZE_UNIT (expr), size) >= 0
|
&& (! memoffset || INTVAL (memoffset) >= 0))
|
&& (! memoffset || INTVAL (memoffset) >= 0))
|
break;
|
break;
|
else
|
else
|
{
|
{
|
/* The widened memory access overflows the expression, which means
|
/* The widened memory access overflows the expression, which means
|
that it could alias another expression. Zap it. */
|
that it could alias another expression. Zap it. */
|
expr = NULL_TREE;
|
expr = NULL_TREE;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
if (! expr)
|
if (! expr)
|
memoffset = NULL_RTX;
|
memoffset = NULL_RTX;
|
|
|
/* The widened memory may alias other stuff, so zap the alias set. */
|
/* The widened memory may alias other stuff, so zap the alias set. */
|
/* ??? Maybe use get_alias_set on any remaining expression. */
|
/* ??? Maybe use get_alias_set on any remaining expression. */
|
|
|
MEM_ATTRS (new_rtx) = get_mem_attrs (0, expr, memoffset, GEN_INT (size),
|
MEM_ATTRS (new_rtx) = get_mem_attrs (0, expr, memoffset, GEN_INT (size),
|
MEM_ALIGN (new_rtx),
|
MEM_ALIGN (new_rtx),
|
MEM_ADDR_SPACE (new_rtx), mode);
|
MEM_ADDR_SPACE (new_rtx), mode);
|
|
|
return new_rtx;
|
return new_rtx;
|
}
|
}
|
|
|
/* A fake decl that is used as the MEM_EXPR of spill slots. */
|
/* A fake decl that is used as the MEM_EXPR of spill slots. */
|
static GTY(()) tree spill_slot_decl;
|
static GTY(()) tree spill_slot_decl;
|
|
|
tree
|
tree
|
get_spill_slot_decl (bool force_build_p)
|
get_spill_slot_decl (bool force_build_p)
|
{
|
{
|
tree d = spill_slot_decl;
|
tree d = spill_slot_decl;
|
rtx rd;
|
rtx rd;
|
|
|
if (d || !force_build_p)
|
if (d || !force_build_p)
|
return d;
|
return d;
|
|
|
d = build_decl (DECL_SOURCE_LOCATION (current_function_decl),
|
d = build_decl (DECL_SOURCE_LOCATION (current_function_decl),
|
VAR_DECL, get_identifier ("%sfp"), void_type_node);
|
VAR_DECL, get_identifier ("%sfp"), void_type_node);
|
DECL_ARTIFICIAL (d) = 1;
|
DECL_ARTIFICIAL (d) = 1;
|
DECL_IGNORED_P (d) = 1;
|
DECL_IGNORED_P (d) = 1;
|
TREE_USED (d) = 1;
|
TREE_USED (d) = 1;
|
TREE_THIS_NOTRAP (d) = 1;
|
TREE_THIS_NOTRAP (d) = 1;
|
spill_slot_decl = d;
|
spill_slot_decl = d;
|
|
|
rd = gen_rtx_MEM (BLKmode, frame_pointer_rtx);
|
rd = gen_rtx_MEM (BLKmode, frame_pointer_rtx);
|
MEM_NOTRAP_P (rd) = 1;
|
MEM_NOTRAP_P (rd) = 1;
|
MEM_ATTRS (rd) = get_mem_attrs (new_alias_set (), d, const0_rtx,
|
MEM_ATTRS (rd) = get_mem_attrs (new_alias_set (), d, const0_rtx,
|
NULL_RTX, 0, ADDR_SPACE_GENERIC, BLKmode);
|
NULL_RTX, 0, ADDR_SPACE_GENERIC, BLKmode);
|
SET_DECL_RTL (d, rd);
|
SET_DECL_RTL (d, rd);
|
|
|
return d;
|
return d;
|
}
|
}
|
|
|
/* Given MEM, a result from assign_stack_local, fill in the memory
|
/* Given MEM, a result from assign_stack_local, fill in the memory
|
attributes as appropriate for a register allocator spill slot.
|
attributes as appropriate for a register allocator spill slot.
|
These slots are not aliasable by other memory. We arrange for
|
These slots are not aliasable by other memory. We arrange for
|
them all to use a single MEM_EXPR, so that the aliasing code can
|
them all to use a single MEM_EXPR, so that the aliasing code can
|
work properly in the case of shared spill slots. */
|
work properly in the case of shared spill slots. */
|
|
|
void
|
void
|
set_mem_attrs_for_spill (rtx mem)
|
set_mem_attrs_for_spill (rtx mem)
|
{
|
{
|
alias_set_type alias;
|
alias_set_type alias;
|
rtx addr, offset;
|
rtx addr, offset;
|
tree expr;
|
tree expr;
|
|
|
expr = get_spill_slot_decl (true);
|
expr = get_spill_slot_decl (true);
|
alias = MEM_ALIAS_SET (DECL_RTL (expr));
|
alias = MEM_ALIAS_SET (DECL_RTL (expr));
|
|
|
/* We expect the incoming memory to be of the form:
|
/* We expect the incoming memory to be of the form:
|
(mem:MODE (plus (reg sfp) (const_int offset)))
|
(mem:MODE (plus (reg sfp) (const_int offset)))
|
with perhaps the plus missing for offset = 0. */
|
with perhaps the plus missing for offset = 0. */
|
addr = XEXP (mem, 0);
|
addr = XEXP (mem, 0);
|
offset = const0_rtx;
|
offset = const0_rtx;
|
if (GET_CODE (addr) == PLUS
|
if (GET_CODE (addr) == PLUS
|
&& CONST_INT_P (XEXP (addr, 1)))
|
&& CONST_INT_P (XEXP (addr, 1)))
|
offset = XEXP (addr, 1);
|
offset = XEXP (addr, 1);
|
|
|
MEM_ATTRS (mem) = get_mem_attrs (alias, expr, offset,
|
MEM_ATTRS (mem) = get_mem_attrs (alias, expr, offset,
|
MEM_SIZE (mem), MEM_ALIGN (mem),
|
MEM_SIZE (mem), MEM_ALIGN (mem),
|
ADDR_SPACE_GENERIC, GET_MODE (mem));
|
ADDR_SPACE_GENERIC, GET_MODE (mem));
|
MEM_NOTRAP_P (mem) = 1;
|
MEM_NOTRAP_P (mem) = 1;
|
}
|
}
|
|
|
/* Return a newly created CODE_LABEL rtx with a unique label number. */
|
/* Return a newly created CODE_LABEL rtx with a unique label number. */
|
|
|
rtx
|
rtx
|
gen_label_rtx (void)
|
gen_label_rtx (void)
|
{
|
{
|
return gen_rtx_CODE_LABEL (VOIDmode, 0, NULL_RTX, NULL_RTX,
|
return gen_rtx_CODE_LABEL (VOIDmode, 0, NULL_RTX, NULL_RTX,
|
NULL, label_num++, NULL);
|
NULL, label_num++, NULL);
|
}
|
}
|
|
|
/* For procedure integration. */
|
/* For procedure integration. */
|
|
|
/* Install new pointers to the first and last insns in the chain.
|
/* Install new pointers to the first and last insns in the chain.
|
Also, set cur_insn_uid to one higher than the last in use.
|
Also, set cur_insn_uid to one higher than the last in use.
|
Used for an inline-procedure after copying the insn chain. */
|
Used for an inline-procedure after copying the insn chain. */
|
|
|
void
|
void
|
set_new_first_and_last_insn (rtx first, rtx last)
|
set_new_first_and_last_insn (rtx first, rtx last)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
first_insn = first;
|
first_insn = first;
|
last_insn = last;
|
last_insn = last;
|
cur_insn_uid = 0;
|
cur_insn_uid = 0;
|
|
|
if (MIN_NONDEBUG_INSN_UID || MAY_HAVE_DEBUG_INSNS)
|
if (MIN_NONDEBUG_INSN_UID || MAY_HAVE_DEBUG_INSNS)
|
{
|
{
|
int debug_count = 0;
|
int debug_count = 0;
|
|
|
cur_insn_uid = MIN_NONDEBUG_INSN_UID - 1;
|
cur_insn_uid = MIN_NONDEBUG_INSN_UID - 1;
|
cur_debug_insn_uid = 0;
|
cur_debug_insn_uid = 0;
|
|
|
for (insn = first; insn; insn = NEXT_INSN (insn))
|
for (insn = first; insn; insn = NEXT_INSN (insn))
|
if (INSN_UID (insn) < MIN_NONDEBUG_INSN_UID)
|
if (INSN_UID (insn) < MIN_NONDEBUG_INSN_UID)
|
cur_debug_insn_uid = MAX (cur_debug_insn_uid, INSN_UID (insn));
|
cur_debug_insn_uid = MAX (cur_debug_insn_uid, INSN_UID (insn));
|
else
|
else
|
{
|
{
|
cur_insn_uid = MAX (cur_insn_uid, INSN_UID (insn));
|
cur_insn_uid = MAX (cur_insn_uid, INSN_UID (insn));
|
if (DEBUG_INSN_P (insn))
|
if (DEBUG_INSN_P (insn))
|
debug_count++;
|
debug_count++;
|
}
|
}
|
|
|
if (debug_count)
|
if (debug_count)
|
cur_debug_insn_uid = MIN_NONDEBUG_INSN_UID + debug_count;
|
cur_debug_insn_uid = MIN_NONDEBUG_INSN_UID + debug_count;
|
else
|
else
|
cur_debug_insn_uid++;
|
cur_debug_insn_uid++;
|
}
|
}
|
else
|
else
|
for (insn = first; insn; insn = NEXT_INSN (insn))
|
for (insn = first; insn; insn = NEXT_INSN (insn))
|
cur_insn_uid = MAX (cur_insn_uid, INSN_UID (insn));
|
cur_insn_uid = MAX (cur_insn_uid, INSN_UID (insn));
|
|
|
cur_insn_uid++;
|
cur_insn_uid++;
|
}
|
}
|
|
|
/* Go through all the RTL insn bodies and copy any invalid shared
|
/* Go through all the RTL insn bodies and copy any invalid shared
|
structure. This routine should only be called once. */
|
structure. This routine should only be called once. */
|
|
|
static void
|
static void
|
unshare_all_rtl_1 (rtx insn)
|
unshare_all_rtl_1 (rtx insn)
|
{
|
{
|
/* Unshare just about everything else. */
|
/* Unshare just about everything else. */
|
unshare_all_rtl_in_chain (insn);
|
unshare_all_rtl_in_chain (insn);
|
|
|
/* Make sure the addresses of stack slots found outside the insn chain
|
/* Make sure the addresses of stack slots found outside the insn chain
|
(such as, in DECL_RTL of a variable) are not shared
|
(such as, in DECL_RTL of a variable) are not shared
|
with the insn chain.
|
with the insn chain.
|
|
|
This special care is necessary when the stack slot MEM does not
|
This special care is necessary when the stack slot MEM does not
|
actually appear in the insn chain. If it does appear, its address
|
actually appear in the insn chain. If it does appear, its address
|
is unshared from all else at that point. */
|
is unshared from all else at that point. */
|
stack_slot_list = copy_rtx_if_shared (stack_slot_list);
|
stack_slot_list = copy_rtx_if_shared (stack_slot_list);
|
}
|
}
|
|
|
/* Go through all the RTL insn bodies and copy any invalid shared
|
/* Go through all the RTL insn bodies and copy any invalid shared
|
structure, again. This is a fairly expensive thing to do so it
|
structure, again. This is a fairly expensive thing to do so it
|
should be done sparingly. */
|
should be done sparingly. */
|
|
|
void
|
void
|
unshare_all_rtl_again (rtx insn)
|
unshare_all_rtl_again (rtx insn)
|
{
|
{
|
rtx p;
|
rtx p;
|
tree decl;
|
tree decl;
|
|
|
for (p = insn; p; p = NEXT_INSN (p))
|
for (p = insn; p; p = NEXT_INSN (p))
|
if (INSN_P (p))
|
if (INSN_P (p))
|
{
|
{
|
reset_used_flags (PATTERN (p));
|
reset_used_flags (PATTERN (p));
|
reset_used_flags (REG_NOTES (p));
|
reset_used_flags (REG_NOTES (p));
|
}
|
}
|
|
|
/* Make sure that virtual stack slots are not shared. */
|
/* Make sure that virtual stack slots are not shared. */
|
set_used_decls (DECL_INITIAL (cfun->decl));
|
set_used_decls (DECL_INITIAL (cfun->decl));
|
|
|
/* Make sure that virtual parameters are not shared. */
|
/* Make sure that virtual parameters are not shared. */
|
for (decl = DECL_ARGUMENTS (cfun->decl); decl; decl = TREE_CHAIN (decl))
|
for (decl = DECL_ARGUMENTS (cfun->decl); decl; decl = TREE_CHAIN (decl))
|
set_used_flags (DECL_RTL (decl));
|
set_used_flags (DECL_RTL (decl));
|
|
|
reset_used_flags (stack_slot_list);
|
reset_used_flags (stack_slot_list);
|
|
|
unshare_all_rtl_1 (insn);
|
unshare_all_rtl_1 (insn);
|
}
|
}
|
|
|
unsigned int
|
unsigned int
|
unshare_all_rtl (void)
|
unshare_all_rtl (void)
|
{
|
{
|
unshare_all_rtl_1 (get_insns ());
|
unshare_all_rtl_1 (get_insns ());
|
return 0;
|
return 0;
|
}
|
}
|
|
|
struct rtl_opt_pass pass_unshare_all_rtl =
|
struct rtl_opt_pass pass_unshare_all_rtl =
|
{
|
{
|
{
|
{
|
RTL_PASS,
|
RTL_PASS,
|
"unshare", /* name */
|
"unshare", /* name */
|
NULL, /* gate */
|
NULL, /* gate */
|
unshare_all_rtl, /* execute */
|
unshare_all_rtl, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_NONE, /* tv_id */
|
TV_NONE, /* tv_id */
|
0, /* properties_required */
|
0, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_dump_func | TODO_verify_rtl_sharing /* todo_flags_finish */
|
TODO_dump_func | TODO_verify_rtl_sharing /* todo_flags_finish */
|
}
|
}
|
};
|
};
|
|
|
|
|
/* Check that ORIG is not marked when it should not be and mark ORIG as in use,
|
/* Check that ORIG is not marked when it should not be and mark ORIG as in use,
|
Recursively does the same for subexpressions. */
|
Recursively does the same for subexpressions. */
|
|
|
static void
|
static void
|
verify_rtx_sharing (rtx orig, rtx insn)
|
verify_rtx_sharing (rtx orig, rtx insn)
|
{
|
{
|
rtx x = orig;
|
rtx x = orig;
|
int i;
|
int i;
|
enum rtx_code code;
|
enum rtx_code code;
|
const char *format_ptr;
|
const char *format_ptr;
|
|
|
if (x == 0)
|
if (x == 0)
|
return;
|
return;
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
|
|
/* These types may be freely shared. */
|
/* These types may be freely shared. */
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case REG:
|
case REG:
|
case DEBUG_EXPR:
|
case DEBUG_EXPR:
|
case VALUE:
|
case VALUE:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_FIXED:
|
case CONST_FIXED:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case LABEL_REF:
|
case LABEL_REF:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case PC:
|
case PC:
|
case CC0:
|
case CC0:
|
case SCRATCH:
|
case SCRATCH:
|
return;
|
return;
|
/* SCRATCH must be shared because they represent distinct values. */
|
/* SCRATCH must be shared because they represent distinct values. */
|
case CLOBBER:
|
case CLOBBER:
|
if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
|
if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
|
return;
|
return;
|
break;
|
break;
|
|
|
case CONST:
|
case CONST:
|
if (shared_const_p (orig))
|
if (shared_const_p (orig))
|
return;
|
return;
|
break;
|
break;
|
|
|
case MEM:
|
case MEM:
|
/* A MEM is allowed to be shared if its address is constant. */
|
/* A MEM is allowed to be shared if its address is constant. */
|
if (CONSTANT_ADDRESS_P (XEXP (x, 0))
|
if (CONSTANT_ADDRESS_P (XEXP (x, 0))
|
|| reload_completed || reload_in_progress)
|
|| reload_completed || reload_in_progress)
|
return;
|
return;
|
|
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* This rtx may not be shared. If it has already been seen,
|
/* This rtx may not be shared. If it has already been seen,
|
replace it with a copy of itself. */
|
replace it with a copy of itself. */
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
if (RTX_FLAG (x, used))
|
if (RTX_FLAG (x, used))
|
{
|
{
|
error ("invalid rtl sharing found in the insn");
|
error ("invalid rtl sharing found in the insn");
|
debug_rtx (insn);
|
debug_rtx (insn);
|
error ("shared rtx");
|
error ("shared rtx");
|
debug_rtx (x);
|
debug_rtx (x);
|
internal_error ("internal consistency failure");
|
internal_error ("internal consistency failure");
|
}
|
}
|
#endif
|
#endif
|
gcc_assert (!RTX_FLAG (x, used));
|
gcc_assert (!RTX_FLAG (x, used));
|
|
|
RTX_FLAG (x, used) = 1;
|
RTX_FLAG (x, used) = 1;
|
|
|
/* Now scan the subexpressions recursively. */
|
/* Now scan the subexpressions recursively. */
|
|
|
format_ptr = GET_RTX_FORMAT (code);
|
format_ptr = GET_RTX_FORMAT (code);
|
|
|
for (i = 0; i < GET_RTX_LENGTH (code); i++)
|
for (i = 0; i < GET_RTX_LENGTH (code); i++)
|
{
|
{
|
switch (*format_ptr++)
|
switch (*format_ptr++)
|
{
|
{
|
case 'e':
|
case 'e':
|
verify_rtx_sharing (XEXP (x, i), insn);
|
verify_rtx_sharing (XEXP (x, i), insn);
|
break;
|
break;
|
|
|
case 'E':
|
case 'E':
|
if (XVEC (x, i) != NULL)
|
if (XVEC (x, i) != NULL)
|
{
|
{
|
int j;
|
int j;
|
int len = XVECLEN (x, i);
|
int len = XVECLEN (x, i);
|
|
|
for (j = 0; j < len; j++)
|
for (j = 0; j < len; j++)
|
{
|
{
|
/* We allow sharing of ASM_OPERANDS inside single
|
/* We allow sharing of ASM_OPERANDS inside single
|
instruction. */
|
instruction. */
|
if (j && GET_CODE (XVECEXP (x, i, j)) == SET
|
if (j && GET_CODE (XVECEXP (x, i, j)) == SET
|
&& (GET_CODE (SET_SRC (XVECEXP (x, i, j)))
|
&& (GET_CODE (SET_SRC (XVECEXP (x, i, j)))
|
== ASM_OPERANDS))
|
== ASM_OPERANDS))
|
verify_rtx_sharing (SET_DEST (XVECEXP (x, i, j)), insn);
|
verify_rtx_sharing (SET_DEST (XVECEXP (x, i, j)), insn);
|
else
|
else
|
verify_rtx_sharing (XVECEXP (x, i, j), insn);
|
verify_rtx_sharing (XVECEXP (x, i, j), insn);
|
}
|
}
|
}
|
}
|
break;
|
break;
|
}
|
}
|
}
|
}
|
return;
|
return;
|
}
|
}
|
|
|
/* Go through all the RTL insn bodies and check that there is no unexpected
|
/* Go through all the RTL insn bodies and check that there is no unexpected
|
sharing in between the subexpressions. */
|
sharing in between the subexpressions. */
|
|
|
void
|
void
|
verify_rtl_sharing (void)
|
verify_rtl_sharing (void)
|
{
|
{
|
rtx p;
|
rtx p;
|
|
|
for (p = get_insns (); p; p = NEXT_INSN (p))
|
for (p = get_insns (); p; p = NEXT_INSN (p))
|
if (INSN_P (p))
|
if (INSN_P (p))
|
{
|
{
|
reset_used_flags (PATTERN (p));
|
reset_used_flags (PATTERN (p));
|
reset_used_flags (REG_NOTES (p));
|
reset_used_flags (REG_NOTES (p));
|
if (GET_CODE (PATTERN (p)) == SEQUENCE)
|
if (GET_CODE (PATTERN (p)) == SEQUENCE)
|
{
|
{
|
int i;
|
int i;
|
rtx q, sequence = PATTERN (p);
|
rtx q, sequence = PATTERN (p);
|
|
|
for (i = 0; i < XVECLEN (sequence, 0); i++)
|
for (i = 0; i < XVECLEN (sequence, 0); i++)
|
{
|
{
|
q = XVECEXP (sequence, 0, i);
|
q = XVECEXP (sequence, 0, i);
|
gcc_assert (INSN_P (q));
|
gcc_assert (INSN_P (q));
|
reset_used_flags (PATTERN (q));
|
reset_used_flags (PATTERN (q));
|
reset_used_flags (REG_NOTES (q));
|
reset_used_flags (REG_NOTES (q));
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
for (p = get_insns (); p; p = NEXT_INSN (p))
|
for (p = get_insns (); p; p = NEXT_INSN (p))
|
if (INSN_P (p))
|
if (INSN_P (p))
|
{
|
{
|
verify_rtx_sharing (PATTERN (p), p);
|
verify_rtx_sharing (PATTERN (p), p);
|
verify_rtx_sharing (REG_NOTES (p), p);
|
verify_rtx_sharing (REG_NOTES (p), p);
|
}
|
}
|
}
|
}
|
|
|
/* Go through all the RTL insn bodies and copy any invalid shared structure.
|
/* Go through all the RTL insn bodies and copy any invalid shared structure.
|
Assumes the mark bits are cleared at entry. */
|
Assumes the mark bits are cleared at entry. */
|
|
|
void
|
void
|
unshare_all_rtl_in_chain (rtx insn)
|
unshare_all_rtl_in_chain (rtx insn)
|
{
|
{
|
for (; insn; insn = NEXT_INSN (insn))
|
for (; insn; insn = NEXT_INSN (insn))
|
if (INSN_P (insn))
|
if (INSN_P (insn))
|
{
|
{
|
PATTERN (insn) = copy_rtx_if_shared (PATTERN (insn));
|
PATTERN (insn) = copy_rtx_if_shared (PATTERN (insn));
|
REG_NOTES (insn) = copy_rtx_if_shared (REG_NOTES (insn));
|
REG_NOTES (insn) = copy_rtx_if_shared (REG_NOTES (insn));
|
}
|
}
|
}
|
}
|
|
|
/* Go through all virtual stack slots of a function and mark them as
|
/* Go through all virtual stack slots of a function and mark them as
|
shared. We never replace the DECL_RTLs themselves with a copy,
|
shared. We never replace the DECL_RTLs themselves with a copy,
|
but expressions mentioned into a DECL_RTL cannot be shared with
|
but expressions mentioned into a DECL_RTL cannot be shared with
|
expressions in the instruction stream.
|
expressions in the instruction stream.
|
|
|
Note that reload may convert pseudo registers into memories in-place.
|
Note that reload may convert pseudo registers into memories in-place.
|
Pseudo registers are always shared, but MEMs never are. Thus if we
|
Pseudo registers are always shared, but MEMs never are. Thus if we
|
reset the used flags on MEMs in the instruction stream, we must set
|
reset the used flags on MEMs in the instruction stream, we must set
|
them again on MEMs that appear in DECL_RTLs. */
|
them again on MEMs that appear in DECL_RTLs. */
|
|
|
static void
|
static void
|
set_used_decls (tree blk)
|
set_used_decls (tree blk)
|
{
|
{
|
tree t;
|
tree t;
|
|
|
/* Mark decls. */
|
/* Mark decls. */
|
for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
|
for (t = BLOCK_VARS (blk); t; t = TREE_CHAIN (t))
|
if (DECL_RTL_SET_P (t))
|
if (DECL_RTL_SET_P (t))
|
set_used_flags (DECL_RTL (t));
|
set_used_flags (DECL_RTL (t));
|
|
|
/* Now process sub-blocks. */
|
/* Now process sub-blocks. */
|
for (t = BLOCK_SUBBLOCKS (blk); t; t = BLOCK_CHAIN (t))
|
for (t = BLOCK_SUBBLOCKS (blk); t; t = BLOCK_CHAIN (t))
|
set_used_decls (t);
|
set_used_decls (t);
|
}
|
}
|
|
|
/* Mark ORIG as in use, and return a copy of it if it was already in use.
|
/* Mark ORIG as in use, and return a copy of it if it was already in use.
|
Recursively does the same for subexpressions. Uses
|
Recursively does the same for subexpressions. Uses
|
copy_rtx_if_shared_1 to reduce stack space. */
|
copy_rtx_if_shared_1 to reduce stack space. */
|
|
|
rtx
|
rtx
|
copy_rtx_if_shared (rtx orig)
|
copy_rtx_if_shared (rtx orig)
|
{
|
{
|
copy_rtx_if_shared_1 (&orig);
|
copy_rtx_if_shared_1 (&orig);
|
return orig;
|
return orig;
|
}
|
}
|
|
|
/* Mark *ORIG1 as in use, and set it to a copy of it if it was already in
|
/* Mark *ORIG1 as in use, and set it to a copy of it if it was already in
|
use. Recursively does the same for subexpressions. */
|
use. Recursively does the same for subexpressions. */
|
|
|
static void
|
static void
|
copy_rtx_if_shared_1 (rtx *orig1)
|
copy_rtx_if_shared_1 (rtx *orig1)
|
{
|
{
|
rtx x;
|
rtx x;
|
int i;
|
int i;
|
enum rtx_code code;
|
enum rtx_code code;
|
rtx *last_ptr;
|
rtx *last_ptr;
|
const char *format_ptr;
|
const char *format_ptr;
|
int copied = 0;
|
int copied = 0;
|
int length;
|
int length;
|
|
|
/* Repeat is used to turn tail-recursion into iteration. */
|
/* Repeat is used to turn tail-recursion into iteration. */
|
repeat:
|
repeat:
|
x = *orig1;
|
x = *orig1;
|
|
|
if (x == 0)
|
if (x == 0)
|
return;
|
return;
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
|
|
/* These types may be freely shared. */
|
/* These types may be freely shared. */
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case REG:
|
case REG:
|
case DEBUG_EXPR:
|
case DEBUG_EXPR:
|
case VALUE:
|
case VALUE:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_FIXED:
|
case CONST_FIXED:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case LABEL_REF:
|
case LABEL_REF:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case PC:
|
case PC:
|
case CC0:
|
case CC0:
|
case SCRATCH:
|
case SCRATCH:
|
/* SCRATCH must be shared because they represent distinct values. */
|
/* SCRATCH must be shared because they represent distinct values. */
|
return;
|
return;
|
case CLOBBER:
|
case CLOBBER:
|
if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
|
if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
|
return;
|
return;
|
break;
|
break;
|
|
|
case CONST:
|
case CONST:
|
if (shared_const_p (x))
|
if (shared_const_p (x))
|
return;
|
return;
|
break;
|
break;
|
|
|
case DEBUG_INSN:
|
case DEBUG_INSN:
|
case INSN:
|
case INSN:
|
case JUMP_INSN:
|
case JUMP_INSN:
|
case CALL_INSN:
|
case CALL_INSN:
|
case NOTE:
|
case NOTE:
|
case BARRIER:
|
case BARRIER:
|
/* The chain of insns is not being copied. */
|
/* The chain of insns is not being copied. */
|
return;
|
return;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* This rtx may not be shared. If it has already been seen,
|
/* This rtx may not be shared. If it has already been seen,
|
replace it with a copy of itself. */
|
replace it with a copy of itself. */
|
|
|
if (RTX_FLAG (x, used))
|
if (RTX_FLAG (x, used))
|
{
|
{
|
x = shallow_copy_rtx (x);
|
x = shallow_copy_rtx (x);
|
copied = 1;
|
copied = 1;
|
}
|
}
|
RTX_FLAG (x, used) = 1;
|
RTX_FLAG (x, used) = 1;
|
|
|
/* Now scan the subexpressions recursively.
|
/* Now scan the subexpressions recursively.
|
We can store any replaced subexpressions directly into X
|
We can store any replaced subexpressions directly into X
|
since we know X is not shared! Any vectors in X
|
since we know X is not shared! Any vectors in X
|
must be copied if X was copied. */
|
must be copied if X was copied. */
|
|
|
format_ptr = GET_RTX_FORMAT (code);
|
format_ptr = GET_RTX_FORMAT (code);
|
length = GET_RTX_LENGTH (code);
|
length = GET_RTX_LENGTH (code);
|
last_ptr = NULL;
|
last_ptr = NULL;
|
|
|
for (i = 0; i < length; i++)
|
for (i = 0; i < length; i++)
|
{
|
{
|
switch (*format_ptr++)
|
switch (*format_ptr++)
|
{
|
{
|
case 'e':
|
case 'e':
|
if (last_ptr)
|
if (last_ptr)
|
copy_rtx_if_shared_1 (last_ptr);
|
copy_rtx_if_shared_1 (last_ptr);
|
last_ptr = &XEXP (x, i);
|
last_ptr = &XEXP (x, i);
|
break;
|
break;
|
|
|
case 'E':
|
case 'E':
|
if (XVEC (x, i) != NULL)
|
if (XVEC (x, i) != NULL)
|
{
|
{
|
int j;
|
int j;
|
int len = XVECLEN (x, i);
|
int len = XVECLEN (x, i);
|
|
|
/* Copy the vector iff I copied the rtx and the length
|
/* Copy the vector iff I copied the rtx and the length
|
is nonzero. */
|
is nonzero. */
|
if (copied && len > 0)
|
if (copied && len > 0)
|
XVEC (x, i) = gen_rtvec_v (len, XVEC (x, i)->elem);
|
XVEC (x, i) = gen_rtvec_v (len, XVEC (x, i)->elem);
|
|
|
/* Call recursively on all inside the vector. */
|
/* Call recursively on all inside the vector. */
|
for (j = 0; j < len; j++)
|
for (j = 0; j < len; j++)
|
{
|
{
|
if (last_ptr)
|
if (last_ptr)
|
copy_rtx_if_shared_1 (last_ptr);
|
copy_rtx_if_shared_1 (last_ptr);
|
last_ptr = &XVECEXP (x, i, j);
|
last_ptr = &XVECEXP (x, i, j);
|
}
|
}
|
}
|
}
|
break;
|
break;
|
}
|
}
|
}
|
}
|
*orig1 = x;
|
*orig1 = x;
|
if (last_ptr)
|
if (last_ptr)
|
{
|
{
|
orig1 = last_ptr;
|
orig1 = last_ptr;
|
goto repeat;
|
goto repeat;
|
}
|
}
|
return;
|
return;
|
}
|
}
|
|
|
/* Clear all the USED bits in X to allow copy_rtx_if_shared to be used
|
/* Clear all the USED bits in X to allow copy_rtx_if_shared to be used
|
to look for shared sub-parts. */
|
to look for shared sub-parts. */
|
|
|
void
|
void
|
reset_used_flags (rtx x)
|
reset_used_flags (rtx x)
|
{
|
{
|
int i, j;
|
int i, j;
|
enum rtx_code code;
|
enum rtx_code code;
|
const char *format_ptr;
|
const char *format_ptr;
|
int length;
|
int length;
|
|
|
/* Repeat is used to turn tail-recursion into iteration. */
|
/* Repeat is used to turn tail-recursion into iteration. */
|
repeat:
|
repeat:
|
if (x == 0)
|
if (x == 0)
|
return;
|
return;
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
|
|
/* These types may be freely shared so we needn't do any resetting
|
/* These types may be freely shared so we needn't do any resetting
|
for them. */
|
for them. */
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case REG:
|
case REG:
|
case DEBUG_EXPR:
|
case DEBUG_EXPR:
|
case VALUE:
|
case VALUE:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_FIXED:
|
case CONST_FIXED:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case PC:
|
case PC:
|
case CC0:
|
case CC0:
|
return;
|
return;
|
|
|
case DEBUG_INSN:
|
case DEBUG_INSN:
|
case INSN:
|
case INSN:
|
case JUMP_INSN:
|
case JUMP_INSN:
|
case CALL_INSN:
|
case CALL_INSN:
|
case NOTE:
|
case NOTE:
|
case LABEL_REF:
|
case LABEL_REF:
|
case BARRIER:
|
case BARRIER:
|
/* The chain of insns is not being copied. */
|
/* The chain of insns is not being copied. */
|
return;
|
return;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
RTX_FLAG (x, used) = 0;
|
RTX_FLAG (x, used) = 0;
|
|
|
format_ptr = GET_RTX_FORMAT (code);
|
format_ptr = GET_RTX_FORMAT (code);
|
length = GET_RTX_LENGTH (code);
|
length = GET_RTX_LENGTH (code);
|
|
|
for (i = 0; i < length; i++)
|
for (i = 0; i < length; i++)
|
{
|
{
|
switch (*format_ptr++)
|
switch (*format_ptr++)
|
{
|
{
|
case 'e':
|
case 'e':
|
if (i == length-1)
|
if (i == length-1)
|
{
|
{
|
x = XEXP (x, i);
|
x = XEXP (x, i);
|
goto repeat;
|
goto repeat;
|
}
|
}
|
reset_used_flags (XEXP (x, i));
|
reset_used_flags (XEXP (x, i));
|
break;
|
break;
|
|
|
case 'E':
|
case 'E':
|
for (j = 0; j < XVECLEN (x, i); j++)
|
for (j = 0; j < XVECLEN (x, i); j++)
|
reset_used_flags (XVECEXP (x, i, j));
|
reset_used_flags (XVECEXP (x, i, j));
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Set all the USED bits in X to allow copy_rtx_if_shared to be used
|
/* Set all the USED bits in X to allow copy_rtx_if_shared to be used
|
to look for shared sub-parts. */
|
to look for shared sub-parts. */
|
|
|
void
|
void
|
set_used_flags (rtx x)
|
set_used_flags (rtx x)
|
{
|
{
|
int i, j;
|
int i, j;
|
enum rtx_code code;
|
enum rtx_code code;
|
const char *format_ptr;
|
const char *format_ptr;
|
|
|
if (x == 0)
|
if (x == 0)
|
return;
|
return;
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
|
|
/* These types may be freely shared so we needn't do any resetting
|
/* These types may be freely shared so we needn't do any resetting
|
for them. */
|
for them. */
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case REG:
|
case REG:
|
case DEBUG_EXPR:
|
case DEBUG_EXPR:
|
case VALUE:
|
case VALUE:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_FIXED:
|
case CONST_FIXED:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case PC:
|
case PC:
|
case CC0:
|
case CC0:
|
return;
|
return;
|
|
|
case DEBUG_INSN:
|
case DEBUG_INSN:
|
case INSN:
|
case INSN:
|
case JUMP_INSN:
|
case JUMP_INSN:
|
case CALL_INSN:
|
case CALL_INSN:
|
case NOTE:
|
case NOTE:
|
case LABEL_REF:
|
case LABEL_REF:
|
case BARRIER:
|
case BARRIER:
|
/* The chain of insns is not being copied. */
|
/* The chain of insns is not being copied. */
|
return;
|
return;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
RTX_FLAG (x, used) = 1;
|
RTX_FLAG (x, used) = 1;
|
|
|
format_ptr = GET_RTX_FORMAT (code);
|
format_ptr = GET_RTX_FORMAT (code);
|
for (i = 0; i < GET_RTX_LENGTH (code); i++)
|
for (i = 0; i < GET_RTX_LENGTH (code); i++)
|
{
|
{
|
switch (*format_ptr++)
|
switch (*format_ptr++)
|
{
|
{
|
case 'e':
|
case 'e':
|
set_used_flags (XEXP (x, i));
|
set_used_flags (XEXP (x, i));
|
break;
|
break;
|
|
|
case 'E':
|
case 'E':
|
for (j = 0; j < XVECLEN (x, i); j++)
|
for (j = 0; j < XVECLEN (x, i); j++)
|
set_used_flags (XVECEXP (x, i, j));
|
set_used_flags (XVECEXP (x, i, j));
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Copy X if necessary so that it won't be altered by changes in OTHER.
|
/* Copy X if necessary so that it won't be altered by changes in OTHER.
|
Return X or the rtx for the pseudo reg the value of X was copied into.
|
Return X or the rtx for the pseudo reg the value of X was copied into.
|
OTHER must be valid as a SET_DEST. */
|
OTHER must be valid as a SET_DEST. */
|
|
|
rtx
|
rtx
|
make_safe_from (rtx x, rtx other)
|
make_safe_from (rtx x, rtx other)
|
{
|
{
|
while (1)
|
while (1)
|
switch (GET_CODE (other))
|
switch (GET_CODE (other))
|
{
|
{
|
case SUBREG:
|
case SUBREG:
|
other = SUBREG_REG (other);
|
other = SUBREG_REG (other);
|
break;
|
break;
|
case STRICT_LOW_PART:
|
case STRICT_LOW_PART:
|
case SIGN_EXTEND:
|
case SIGN_EXTEND:
|
case ZERO_EXTEND:
|
case ZERO_EXTEND:
|
other = XEXP (other, 0);
|
other = XEXP (other, 0);
|
break;
|
break;
|
default:
|
default:
|
goto done;
|
goto done;
|
}
|
}
|
done:
|
done:
|
if ((MEM_P (other)
|
if ((MEM_P (other)
|
&& ! CONSTANT_P (x)
|
&& ! CONSTANT_P (x)
|
&& !REG_P (x)
|
&& !REG_P (x)
|
&& GET_CODE (x) != SUBREG)
|
&& GET_CODE (x) != SUBREG)
|
|| (REG_P (other)
|
|| (REG_P (other)
|
&& (REGNO (other) < FIRST_PSEUDO_REGISTER
|
&& (REGNO (other) < FIRST_PSEUDO_REGISTER
|
|| reg_mentioned_p (other, x))))
|
|| reg_mentioned_p (other, x))))
|
{
|
{
|
rtx temp = gen_reg_rtx (GET_MODE (x));
|
rtx temp = gen_reg_rtx (GET_MODE (x));
|
emit_move_insn (temp, x);
|
emit_move_insn (temp, x);
|
return temp;
|
return temp;
|
}
|
}
|
return x;
|
return x;
|
}
|
}
|
|
|
/* Emission of insns (adding them to the doubly-linked list). */
|
/* Emission of insns (adding them to the doubly-linked list). */
|
|
|
/* Return the first insn of the current sequence or current function. */
|
/* Return the first insn of the current sequence or current function. */
|
|
|
rtx
|
rtx
|
get_insns (void)
|
get_insns (void)
|
{
|
{
|
return first_insn;
|
return first_insn;
|
}
|
}
|
|
|
/* Specify a new insn as the first in the chain. */
|
/* Specify a new insn as the first in the chain. */
|
|
|
void
|
void
|
set_first_insn (rtx insn)
|
set_first_insn (rtx insn)
|
{
|
{
|
gcc_assert (!PREV_INSN (insn));
|
gcc_assert (!PREV_INSN (insn));
|
first_insn = insn;
|
first_insn = insn;
|
}
|
}
|
|
|
/* Return the last insn emitted in current sequence or current function. */
|
/* Return the last insn emitted in current sequence or current function. */
|
|
|
rtx
|
rtx
|
get_last_insn (void)
|
get_last_insn (void)
|
{
|
{
|
return last_insn;
|
return last_insn;
|
}
|
}
|
|
|
/* Specify a new insn as the last in the chain. */
|
/* Specify a new insn as the last in the chain. */
|
|
|
void
|
void
|
set_last_insn (rtx insn)
|
set_last_insn (rtx insn)
|
{
|
{
|
gcc_assert (!NEXT_INSN (insn));
|
gcc_assert (!NEXT_INSN (insn));
|
last_insn = insn;
|
last_insn = insn;
|
}
|
}
|
|
|
/* Return the last insn emitted, even if it is in a sequence now pushed. */
|
/* Return the last insn emitted, even if it is in a sequence now pushed. */
|
|
|
rtx
|
rtx
|
get_last_insn_anywhere (void)
|
get_last_insn_anywhere (void)
|
{
|
{
|
struct sequence_stack *stack;
|
struct sequence_stack *stack;
|
if (last_insn)
|
if (last_insn)
|
return last_insn;
|
return last_insn;
|
for (stack = seq_stack; stack; stack = stack->next)
|
for (stack = seq_stack; stack; stack = stack->next)
|
if (stack->last != 0)
|
if (stack->last != 0)
|
return stack->last;
|
return stack->last;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return the first nonnote insn emitted in current sequence or current
|
/* Return the first nonnote insn emitted in current sequence or current
|
function. This routine looks inside SEQUENCEs. */
|
function. This routine looks inside SEQUENCEs. */
|
|
|
rtx
|
rtx
|
get_first_nonnote_insn (void)
|
get_first_nonnote_insn (void)
|
{
|
{
|
rtx insn = first_insn;
|
rtx insn = first_insn;
|
|
|
if (insn)
|
if (insn)
|
{
|
{
|
if (NOTE_P (insn))
|
if (NOTE_P (insn))
|
for (insn = next_insn (insn);
|
for (insn = next_insn (insn);
|
insn && NOTE_P (insn);
|
insn && NOTE_P (insn);
|
insn = next_insn (insn))
|
insn = next_insn (insn))
|
continue;
|
continue;
|
else
|
else
|
{
|
{
|
if (NONJUMP_INSN_P (insn)
|
if (NONJUMP_INSN_P (insn)
|
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
|
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
|
insn = XVECEXP (PATTERN (insn), 0, 0);
|
insn = XVECEXP (PATTERN (insn), 0, 0);
|
}
|
}
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Return the last nonnote insn emitted in current sequence or current
|
/* Return the last nonnote insn emitted in current sequence or current
|
function. This routine looks inside SEQUENCEs. */
|
function. This routine looks inside SEQUENCEs. */
|
|
|
rtx
|
rtx
|
get_last_nonnote_insn (void)
|
get_last_nonnote_insn (void)
|
{
|
{
|
rtx insn = last_insn;
|
rtx insn = last_insn;
|
|
|
if (insn)
|
if (insn)
|
{
|
{
|
if (NOTE_P (insn))
|
if (NOTE_P (insn))
|
for (insn = previous_insn (insn);
|
for (insn = previous_insn (insn);
|
insn && NOTE_P (insn);
|
insn && NOTE_P (insn);
|
insn = previous_insn (insn))
|
insn = previous_insn (insn))
|
continue;
|
continue;
|
else
|
else
|
{
|
{
|
if (NONJUMP_INSN_P (insn)
|
if (NONJUMP_INSN_P (insn)
|
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
|
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
|
insn = XVECEXP (PATTERN (insn), 0,
|
insn = XVECEXP (PATTERN (insn), 0,
|
XVECLEN (PATTERN (insn), 0) - 1);
|
XVECLEN (PATTERN (insn), 0) - 1);
|
}
|
}
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Return a number larger than any instruction's uid in this function. */
|
/* Return a number larger than any instruction's uid in this function. */
|
|
|
int
|
int
|
get_max_uid (void)
|
get_max_uid (void)
|
{
|
{
|
return cur_insn_uid;
|
return cur_insn_uid;
|
}
|
}
|
|
|
/* Return the number of actual (non-debug) insns emitted in this
|
/* Return the number of actual (non-debug) insns emitted in this
|
function. */
|
function. */
|
|
|
int
|
int
|
get_max_insn_count (void)
|
get_max_insn_count (void)
|
{
|
{
|
int n = cur_insn_uid;
|
int n = cur_insn_uid;
|
|
|
/* The table size must be stable across -g, to avoid codegen
|
/* The table size must be stable across -g, to avoid codegen
|
differences due to debug insns, and not be affected by
|
differences due to debug insns, and not be affected by
|
-fmin-insn-uid, to avoid excessive table size and to simplify
|
-fmin-insn-uid, to avoid excessive table size and to simplify
|
debugging of -fcompare-debug failures. */
|
debugging of -fcompare-debug failures. */
|
if (cur_debug_insn_uid > MIN_NONDEBUG_INSN_UID)
|
if (cur_debug_insn_uid > MIN_NONDEBUG_INSN_UID)
|
n -= cur_debug_insn_uid;
|
n -= cur_debug_insn_uid;
|
else
|
else
|
n -= MIN_NONDEBUG_INSN_UID;
|
n -= MIN_NONDEBUG_INSN_UID;
|
|
|
return n;
|
return n;
|
}
|
}
|
|
|
|
|
/* Return the next insn. If it is a SEQUENCE, return the first insn
|
/* Return the next insn. If it is a SEQUENCE, return the first insn
|
of the sequence. */
|
of the sequence. */
|
|
|
rtx
|
rtx
|
next_insn (rtx insn)
|
next_insn (rtx insn)
|
{
|
{
|
if (insn)
|
if (insn)
|
{
|
{
|
insn = NEXT_INSN (insn);
|
insn = NEXT_INSN (insn);
|
if (insn && NONJUMP_INSN_P (insn)
|
if (insn && NONJUMP_INSN_P (insn)
|
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
|
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
|
insn = XVECEXP (PATTERN (insn), 0, 0);
|
insn = XVECEXP (PATTERN (insn), 0, 0);
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Return the previous insn. If it is a SEQUENCE, return the last insn
|
/* Return the previous insn. If it is a SEQUENCE, return the last insn
|
of the sequence. */
|
of the sequence. */
|
|
|
rtx
|
rtx
|
previous_insn (rtx insn)
|
previous_insn (rtx insn)
|
{
|
{
|
if (insn)
|
if (insn)
|
{
|
{
|
insn = PREV_INSN (insn);
|
insn = PREV_INSN (insn);
|
if (insn && NONJUMP_INSN_P (insn)
|
if (insn && NONJUMP_INSN_P (insn)
|
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
|
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
|
insn = XVECEXP (PATTERN (insn), 0, XVECLEN (PATTERN (insn), 0) - 1);
|
insn = XVECEXP (PATTERN (insn), 0, XVECLEN (PATTERN (insn), 0) - 1);
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Return the next insn after INSN that is not a NOTE. This routine does not
|
/* Return the next insn after INSN that is not a NOTE. This routine does not
|
look inside SEQUENCEs. */
|
look inside SEQUENCEs. */
|
|
|
rtx
|
rtx
|
next_nonnote_insn (rtx insn)
|
next_nonnote_insn (rtx insn)
|
{
|
{
|
while (insn)
|
while (insn)
|
{
|
{
|
insn = NEXT_INSN (insn);
|
insn = NEXT_INSN (insn);
|
if (insn == 0 || !NOTE_P (insn))
|
if (insn == 0 || !NOTE_P (insn))
|
break;
|
break;
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Return the next insn after INSN that is not a NOTE, but stop the
|
/* Return the next insn after INSN that is not a NOTE, but stop the
|
search before we enter another basic block. This routine does not
|
search before we enter another basic block. This routine does not
|
look inside SEQUENCEs. */
|
look inside SEQUENCEs. */
|
|
|
rtx
|
rtx
|
next_nonnote_insn_bb (rtx insn)
|
next_nonnote_insn_bb (rtx insn)
|
{
|
{
|
while (insn)
|
while (insn)
|
{
|
{
|
insn = NEXT_INSN (insn);
|
insn = NEXT_INSN (insn);
|
if (insn == 0 || !NOTE_P (insn))
|
if (insn == 0 || !NOTE_P (insn))
|
break;
|
break;
|
if (NOTE_INSN_BASIC_BLOCK_P (insn))
|
if (NOTE_INSN_BASIC_BLOCK_P (insn))
|
return NULL_RTX;
|
return NULL_RTX;
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Return the previous insn before INSN that is not a NOTE. This routine does
|
/* Return the previous insn before INSN that is not a NOTE. This routine does
|
not look inside SEQUENCEs. */
|
not look inside SEQUENCEs. */
|
|
|
rtx
|
rtx
|
prev_nonnote_insn (rtx insn)
|
prev_nonnote_insn (rtx insn)
|
{
|
{
|
while (insn)
|
while (insn)
|
{
|
{
|
insn = PREV_INSN (insn);
|
insn = PREV_INSN (insn);
|
if (insn == 0 || !NOTE_P (insn))
|
if (insn == 0 || !NOTE_P (insn))
|
break;
|
break;
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Return the previous insn before INSN that is not a NOTE, but stop
|
/* Return the previous insn before INSN that is not a NOTE, but stop
|
the search before we enter another basic block. This routine does
|
the search before we enter another basic block. This routine does
|
not look inside SEQUENCEs. */
|
not look inside SEQUENCEs. */
|
|
|
rtx
|
rtx
|
prev_nonnote_insn_bb (rtx insn)
|
prev_nonnote_insn_bb (rtx insn)
|
{
|
{
|
while (insn)
|
while (insn)
|
{
|
{
|
insn = PREV_INSN (insn);
|
insn = PREV_INSN (insn);
|
if (insn == 0 || !NOTE_P (insn))
|
if (insn == 0 || !NOTE_P (insn))
|
break;
|
break;
|
if (NOTE_INSN_BASIC_BLOCK_P (insn))
|
if (NOTE_INSN_BASIC_BLOCK_P (insn))
|
return NULL_RTX;
|
return NULL_RTX;
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Return the next insn after INSN that is not a DEBUG_INSN. This
|
/* Return the next insn after INSN that is not a DEBUG_INSN. This
|
routine does not look inside SEQUENCEs. */
|
routine does not look inside SEQUENCEs. */
|
|
|
rtx
|
rtx
|
next_nondebug_insn (rtx insn)
|
next_nondebug_insn (rtx insn)
|
{
|
{
|
while (insn)
|
while (insn)
|
{
|
{
|
insn = NEXT_INSN (insn);
|
insn = NEXT_INSN (insn);
|
if (insn == 0 || !DEBUG_INSN_P (insn))
|
if (insn == 0 || !DEBUG_INSN_P (insn))
|
break;
|
break;
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Return the previous insn before INSN that is not a DEBUG_INSN.
|
/* Return the previous insn before INSN that is not a DEBUG_INSN.
|
This routine does not look inside SEQUENCEs. */
|
This routine does not look inside SEQUENCEs. */
|
|
|
rtx
|
rtx
|
prev_nondebug_insn (rtx insn)
|
prev_nondebug_insn (rtx insn)
|
{
|
{
|
while (insn)
|
while (insn)
|
{
|
{
|
insn = PREV_INSN (insn);
|
insn = PREV_INSN (insn);
|
if (insn == 0 || !DEBUG_INSN_P (insn))
|
if (insn == 0 || !DEBUG_INSN_P (insn))
|
break;
|
break;
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Return the next insn after INSN that is not a NOTE nor DEBUG_INSN.
|
/* Return the next insn after INSN that is not a NOTE nor DEBUG_INSN.
|
This routine does not look inside SEQUENCEs. */
|
This routine does not look inside SEQUENCEs. */
|
|
|
rtx
|
rtx
|
next_nonnote_nondebug_insn (rtx insn)
|
next_nonnote_nondebug_insn (rtx insn)
|
{
|
{
|
while (insn)
|
while (insn)
|
{
|
{
|
insn = NEXT_INSN (insn);
|
insn = NEXT_INSN (insn);
|
if (insn == 0 || (!NOTE_P (insn) && !DEBUG_INSN_P (insn)))
|
if (insn == 0 || (!NOTE_P (insn) && !DEBUG_INSN_P (insn)))
|
break;
|
break;
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Return the previous insn before INSN that is not a NOTE nor DEBUG_INSN.
|
/* Return the previous insn before INSN that is not a NOTE nor DEBUG_INSN.
|
This routine does not look inside SEQUENCEs. */
|
This routine does not look inside SEQUENCEs. */
|
|
|
rtx
|
rtx
|
prev_nonnote_nondebug_insn (rtx insn)
|
prev_nonnote_nondebug_insn (rtx insn)
|
{
|
{
|
while (insn)
|
while (insn)
|
{
|
{
|
insn = PREV_INSN (insn);
|
insn = PREV_INSN (insn);
|
if (insn == 0 || (!NOTE_P (insn) && !DEBUG_INSN_P (insn)))
|
if (insn == 0 || (!NOTE_P (insn) && !DEBUG_INSN_P (insn)))
|
break;
|
break;
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Return the next INSN, CALL_INSN or JUMP_INSN after INSN;
|
/* Return the next INSN, CALL_INSN or JUMP_INSN after INSN;
|
or 0, if there is none. This routine does not look inside
|
or 0, if there is none. This routine does not look inside
|
SEQUENCEs. */
|
SEQUENCEs. */
|
|
|
rtx
|
rtx
|
next_real_insn (rtx insn)
|
next_real_insn (rtx insn)
|
{
|
{
|
while (insn)
|
while (insn)
|
{
|
{
|
insn = NEXT_INSN (insn);
|
insn = NEXT_INSN (insn);
|
if (insn == 0 || INSN_P (insn))
|
if (insn == 0 || INSN_P (insn))
|
break;
|
break;
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Return the last INSN, CALL_INSN or JUMP_INSN before INSN;
|
/* Return the last INSN, CALL_INSN or JUMP_INSN before INSN;
|
or 0, if there is none. This routine does not look inside
|
or 0, if there is none. This routine does not look inside
|
SEQUENCEs. */
|
SEQUENCEs. */
|
|
|
rtx
|
rtx
|
prev_real_insn (rtx insn)
|
prev_real_insn (rtx insn)
|
{
|
{
|
while (insn)
|
while (insn)
|
{
|
{
|
insn = PREV_INSN (insn);
|
insn = PREV_INSN (insn);
|
if (insn == 0 || INSN_P (insn))
|
if (insn == 0 || INSN_P (insn))
|
break;
|
break;
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Return the last CALL_INSN in the current list, or 0 if there is none.
|
/* Return the last CALL_INSN in the current list, or 0 if there is none.
|
This routine does not look inside SEQUENCEs. */
|
This routine does not look inside SEQUENCEs. */
|
|
|
rtx
|
rtx
|
last_call_insn (void)
|
last_call_insn (void)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
for (insn = get_last_insn ();
|
for (insn = get_last_insn ();
|
insn && !CALL_P (insn);
|
insn && !CALL_P (insn);
|
insn = PREV_INSN (insn))
|
insn = PREV_INSN (insn))
|
;
|
;
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Find the next insn after INSN that really does something. This routine
|
/* Find the next insn after INSN that really does something. This routine
|
does not look inside SEQUENCEs. After reload this also skips over
|
does not look inside SEQUENCEs. After reload this also skips over
|
standalone USE and CLOBBER insn. */
|
standalone USE and CLOBBER insn. */
|
|
|
int
|
int
|
active_insn_p (const_rtx insn)
|
active_insn_p (const_rtx insn)
|
{
|
{
|
return (CALL_P (insn) || JUMP_P (insn)
|
return (CALL_P (insn) || JUMP_P (insn)
|
|| (NONJUMP_INSN_P (insn)
|
|| (NONJUMP_INSN_P (insn)
|
&& (! reload_completed
|
&& (! reload_completed
|
|| (GET_CODE (PATTERN (insn)) != USE
|
|| (GET_CODE (PATTERN (insn)) != USE
|
&& GET_CODE (PATTERN (insn)) != CLOBBER))));
|
&& GET_CODE (PATTERN (insn)) != CLOBBER))));
|
}
|
}
|
|
|
rtx
|
rtx
|
next_active_insn (rtx insn)
|
next_active_insn (rtx insn)
|
{
|
{
|
while (insn)
|
while (insn)
|
{
|
{
|
insn = NEXT_INSN (insn);
|
insn = NEXT_INSN (insn);
|
if (insn == 0 || active_insn_p (insn))
|
if (insn == 0 || active_insn_p (insn))
|
break;
|
break;
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Find the last insn before INSN that really does something. This routine
|
/* Find the last insn before INSN that really does something. This routine
|
does not look inside SEQUENCEs. After reload this also skips over
|
does not look inside SEQUENCEs. After reload this also skips over
|
standalone USE and CLOBBER insn. */
|
standalone USE and CLOBBER insn. */
|
|
|
rtx
|
rtx
|
prev_active_insn (rtx insn)
|
prev_active_insn (rtx insn)
|
{
|
{
|
while (insn)
|
while (insn)
|
{
|
{
|
insn = PREV_INSN (insn);
|
insn = PREV_INSN (insn);
|
if (insn == 0 || active_insn_p (insn))
|
if (insn == 0 || active_insn_p (insn))
|
break;
|
break;
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Return the next CODE_LABEL after the insn INSN, or 0 if there is none. */
|
/* Return the next CODE_LABEL after the insn INSN, or 0 if there is none. */
|
|
|
rtx
|
rtx
|
next_label (rtx insn)
|
next_label (rtx insn)
|
{
|
{
|
while (insn)
|
while (insn)
|
{
|
{
|
insn = NEXT_INSN (insn);
|
insn = NEXT_INSN (insn);
|
if (insn == 0 || LABEL_P (insn))
|
if (insn == 0 || LABEL_P (insn))
|
break;
|
break;
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Return the last CODE_LABEL before the insn INSN, or 0 if there is none. */
|
/* Return the last CODE_LABEL before the insn INSN, or 0 if there is none. */
|
|
|
rtx
|
rtx
|
prev_label (rtx insn)
|
prev_label (rtx insn)
|
{
|
{
|
while (insn)
|
while (insn)
|
{
|
{
|
insn = PREV_INSN (insn);
|
insn = PREV_INSN (insn);
|
if (insn == 0 || LABEL_P (insn))
|
if (insn == 0 || LABEL_P (insn))
|
break;
|
break;
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Return the last label to mark the same position as LABEL. Return null
|
/* Return the last label to mark the same position as LABEL. Return null
|
if LABEL itself is null. */
|
if LABEL itself is null. */
|
|
|
rtx
|
rtx
|
skip_consecutive_labels (rtx label)
|
skip_consecutive_labels (rtx label)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
for (insn = label; insn != 0 && !INSN_P (insn); insn = NEXT_INSN (insn))
|
for (insn = label; insn != 0 && !INSN_P (insn); insn = NEXT_INSN (insn))
|
if (LABEL_P (insn))
|
if (LABEL_P (insn))
|
label = insn;
|
label = insn;
|
|
|
return label;
|
return label;
|
}
|
}
|
|
|
#ifdef HAVE_cc0
|
#ifdef HAVE_cc0
|
/* INSN uses CC0 and is being moved into a delay slot. Set up REG_CC_SETTER
|
/* INSN uses CC0 and is being moved into a delay slot. Set up REG_CC_SETTER
|
and REG_CC_USER notes so we can find it. */
|
and REG_CC_USER notes so we can find it. */
|
|
|
void
|
void
|
link_cc0_insns (rtx insn)
|
link_cc0_insns (rtx insn)
|
{
|
{
|
rtx user = next_nonnote_insn (insn);
|
rtx user = next_nonnote_insn (insn);
|
|
|
if (NONJUMP_INSN_P (user) && GET_CODE (PATTERN (user)) == SEQUENCE)
|
if (NONJUMP_INSN_P (user) && GET_CODE (PATTERN (user)) == SEQUENCE)
|
user = XVECEXP (PATTERN (user), 0, 0);
|
user = XVECEXP (PATTERN (user), 0, 0);
|
|
|
add_reg_note (user, REG_CC_SETTER, insn);
|
add_reg_note (user, REG_CC_SETTER, insn);
|
add_reg_note (insn, REG_CC_USER, user);
|
add_reg_note (insn, REG_CC_USER, user);
|
}
|
}
|
|
|
/* Return the next insn that uses CC0 after INSN, which is assumed to
|
/* Return the next insn that uses CC0 after INSN, which is assumed to
|
set it. This is the inverse of prev_cc0_setter (i.e., prev_cc0_setter
|
set it. This is the inverse of prev_cc0_setter (i.e., prev_cc0_setter
|
applied to the result of this function should yield INSN).
|
applied to the result of this function should yield INSN).
|
|
|
Normally, this is simply the next insn. However, if a REG_CC_USER note
|
Normally, this is simply the next insn. However, if a REG_CC_USER note
|
is present, it contains the insn that uses CC0.
|
is present, it contains the insn that uses CC0.
|
|
|
Return 0 if we can't find the insn. */
|
Return 0 if we can't find the insn. */
|
|
|
rtx
|
rtx
|
next_cc0_user (rtx insn)
|
next_cc0_user (rtx insn)
|
{
|
{
|
rtx note = find_reg_note (insn, REG_CC_USER, NULL_RTX);
|
rtx note = find_reg_note (insn, REG_CC_USER, NULL_RTX);
|
|
|
if (note)
|
if (note)
|
return XEXP (note, 0);
|
return XEXP (note, 0);
|
|
|
insn = next_nonnote_insn (insn);
|
insn = next_nonnote_insn (insn);
|
if (insn && NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE)
|
if (insn && NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE)
|
insn = XVECEXP (PATTERN (insn), 0, 0);
|
insn = XVECEXP (PATTERN (insn), 0, 0);
|
|
|
if (insn && INSN_P (insn) && reg_mentioned_p (cc0_rtx, PATTERN (insn)))
|
if (insn && INSN_P (insn) && reg_mentioned_p (cc0_rtx, PATTERN (insn)))
|
return insn;
|
return insn;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Find the insn that set CC0 for INSN. Unless INSN has a REG_CC_SETTER
|
/* Find the insn that set CC0 for INSN. Unless INSN has a REG_CC_SETTER
|
note, it is the previous insn. */
|
note, it is the previous insn. */
|
|
|
rtx
|
rtx
|
prev_cc0_setter (rtx insn)
|
prev_cc0_setter (rtx insn)
|
{
|
{
|
rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
|
rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
|
|
|
if (note)
|
if (note)
|
return XEXP (note, 0);
|
return XEXP (note, 0);
|
|
|
insn = prev_nonnote_insn (insn);
|
insn = prev_nonnote_insn (insn);
|
gcc_assert (sets_cc0_p (PATTERN (insn)));
|
gcc_assert (sets_cc0_p (PATTERN (insn)));
|
|
|
return insn;
|
return insn;
|
}
|
}
|
#endif
|
#endif
|
|
|
#ifdef AUTO_INC_DEC
|
#ifdef AUTO_INC_DEC
|
/* Find a RTX_AUTOINC class rtx which matches DATA. */
|
/* Find a RTX_AUTOINC class rtx which matches DATA. */
|
|
|
static int
|
static int
|
find_auto_inc (rtx *xp, void *data)
|
find_auto_inc (rtx *xp, void *data)
|
{
|
{
|
rtx x = *xp;
|
rtx x = *xp;
|
rtx reg = (rtx) data;
|
rtx reg = (rtx) data;
|
|
|
if (GET_RTX_CLASS (GET_CODE (x)) != RTX_AUTOINC)
|
if (GET_RTX_CLASS (GET_CODE (x)) != RTX_AUTOINC)
|
return 0;
|
return 0;
|
|
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case PRE_DEC:
|
case PRE_DEC:
|
case PRE_INC:
|
case PRE_INC:
|
case POST_DEC:
|
case POST_DEC:
|
case POST_INC:
|
case POST_INC:
|
case PRE_MODIFY:
|
case PRE_MODIFY:
|
case POST_MODIFY:
|
case POST_MODIFY:
|
if (rtx_equal_p (reg, XEXP (x, 0)))
|
if (rtx_equal_p (reg, XEXP (x, 0)))
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
return -1;
|
return -1;
|
}
|
}
|
#endif
|
#endif
|
|
|
/* Increment the label uses for all labels present in rtx. */
|
/* Increment the label uses for all labels present in rtx. */
|
|
|
static void
|
static void
|
mark_label_nuses (rtx x)
|
mark_label_nuses (rtx x)
|
{
|
{
|
enum rtx_code code;
|
enum rtx_code code;
|
int i, j;
|
int i, j;
|
const char *fmt;
|
const char *fmt;
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
if (code == LABEL_REF && LABEL_P (XEXP (x, 0)))
|
if (code == LABEL_REF && LABEL_P (XEXP (x, 0)))
|
LABEL_NUSES (XEXP (x, 0))++;
|
LABEL_NUSES (XEXP (x, 0))++;
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
if (fmt[i] == 'e')
|
if (fmt[i] == 'e')
|
mark_label_nuses (XEXP (x, i));
|
mark_label_nuses (XEXP (x, i));
|
else if (fmt[i] == 'E')
|
else if (fmt[i] == 'E')
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
|
mark_label_nuses (XVECEXP (x, i, j));
|
mark_label_nuses (XVECEXP (x, i, j));
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Try splitting insns that can be split for better scheduling.
|
/* Try splitting insns that can be split for better scheduling.
|
PAT is the pattern which might split.
|
PAT is the pattern which might split.
|
TRIAL is the insn providing PAT.
|
TRIAL is the insn providing PAT.
|
LAST is nonzero if we should return the last insn of the sequence produced.
|
LAST is nonzero if we should return the last insn of the sequence produced.
|
|
|
If this routine succeeds in splitting, it returns the first or last
|
If this routine succeeds in splitting, it returns the first or last
|
replacement insn depending on the value of LAST. Otherwise, it
|
replacement insn depending on the value of LAST. Otherwise, it
|
returns TRIAL. If the insn to be returned can be split, it will be. */
|
returns TRIAL. If the insn to be returned can be split, it will be. */
|
|
|
rtx
|
rtx
|
try_split (rtx pat, rtx trial, int last)
|
try_split (rtx pat, rtx trial, int last)
|
{
|
{
|
rtx before = PREV_INSN (trial);
|
rtx before = PREV_INSN (trial);
|
rtx after = NEXT_INSN (trial);
|
rtx after = NEXT_INSN (trial);
|
int has_barrier = 0;
|
int has_barrier = 0;
|
rtx note, seq, tem;
|
rtx note, seq, tem;
|
int probability;
|
int probability;
|
rtx insn_last, insn;
|
rtx insn_last, insn;
|
int njumps = 0;
|
int njumps = 0;
|
|
|
/* We're not good at redistributing frame information. */
|
/* We're not good at redistributing frame information. */
|
if (RTX_FRAME_RELATED_P (trial))
|
if (RTX_FRAME_RELATED_P (trial))
|
return trial;
|
return trial;
|
|
|
if (any_condjump_p (trial)
|
if (any_condjump_p (trial)
|
&& (note = find_reg_note (trial, REG_BR_PROB, 0)))
|
&& (note = find_reg_note (trial, REG_BR_PROB, 0)))
|
split_branch_probability = INTVAL (XEXP (note, 0));
|
split_branch_probability = INTVAL (XEXP (note, 0));
|
probability = split_branch_probability;
|
probability = split_branch_probability;
|
|
|
seq = split_insns (pat, trial);
|
seq = split_insns (pat, trial);
|
|
|
split_branch_probability = -1;
|
split_branch_probability = -1;
|
|
|
/* If we are splitting a JUMP_INSN, it might be followed by a BARRIER.
|
/* If we are splitting a JUMP_INSN, it might be followed by a BARRIER.
|
We may need to handle this specially. */
|
We may need to handle this specially. */
|
if (after && BARRIER_P (after))
|
if (after && BARRIER_P (after))
|
{
|
{
|
has_barrier = 1;
|
has_barrier = 1;
|
after = NEXT_INSN (after);
|
after = NEXT_INSN (after);
|
}
|
}
|
|
|
if (!seq)
|
if (!seq)
|
return trial;
|
return trial;
|
|
|
/* Avoid infinite loop if any insn of the result matches
|
/* Avoid infinite loop if any insn of the result matches
|
the original pattern. */
|
the original pattern. */
|
insn_last = seq;
|
insn_last = seq;
|
while (1)
|
while (1)
|
{
|
{
|
if (INSN_P (insn_last)
|
if (INSN_P (insn_last)
|
&& rtx_equal_p (PATTERN (insn_last), pat))
|
&& rtx_equal_p (PATTERN (insn_last), pat))
|
return trial;
|
return trial;
|
if (!NEXT_INSN (insn_last))
|
if (!NEXT_INSN (insn_last))
|
break;
|
break;
|
insn_last = NEXT_INSN (insn_last);
|
insn_last = NEXT_INSN (insn_last);
|
}
|
}
|
|
|
/* We will be adding the new sequence to the function. The splitters
|
/* We will be adding the new sequence to the function. The splitters
|
may have introduced invalid RTL sharing, so unshare the sequence now. */
|
may have introduced invalid RTL sharing, so unshare the sequence now. */
|
unshare_all_rtl_in_chain (seq);
|
unshare_all_rtl_in_chain (seq);
|
|
|
/* Mark labels. */
|
/* Mark labels. */
|
for (insn = insn_last; insn ; insn = PREV_INSN (insn))
|
for (insn = insn_last; insn ; insn = PREV_INSN (insn))
|
{
|
{
|
if (JUMP_P (insn))
|
if (JUMP_P (insn))
|
{
|
{
|
mark_jump_label (PATTERN (insn), insn, 0);
|
mark_jump_label (PATTERN (insn), insn, 0);
|
njumps++;
|
njumps++;
|
if (probability != -1
|
if (probability != -1
|
&& any_condjump_p (insn)
|
&& any_condjump_p (insn)
|
&& !find_reg_note (insn, REG_BR_PROB, 0))
|
&& !find_reg_note (insn, REG_BR_PROB, 0))
|
{
|
{
|
/* We can preserve the REG_BR_PROB notes only if exactly
|
/* We can preserve the REG_BR_PROB notes only if exactly
|
one jump is created, otherwise the machine description
|
one jump is created, otherwise the machine description
|
is responsible for this step using
|
is responsible for this step using
|
split_branch_probability variable. */
|
split_branch_probability variable. */
|
gcc_assert (njumps == 1);
|
gcc_assert (njumps == 1);
|
add_reg_note (insn, REG_BR_PROB, GEN_INT (probability));
|
add_reg_note (insn, REG_BR_PROB, GEN_INT (probability));
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* If we are splitting a CALL_INSN, look for the CALL_INSN
|
/* If we are splitting a CALL_INSN, look for the CALL_INSN
|
in SEQ and copy our CALL_INSN_FUNCTION_USAGE to it. */
|
in SEQ and copy our CALL_INSN_FUNCTION_USAGE to it. */
|
if (CALL_P (trial))
|
if (CALL_P (trial))
|
{
|
{
|
for (insn = insn_last; insn ; insn = PREV_INSN (insn))
|
for (insn = insn_last; insn ; insn = PREV_INSN (insn))
|
if (CALL_P (insn))
|
if (CALL_P (insn))
|
{
|
{
|
rtx *p = &CALL_INSN_FUNCTION_USAGE (insn);
|
rtx *p = &CALL_INSN_FUNCTION_USAGE (insn);
|
while (*p)
|
while (*p)
|
p = &XEXP (*p, 1);
|
p = &XEXP (*p, 1);
|
*p = CALL_INSN_FUNCTION_USAGE (trial);
|
*p = CALL_INSN_FUNCTION_USAGE (trial);
|
SIBLING_CALL_P (insn) = SIBLING_CALL_P (trial);
|
SIBLING_CALL_P (insn) = SIBLING_CALL_P (trial);
|
|
|
/* Update the debug information for the CALL_INSN. */
|
/* Update the debug information for the CALL_INSN. */
|
if (flag_enable_icf_debug)
|
if (flag_enable_icf_debug)
|
(*debug_hooks->copy_call_info) (trial, insn);
|
(*debug_hooks->copy_call_info) (trial, insn);
|
}
|
}
|
}
|
}
|
|
|
/* Copy notes, particularly those related to the CFG. */
|
/* Copy notes, particularly those related to the CFG. */
|
for (note = REG_NOTES (trial); note; note = XEXP (note, 1))
|
for (note = REG_NOTES (trial); note; note = XEXP (note, 1))
|
{
|
{
|
switch (REG_NOTE_KIND (note))
|
switch (REG_NOTE_KIND (note))
|
{
|
{
|
case REG_EH_REGION:
|
case REG_EH_REGION:
|
copy_reg_eh_region_note_backward (note, insn_last, NULL);
|
copy_reg_eh_region_note_backward (note, insn_last, NULL);
|
break;
|
break;
|
|
|
case REG_NORETURN:
|
case REG_NORETURN:
|
case REG_SETJMP:
|
case REG_SETJMP:
|
for (insn = insn_last; insn != NULL_RTX; insn = PREV_INSN (insn))
|
for (insn = insn_last; insn != NULL_RTX; insn = PREV_INSN (insn))
|
{
|
{
|
if (CALL_P (insn))
|
if (CALL_P (insn))
|
add_reg_note (insn, REG_NOTE_KIND (note), XEXP (note, 0));
|
add_reg_note (insn, REG_NOTE_KIND (note), XEXP (note, 0));
|
}
|
}
|
break;
|
break;
|
|
|
case REG_NON_LOCAL_GOTO:
|
case REG_NON_LOCAL_GOTO:
|
for (insn = insn_last; insn != NULL_RTX; insn = PREV_INSN (insn))
|
for (insn = insn_last; insn != NULL_RTX; insn = PREV_INSN (insn))
|
{
|
{
|
if (JUMP_P (insn))
|
if (JUMP_P (insn))
|
add_reg_note (insn, REG_NOTE_KIND (note), XEXP (note, 0));
|
add_reg_note (insn, REG_NOTE_KIND (note), XEXP (note, 0));
|
}
|
}
|
break;
|
break;
|
|
|
#ifdef AUTO_INC_DEC
|
#ifdef AUTO_INC_DEC
|
case REG_INC:
|
case REG_INC:
|
for (insn = insn_last; insn != NULL_RTX; insn = PREV_INSN (insn))
|
for (insn = insn_last; insn != NULL_RTX; insn = PREV_INSN (insn))
|
{
|
{
|
rtx reg = XEXP (note, 0);
|
rtx reg = XEXP (note, 0);
|
if (!FIND_REG_INC_NOTE (insn, reg)
|
if (!FIND_REG_INC_NOTE (insn, reg)
|
&& for_each_rtx (&PATTERN (insn), find_auto_inc, reg) > 0)
|
&& for_each_rtx (&PATTERN (insn), find_auto_inc, reg) > 0)
|
add_reg_note (insn, REG_INC, reg);
|
add_reg_note (insn, REG_INC, reg);
|
}
|
}
|
break;
|
break;
|
#endif
|
#endif
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* If there are LABELS inside the split insns increment the
|
/* If there are LABELS inside the split insns increment the
|
usage count so we don't delete the label. */
|
usage count so we don't delete the label. */
|
if (INSN_P (trial))
|
if (INSN_P (trial))
|
{
|
{
|
insn = insn_last;
|
insn = insn_last;
|
while (insn != NULL_RTX)
|
while (insn != NULL_RTX)
|
{
|
{
|
/* JUMP_P insns have already been "marked" above. */
|
/* JUMP_P insns have already been "marked" above. */
|
if (NONJUMP_INSN_P (insn))
|
if (NONJUMP_INSN_P (insn))
|
mark_label_nuses (PATTERN (insn));
|
mark_label_nuses (PATTERN (insn));
|
|
|
insn = PREV_INSN (insn);
|
insn = PREV_INSN (insn);
|
}
|
}
|
}
|
}
|
|
|
tem = emit_insn_after_setloc (seq, trial, INSN_LOCATOR (trial));
|
tem = emit_insn_after_setloc (seq, trial, INSN_LOCATOR (trial));
|
|
|
delete_insn (trial);
|
delete_insn (trial);
|
if (has_barrier)
|
if (has_barrier)
|
emit_barrier_after (tem);
|
emit_barrier_after (tem);
|
|
|
/* Recursively call try_split for each new insn created; by the
|
/* Recursively call try_split for each new insn created; by the
|
time control returns here that insn will be fully split, so
|
time control returns here that insn will be fully split, so
|
set LAST and continue from the insn after the one returned.
|
set LAST and continue from the insn after the one returned.
|
We can't use next_active_insn here since AFTER may be a note.
|
We can't use next_active_insn here since AFTER may be a note.
|
Ignore deleted insns, which can be occur if not optimizing. */
|
Ignore deleted insns, which can be occur if not optimizing. */
|
for (tem = NEXT_INSN (before); tem != after; tem = NEXT_INSN (tem))
|
for (tem = NEXT_INSN (before); tem != after; tem = NEXT_INSN (tem))
|
if (! INSN_DELETED_P (tem) && INSN_P (tem))
|
if (! INSN_DELETED_P (tem) && INSN_P (tem))
|
tem = try_split (PATTERN (tem), tem, 1);
|
tem = try_split (PATTERN (tem), tem, 1);
|
|
|
/* Return either the first or the last insn, depending on which was
|
/* Return either the first or the last insn, depending on which was
|
requested. */
|
requested. */
|
return last
|
return last
|
? (after ? PREV_INSN (after) : last_insn)
|
? (after ? PREV_INSN (after) : last_insn)
|
: NEXT_INSN (before);
|
: NEXT_INSN (before);
|
}
|
}
|
|
|
/* Make and return an INSN rtx, initializing all its slots.
|
/* Make and return an INSN rtx, initializing all its slots.
|
Store PATTERN in the pattern slots. */
|
Store PATTERN in the pattern slots. */
|
|
|
rtx
|
rtx
|
make_insn_raw (rtx pattern)
|
make_insn_raw (rtx pattern)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
insn = rtx_alloc (INSN);
|
insn = rtx_alloc (INSN);
|
|
|
INSN_UID (insn) = cur_insn_uid++;
|
INSN_UID (insn) = cur_insn_uid++;
|
PATTERN (insn) = pattern;
|
PATTERN (insn) = pattern;
|
INSN_CODE (insn) = -1;
|
INSN_CODE (insn) = -1;
|
REG_NOTES (insn) = NULL;
|
REG_NOTES (insn) = NULL;
|
INSN_LOCATOR (insn) = curr_insn_locator ();
|
INSN_LOCATOR (insn) = curr_insn_locator ();
|
BLOCK_FOR_INSN (insn) = NULL;
|
BLOCK_FOR_INSN (insn) = NULL;
|
|
|
#ifdef ENABLE_RTL_CHECKING
|
#ifdef ENABLE_RTL_CHECKING
|
if (insn
|
if (insn
|
&& INSN_P (insn)
|
&& INSN_P (insn)
|
&& (returnjump_p (insn)
|
&& (returnjump_p (insn)
|
|| (GET_CODE (insn) == SET
|
|| (GET_CODE (insn) == SET
|
&& SET_DEST (insn) == pc_rtx)))
|
&& SET_DEST (insn) == pc_rtx)))
|
{
|
{
|
warning (0, "ICE: emit_insn used where emit_jump_insn needed:\n");
|
warning (0, "ICE: emit_insn used where emit_jump_insn needed:\n");
|
debug_rtx (insn);
|
debug_rtx (insn);
|
}
|
}
|
#endif
|
#endif
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Like `make_insn_raw' but make a DEBUG_INSN instead of an insn. */
|
/* Like `make_insn_raw' but make a DEBUG_INSN instead of an insn. */
|
|
|
rtx
|
rtx
|
make_debug_insn_raw (rtx pattern)
|
make_debug_insn_raw (rtx pattern)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
insn = rtx_alloc (DEBUG_INSN);
|
insn = rtx_alloc (DEBUG_INSN);
|
INSN_UID (insn) = cur_debug_insn_uid++;
|
INSN_UID (insn) = cur_debug_insn_uid++;
|
if (cur_debug_insn_uid > MIN_NONDEBUG_INSN_UID)
|
if (cur_debug_insn_uid > MIN_NONDEBUG_INSN_UID)
|
INSN_UID (insn) = cur_insn_uid++;
|
INSN_UID (insn) = cur_insn_uid++;
|
|
|
PATTERN (insn) = pattern;
|
PATTERN (insn) = pattern;
|
INSN_CODE (insn) = -1;
|
INSN_CODE (insn) = -1;
|
REG_NOTES (insn) = NULL;
|
REG_NOTES (insn) = NULL;
|
INSN_LOCATOR (insn) = curr_insn_locator ();
|
INSN_LOCATOR (insn) = curr_insn_locator ();
|
BLOCK_FOR_INSN (insn) = NULL;
|
BLOCK_FOR_INSN (insn) = NULL;
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Like `make_insn_raw' but make a JUMP_INSN instead of an insn. */
|
/* Like `make_insn_raw' but make a JUMP_INSN instead of an insn. */
|
|
|
rtx
|
rtx
|
make_jump_insn_raw (rtx pattern)
|
make_jump_insn_raw (rtx pattern)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
insn = rtx_alloc (JUMP_INSN);
|
insn = rtx_alloc (JUMP_INSN);
|
INSN_UID (insn) = cur_insn_uid++;
|
INSN_UID (insn) = cur_insn_uid++;
|
|
|
PATTERN (insn) = pattern;
|
PATTERN (insn) = pattern;
|
INSN_CODE (insn) = -1;
|
INSN_CODE (insn) = -1;
|
REG_NOTES (insn) = NULL;
|
REG_NOTES (insn) = NULL;
|
JUMP_LABEL (insn) = NULL;
|
JUMP_LABEL (insn) = NULL;
|
INSN_LOCATOR (insn) = curr_insn_locator ();
|
INSN_LOCATOR (insn) = curr_insn_locator ();
|
BLOCK_FOR_INSN (insn) = NULL;
|
BLOCK_FOR_INSN (insn) = NULL;
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Like `make_insn_raw' but make a CALL_INSN instead of an insn. */
|
/* Like `make_insn_raw' but make a CALL_INSN instead of an insn. */
|
|
|
static rtx
|
static rtx
|
make_call_insn_raw (rtx pattern)
|
make_call_insn_raw (rtx pattern)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
insn = rtx_alloc (CALL_INSN);
|
insn = rtx_alloc (CALL_INSN);
|
INSN_UID (insn) = cur_insn_uid++;
|
INSN_UID (insn) = cur_insn_uid++;
|
|
|
PATTERN (insn) = pattern;
|
PATTERN (insn) = pattern;
|
INSN_CODE (insn) = -1;
|
INSN_CODE (insn) = -1;
|
REG_NOTES (insn) = NULL;
|
REG_NOTES (insn) = NULL;
|
CALL_INSN_FUNCTION_USAGE (insn) = NULL;
|
CALL_INSN_FUNCTION_USAGE (insn) = NULL;
|
INSN_LOCATOR (insn) = curr_insn_locator ();
|
INSN_LOCATOR (insn) = curr_insn_locator ();
|
BLOCK_FOR_INSN (insn) = NULL;
|
BLOCK_FOR_INSN (insn) = NULL;
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Add INSN to the end of the doubly-linked list.
|
/* Add INSN to the end of the doubly-linked list.
|
INSN may be an INSN, JUMP_INSN, CALL_INSN, CODE_LABEL, BARRIER or NOTE. */
|
INSN may be an INSN, JUMP_INSN, CALL_INSN, CODE_LABEL, BARRIER or NOTE. */
|
|
|
void
|
void
|
add_insn (rtx insn)
|
add_insn (rtx insn)
|
{
|
{
|
PREV_INSN (insn) = last_insn;
|
PREV_INSN (insn) = last_insn;
|
NEXT_INSN (insn) = 0;
|
NEXT_INSN (insn) = 0;
|
|
|
if (NULL != last_insn)
|
if (NULL != last_insn)
|
NEXT_INSN (last_insn) = insn;
|
NEXT_INSN (last_insn) = insn;
|
|
|
if (NULL == first_insn)
|
if (NULL == first_insn)
|
first_insn = insn;
|
first_insn = insn;
|
|
|
last_insn = insn;
|
last_insn = insn;
|
}
|
}
|
|
|
/* Add INSN into the doubly-linked list after insn AFTER. This and
|
/* Add INSN into the doubly-linked list after insn AFTER. This and
|
the next should be the only functions called to insert an insn once
|
the next should be the only functions called to insert an insn once
|
delay slots have been filled since only they know how to update a
|
delay slots have been filled since only they know how to update a
|
SEQUENCE. */
|
SEQUENCE. */
|
|
|
void
|
void
|
add_insn_after (rtx insn, rtx after, basic_block bb)
|
add_insn_after (rtx insn, rtx after, basic_block bb)
|
{
|
{
|
rtx next = NEXT_INSN (after);
|
rtx next = NEXT_INSN (after);
|
|
|
gcc_assert (!optimize || !INSN_DELETED_P (after));
|
gcc_assert (!optimize || !INSN_DELETED_P (after));
|
|
|
NEXT_INSN (insn) = next;
|
NEXT_INSN (insn) = next;
|
PREV_INSN (insn) = after;
|
PREV_INSN (insn) = after;
|
|
|
if (next)
|
if (next)
|
{
|
{
|
PREV_INSN (next) = insn;
|
PREV_INSN (next) = insn;
|
if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SEQUENCE)
|
if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SEQUENCE)
|
PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = insn;
|
PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = insn;
|
}
|
}
|
else if (last_insn == after)
|
else if (last_insn == after)
|
last_insn = insn;
|
last_insn = insn;
|
else
|
else
|
{
|
{
|
struct sequence_stack *stack = seq_stack;
|
struct sequence_stack *stack = seq_stack;
|
/* Scan all pending sequences too. */
|
/* Scan all pending sequences too. */
|
for (; stack; stack = stack->next)
|
for (; stack; stack = stack->next)
|
if (after == stack->last)
|
if (after == stack->last)
|
{
|
{
|
stack->last = insn;
|
stack->last = insn;
|
break;
|
break;
|
}
|
}
|
|
|
gcc_assert (stack);
|
gcc_assert (stack);
|
}
|
}
|
|
|
if (!BARRIER_P (after)
|
if (!BARRIER_P (after)
|
&& !BARRIER_P (insn)
|
&& !BARRIER_P (insn)
|
&& (bb = BLOCK_FOR_INSN (after)))
|
&& (bb = BLOCK_FOR_INSN (after)))
|
{
|
{
|
set_block_for_insn (insn, bb);
|
set_block_for_insn (insn, bb);
|
if (INSN_P (insn))
|
if (INSN_P (insn))
|
df_insn_rescan (insn);
|
df_insn_rescan (insn);
|
/* Should not happen as first in the BB is always
|
/* Should not happen as first in the BB is always
|
either NOTE or LABEL. */
|
either NOTE or LABEL. */
|
if (BB_END (bb) == after
|
if (BB_END (bb) == after
|
/* Avoid clobbering of structure when creating new BB. */
|
/* Avoid clobbering of structure when creating new BB. */
|
&& !BARRIER_P (insn)
|
&& !BARRIER_P (insn)
|
&& !NOTE_INSN_BASIC_BLOCK_P (insn))
|
&& !NOTE_INSN_BASIC_BLOCK_P (insn))
|
BB_END (bb) = insn;
|
BB_END (bb) = insn;
|
}
|
}
|
|
|
NEXT_INSN (after) = insn;
|
NEXT_INSN (after) = insn;
|
if (NONJUMP_INSN_P (after) && GET_CODE (PATTERN (after)) == SEQUENCE)
|
if (NONJUMP_INSN_P (after) && GET_CODE (PATTERN (after)) == SEQUENCE)
|
{
|
{
|
rtx sequence = PATTERN (after);
|
rtx sequence = PATTERN (after);
|
NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
|
NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
|
}
|
}
|
}
|
}
|
|
|
/* Add INSN into the doubly-linked list before insn BEFORE. This and
|
/* Add INSN into the doubly-linked list before insn BEFORE. This and
|
the previous should be the only functions called to insert an insn
|
the previous should be the only functions called to insert an insn
|
once delay slots have been filled since only they know how to
|
once delay slots have been filled since only they know how to
|
update a SEQUENCE. If BB is NULL, an attempt is made to infer the
|
update a SEQUENCE. If BB is NULL, an attempt is made to infer the
|
bb from before. */
|
bb from before. */
|
|
|
void
|
void
|
add_insn_before (rtx insn, rtx before, basic_block bb)
|
add_insn_before (rtx insn, rtx before, basic_block bb)
|
{
|
{
|
rtx prev = PREV_INSN (before);
|
rtx prev = PREV_INSN (before);
|
|
|
gcc_assert (!optimize || !INSN_DELETED_P (before));
|
gcc_assert (!optimize || !INSN_DELETED_P (before));
|
|
|
PREV_INSN (insn) = prev;
|
PREV_INSN (insn) = prev;
|
NEXT_INSN (insn) = before;
|
NEXT_INSN (insn) = before;
|
|
|
if (prev)
|
if (prev)
|
{
|
{
|
NEXT_INSN (prev) = insn;
|
NEXT_INSN (prev) = insn;
|
if (NONJUMP_INSN_P (prev) && GET_CODE (PATTERN (prev)) == SEQUENCE)
|
if (NONJUMP_INSN_P (prev) && GET_CODE (PATTERN (prev)) == SEQUENCE)
|
{
|
{
|
rtx sequence = PATTERN (prev);
|
rtx sequence = PATTERN (prev);
|
NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
|
NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn;
|
}
|
}
|
}
|
}
|
else if (first_insn == before)
|
else if (first_insn == before)
|
first_insn = insn;
|
first_insn = insn;
|
else
|
else
|
{
|
{
|
struct sequence_stack *stack = seq_stack;
|
struct sequence_stack *stack = seq_stack;
|
/* Scan all pending sequences too. */
|
/* Scan all pending sequences too. */
|
for (; stack; stack = stack->next)
|
for (; stack; stack = stack->next)
|
if (before == stack->first)
|
if (before == stack->first)
|
{
|
{
|
stack->first = insn;
|
stack->first = insn;
|
break;
|
break;
|
}
|
}
|
|
|
gcc_assert (stack);
|
gcc_assert (stack);
|
}
|
}
|
|
|
if (!bb
|
if (!bb
|
&& !BARRIER_P (before)
|
&& !BARRIER_P (before)
|
&& !BARRIER_P (insn))
|
&& !BARRIER_P (insn))
|
bb = BLOCK_FOR_INSN (before);
|
bb = BLOCK_FOR_INSN (before);
|
|
|
if (bb)
|
if (bb)
|
{
|
{
|
set_block_for_insn (insn, bb);
|
set_block_for_insn (insn, bb);
|
if (INSN_P (insn))
|
if (INSN_P (insn))
|
df_insn_rescan (insn);
|
df_insn_rescan (insn);
|
/* Should not happen as first in the BB is always either NOTE or
|
/* Should not happen as first in the BB is always either NOTE or
|
LABEL. */
|
LABEL. */
|
gcc_assert (BB_HEAD (bb) != insn
|
gcc_assert (BB_HEAD (bb) != insn
|
/* Avoid clobbering of structure when creating new BB. */
|
/* Avoid clobbering of structure when creating new BB. */
|
|| BARRIER_P (insn)
|
|| BARRIER_P (insn)
|
|| NOTE_INSN_BASIC_BLOCK_P (insn));
|
|| NOTE_INSN_BASIC_BLOCK_P (insn));
|
}
|
}
|
|
|
PREV_INSN (before) = insn;
|
PREV_INSN (before) = insn;
|
if (NONJUMP_INSN_P (before) && GET_CODE (PATTERN (before)) == SEQUENCE)
|
if (NONJUMP_INSN_P (before) && GET_CODE (PATTERN (before)) == SEQUENCE)
|
PREV_INSN (XVECEXP (PATTERN (before), 0, 0)) = insn;
|
PREV_INSN (XVECEXP (PATTERN (before), 0, 0)) = insn;
|
}
|
}
|
|
|
|
|
/* Replace insn with an deleted instruction note. */
|
/* Replace insn with an deleted instruction note. */
|
|
|
void
|
void
|
set_insn_deleted (rtx insn)
|
set_insn_deleted (rtx insn)
|
{
|
{
|
df_insn_delete (BLOCK_FOR_INSN (insn), INSN_UID (insn));
|
df_insn_delete (BLOCK_FOR_INSN (insn), INSN_UID (insn));
|
PUT_CODE (insn, NOTE);
|
PUT_CODE (insn, NOTE);
|
NOTE_KIND (insn) = NOTE_INSN_DELETED;
|
NOTE_KIND (insn) = NOTE_INSN_DELETED;
|
}
|
}
|
|
|
|
|
/* Remove an insn from its doubly-linked list. This function knows how
|
/* Remove an insn from its doubly-linked list. This function knows how
|
to handle sequences. */
|
to handle sequences. */
|
void
|
void
|
remove_insn (rtx insn)
|
remove_insn (rtx insn)
|
{
|
{
|
rtx next = NEXT_INSN (insn);
|
rtx next = NEXT_INSN (insn);
|
rtx prev = PREV_INSN (insn);
|
rtx prev = PREV_INSN (insn);
|
basic_block bb;
|
basic_block bb;
|
|
|
/* Later in the code, the block will be marked dirty. */
|
/* Later in the code, the block will be marked dirty. */
|
df_insn_delete (NULL, INSN_UID (insn));
|
df_insn_delete (NULL, INSN_UID (insn));
|
|
|
if (prev)
|
if (prev)
|
{
|
{
|
NEXT_INSN (prev) = next;
|
NEXT_INSN (prev) = next;
|
if (NONJUMP_INSN_P (prev) && GET_CODE (PATTERN (prev)) == SEQUENCE)
|
if (NONJUMP_INSN_P (prev) && GET_CODE (PATTERN (prev)) == SEQUENCE)
|
{
|
{
|
rtx sequence = PATTERN (prev);
|
rtx sequence = PATTERN (prev);
|
NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = next;
|
NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = next;
|
}
|
}
|
}
|
}
|
else if (first_insn == insn)
|
else if (first_insn == insn)
|
first_insn = next;
|
first_insn = next;
|
else
|
else
|
{
|
{
|
struct sequence_stack *stack = seq_stack;
|
struct sequence_stack *stack = seq_stack;
|
/* Scan all pending sequences too. */
|
/* Scan all pending sequences too. */
|
for (; stack; stack = stack->next)
|
for (; stack; stack = stack->next)
|
if (insn == stack->first)
|
if (insn == stack->first)
|
{
|
{
|
stack->first = next;
|
stack->first = next;
|
break;
|
break;
|
}
|
}
|
|
|
gcc_assert (stack);
|
gcc_assert (stack);
|
}
|
}
|
|
|
if (next)
|
if (next)
|
{
|
{
|
PREV_INSN (next) = prev;
|
PREV_INSN (next) = prev;
|
if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SEQUENCE)
|
if (NONJUMP_INSN_P (next) && GET_CODE (PATTERN (next)) == SEQUENCE)
|
PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = prev;
|
PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = prev;
|
}
|
}
|
else if (last_insn == insn)
|
else if (last_insn == insn)
|
last_insn = prev;
|
last_insn = prev;
|
else
|
else
|
{
|
{
|
struct sequence_stack *stack = seq_stack;
|
struct sequence_stack *stack = seq_stack;
|
/* Scan all pending sequences too. */
|
/* Scan all pending sequences too. */
|
for (; stack; stack = stack->next)
|
for (; stack; stack = stack->next)
|
if (insn == stack->last)
|
if (insn == stack->last)
|
{
|
{
|
stack->last = prev;
|
stack->last = prev;
|
break;
|
break;
|
}
|
}
|
|
|
gcc_assert (stack);
|
gcc_assert (stack);
|
}
|
}
|
if (!BARRIER_P (insn)
|
if (!BARRIER_P (insn)
|
&& (bb = BLOCK_FOR_INSN (insn)))
|
&& (bb = BLOCK_FOR_INSN (insn)))
|
{
|
{
|
if (INSN_P (insn))
|
if (INSN_P (insn))
|
df_set_bb_dirty (bb);
|
df_set_bb_dirty (bb);
|
if (BB_HEAD (bb) == insn)
|
if (BB_HEAD (bb) == insn)
|
{
|
{
|
/* Never ever delete the basic block note without deleting whole
|
/* Never ever delete the basic block note without deleting whole
|
basic block. */
|
basic block. */
|
gcc_assert (!NOTE_P (insn));
|
gcc_assert (!NOTE_P (insn));
|
BB_HEAD (bb) = next;
|
BB_HEAD (bb) = next;
|
}
|
}
|
if (BB_END (bb) == insn)
|
if (BB_END (bb) == insn)
|
BB_END (bb) = prev;
|
BB_END (bb) = prev;
|
}
|
}
|
}
|
}
|
|
|
/* Append CALL_FUSAGE to the CALL_INSN_FUNCTION_USAGE for CALL_INSN. */
|
/* Append CALL_FUSAGE to the CALL_INSN_FUNCTION_USAGE for CALL_INSN. */
|
|
|
void
|
void
|
add_function_usage_to (rtx call_insn, rtx call_fusage)
|
add_function_usage_to (rtx call_insn, rtx call_fusage)
|
{
|
{
|
gcc_assert (call_insn && CALL_P (call_insn));
|
gcc_assert (call_insn && CALL_P (call_insn));
|
|
|
/* Put the register usage information on the CALL. If there is already
|
/* Put the register usage information on the CALL. If there is already
|
some usage information, put ours at the end. */
|
some usage information, put ours at the end. */
|
if (CALL_INSN_FUNCTION_USAGE (call_insn))
|
if (CALL_INSN_FUNCTION_USAGE (call_insn))
|
{
|
{
|
rtx link;
|
rtx link;
|
|
|
for (link = CALL_INSN_FUNCTION_USAGE (call_insn); XEXP (link, 1) != 0;
|
for (link = CALL_INSN_FUNCTION_USAGE (call_insn); XEXP (link, 1) != 0;
|
link = XEXP (link, 1))
|
link = XEXP (link, 1))
|
;
|
;
|
|
|
XEXP (link, 1) = call_fusage;
|
XEXP (link, 1) = call_fusage;
|
}
|
}
|
else
|
else
|
CALL_INSN_FUNCTION_USAGE (call_insn) = call_fusage;
|
CALL_INSN_FUNCTION_USAGE (call_insn) = call_fusage;
|
}
|
}
|
|
|
/* Delete all insns made since FROM.
|
/* Delete all insns made since FROM.
|
FROM becomes the new last instruction. */
|
FROM becomes the new last instruction. */
|
|
|
void
|
void
|
delete_insns_since (rtx from)
|
delete_insns_since (rtx from)
|
{
|
{
|
if (from == 0)
|
if (from == 0)
|
first_insn = 0;
|
first_insn = 0;
|
else
|
else
|
NEXT_INSN (from) = 0;
|
NEXT_INSN (from) = 0;
|
last_insn = from;
|
last_insn = from;
|
}
|
}
|
|
|
/* This function is deprecated, please use sequences instead.
|
/* This function is deprecated, please use sequences instead.
|
|
|
Move a consecutive bunch of insns to a different place in the chain.
|
Move a consecutive bunch of insns to a different place in the chain.
|
The insns to be moved are those between FROM and TO.
|
The insns to be moved are those between FROM and TO.
|
They are moved to a new position after the insn AFTER.
|
They are moved to a new position after the insn AFTER.
|
AFTER must not be FROM or TO or any insn in between.
|
AFTER must not be FROM or TO or any insn in between.
|
|
|
This function does not know about SEQUENCEs and hence should not be
|
This function does not know about SEQUENCEs and hence should not be
|
called after delay-slot filling has been done. */
|
called after delay-slot filling has been done. */
|
|
|
void
|
void
|
reorder_insns_nobb (rtx from, rtx to, rtx after)
|
reorder_insns_nobb (rtx from, rtx to, rtx after)
|
{
|
{
|
/* Splice this bunch out of where it is now. */
|
/* Splice this bunch out of where it is now. */
|
if (PREV_INSN (from))
|
if (PREV_INSN (from))
|
NEXT_INSN (PREV_INSN (from)) = NEXT_INSN (to);
|
NEXT_INSN (PREV_INSN (from)) = NEXT_INSN (to);
|
if (NEXT_INSN (to))
|
if (NEXT_INSN (to))
|
PREV_INSN (NEXT_INSN (to)) = PREV_INSN (from);
|
PREV_INSN (NEXT_INSN (to)) = PREV_INSN (from);
|
if (last_insn == to)
|
if (last_insn == to)
|
last_insn = PREV_INSN (from);
|
last_insn = PREV_INSN (from);
|
if (first_insn == from)
|
if (first_insn == from)
|
first_insn = NEXT_INSN (to);
|
first_insn = NEXT_INSN (to);
|
|
|
/* Make the new neighbors point to it and it to them. */
|
/* Make the new neighbors point to it and it to them. */
|
if (NEXT_INSN (after))
|
if (NEXT_INSN (after))
|
PREV_INSN (NEXT_INSN (after)) = to;
|
PREV_INSN (NEXT_INSN (after)) = to;
|
|
|
NEXT_INSN (to) = NEXT_INSN (after);
|
NEXT_INSN (to) = NEXT_INSN (after);
|
PREV_INSN (from) = after;
|
PREV_INSN (from) = after;
|
NEXT_INSN (after) = from;
|
NEXT_INSN (after) = from;
|
if (after == last_insn)
|
if (after == last_insn)
|
last_insn = to;
|
last_insn = to;
|
}
|
}
|
|
|
/* Same as function above, but take care to update BB boundaries. */
|
/* Same as function above, but take care to update BB boundaries. */
|
void
|
void
|
reorder_insns (rtx from, rtx to, rtx after)
|
reorder_insns (rtx from, rtx to, rtx after)
|
{
|
{
|
rtx prev = PREV_INSN (from);
|
rtx prev = PREV_INSN (from);
|
basic_block bb, bb2;
|
basic_block bb, bb2;
|
|
|
reorder_insns_nobb (from, to, after);
|
reorder_insns_nobb (from, to, after);
|
|
|
if (!BARRIER_P (after)
|
if (!BARRIER_P (after)
|
&& (bb = BLOCK_FOR_INSN (after)))
|
&& (bb = BLOCK_FOR_INSN (after)))
|
{
|
{
|
rtx x;
|
rtx x;
|
df_set_bb_dirty (bb);
|
df_set_bb_dirty (bb);
|
|
|
if (!BARRIER_P (from)
|
if (!BARRIER_P (from)
|
&& (bb2 = BLOCK_FOR_INSN (from)))
|
&& (bb2 = BLOCK_FOR_INSN (from)))
|
{
|
{
|
if (BB_END (bb2) == to)
|
if (BB_END (bb2) == to)
|
BB_END (bb2) = prev;
|
BB_END (bb2) = prev;
|
df_set_bb_dirty (bb2);
|
df_set_bb_dirty (bb2);
|
}
|
}
|
|
|
if (BB_END (bb) == after)
|
if (BB_END (bb) == after)
|
BB_END (bb) = to;
|
BB_END (bb) = to;
|
|
|
for (x = from; x != NEXT_INSN (to); x = NEXT_INSN (x))
|
for (x = from; x != NEXT_INSN (to); x = NEXT_INSN (x))
|
if (!BARRIER_P (x))
|
if (!BARRIER_P (x))
|
df_insn_change_bb (x, bb);
|
df_insn_change_bb (x, bb);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Emit insn(s) of given code and pattern
|
/* Emit insn(s) of given code and pattern
|
at a specified place within the doubly-linked list.
|
at a specified place within the doubly-linked list.
|
|
|
All of the emit_foo global entry points accept an object
|
All of the emit_foo global entry points accept an object
|
X which is either an insn list or a PATTERN of a single
|
X which is either an insn list or a PATTERN of a single
|
instruction.
|
instruction.
|
|
|
There are thus a few canonical ways to generate code and
|
There are thus a few canonical ways to generate code and
|
emit it at a specific place in the instruction stream. For
|
emit it at a specific place in the instruction stream. For
|
example, consider the instruction named SPOT and the fact that
|
example, consider the instruction named SPOT and the fact that
|
we would like to emit some instructions before SPOT. We might
|
we would like to emit some instructions before SPOT. We might
|
do it like this:
|
do it like this:
|
|
|
start_sequence ();
|
start_sequence ();
|
... emit the new instructions ...
|
... emit the new instructions ...
|
insns_head = get_insns ();
|
insns_head = get_insns ();
|
end_sequence ();
|
end_sequence ();
|
|
|
emit_insn_before (insns_head, SPOT);
|
emit_insn_before (insns_head, SPOT);
|
|
|
It used to be common to generate SEQUENCE rtl instead, but that
|
It used to be common to generate SEQUENCE rtl instead, but that
|
is a relic of the past which no longer occurs. The reason is that
|
is a relic of the past which no longer occurs. The reason is that
|
SEQUENCE rtl results in much fragmented RTL memory since the SEQUENCE
|
SEQUENCE rtl results in much fragmented RTL memory since the SEQUENCE
|
generated would almost certainly die right after it was created. */
|
generated would almost certainly die right after it was created. */
|
|
|
/* Make X be output before the instruction BEFORE. */
|
/* Make X be output before the instruction BEFORE. */
|
|
|
rtx
|
rtx
|
emit_insn_before_noloc (rtx x, rtx before, basic_block bb)
|
emit_insn_before_noloc (rtx x, rtx before, basic_block bb)
|
{
|
{
|
rtx last = before;
|
rtx last = before;
|
rtx insn;
|
rtx insn;
|
|
|
gcc_assert (before);
|
gcc_assert (before);
|
|
|
if (x == NULL_RTX)
|
if (x == NULL_RTX)
|
return last;
|
return last;
|
|
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case DEBUG_INSN:
|
case DEBUG_INSN:
|
case INSN:
|
case INSN:
|
case JUMP_INSN:
|
case JUMP_INSN:
|
case CALL_INSN:
|
case CALL_INSN:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case BARRIER:
|
case BARRIER:
|
case NOTE:
|
case NOTE:
|
insn = x;
|
insn = x;
|
while (insn)
|
while (insn)
|
{
|
{
|
rtx next = NEXT_INSN (insn);
|
rtx next = NEXT_INSN (insn);
|
add_insn_before (insn, before, bb);
|
add_insn_before (insn, before, bb);
|
last = insn;
|
last = insn;
|
insn = next;
|
insn = next;
|
}
|
}
|
break;
|
break;
|
|
|
#ifdef ENABLE_RTL_CHECKING
|
#ifdef ENABLE_RTL_CHECKING
|
case SEQUENCE:
|
case SEQUENCE:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
break;
|
break;
|
#endif
|
#endif
|
|
|
default:
|
default:
|
last = make_insn_raw (x);
|
last = make_insn_raw (x);
|
add_insn_before (last, before, bb);
|
add_insn_before (last, before, bb);
|
break;
|
break;
|
}
|
}
|
|
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Make an instruction with body X and code JUMP_INSN
|
/* Make an instruction with body X and code JUMP_INSN
|
and output it before the instruction BEFORE. */
|
and output it before the instruction BEFORE. */
|
|
|
rtx
|
rtx
|
emit_jump_insn_before_noloc (rtx x, rtx before)
|
emit_jump_insn_before_noloc (rtx x, rtx before)
|
{
|
{
|
rtx insn, last = NULL_RTX;
|
rtx insn, last = NULL_RTX;
|
|
|
gcc_assert (before);
|
gcc_assert (before);
|
|
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case DEBUG_INSN:
|
case DEBUG_INSN:
|
case INSN:
|
case INSN:
|
case JUMP_INSN:
|
case JUMP_INSN:
|
case CALL_INSN:
|
case CALL_INSN:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case BARRIER:
|
case BARRIER:
|
case NOTE:
|
case NOTE:
|
insn = x;
|
insn = x;
|
while (insn)
|
while (insn)
|
{
|
{
|
rtx next = NEXT_INSN (insn);
|
rtx next = NEXT_INSN (insn);
|
add_insn_before (insn, before, NULL);
|
add_insn_before (insn, before, NULL);
|
last = insn;
|
last = insn;
|
insn = next;
|
insn = next;
|
}
|
}
|
break;
|
break;
|
|
|
#ifdef ENABLE_RTL_CHECKING
|
#ifdef ENABLE_RTL_CHECKING
|
case SEQUENCE:
|
case SEQUENCE:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
break;
|
break;
|
#endif
|
#endif
|
|
|
default:
|
default:
|
last = make_jump_insn_raw (x);
|
last = make_jump_insn_raw (x);
|
add_insn_before (last, before, NULL);
|
add_insn_before (last, before, NULL);
|
break;
|
break;
|
}
|
}
|
|
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Make an instruction with body X and code CALL_INSN
|
/* Make an instruction with body X and code CALL_INSN
|
and output it before the instruction BEFORE. */
|
and output it before the instruction BEFORE. */
|
|
|
rtx
|
rtx
|
emit_call_insn_before_noloc (rtx x, rtx before)
|
emit_call_insn_before_noloc (rtx x, rtx before)
|
{
|
{
|
rtx last = NULL_RTX, insn;
|
rtx last = NULL_RTX, insn;
|
|
|
gcc_assert (before);
|
gcc_assert (before);
|
|
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case DEBUG_INSN:
|
case DEBUG_INSN:
|
case INSN:
|
case INSN:
|
case JUMP_INSN:
|
case JUMP_INSN:
|
case CALL_INSN:
|
case CALL_INSN:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case BARRIER:
|
case BARRIER:
|
case NOTE:
|
case NOTE:
|
insn = x;
|
insn = x;
|
while (insn)
|
while (insn)
|
{
|
{
|
rtx next = NEXT_INSN (insn);
|
rtx next = NEXT_INSN (insn);
|
add_insn_before (insn, before, NULL);
|
add_insn_before (insn, before, NULL);
|
last = insn;
|
last = insn;
|
insn = next;
|
insn = next;
|
}
|
}
|
break;
|
break;
|
|
|
#ifdef ENABLE_RTL_CHECKING
|
#ifdef ENABLE_RTL_CHECKING
|
case SEQUENCE:
|
case SEQUENCE:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
break;
|
break;
|
#endif
|
#endif
|
|
|
default:
|
default:
|
last = make_call_insn_raw (x);
|
last = make_call_insn_raw (x);
|
add_insn_before (last, before, NULL);
|
add_insn_before (last, before, NULL);
|
break;
|
break;
|
}
|
}
|
|
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Make an instruction with body X and code DEBUG_INSN
|
/* Make an instruction with body X and code DEBUG_INSN
|
and output it before the instruction BEFORE. */
|
and output it before the instruction BEFORE. */
|
|
|
rtx
|
rtx
|
emit_debug_insn_before_noloc (rtx x, rtx before)
|
emit_debug_insn_before_noloc (rtx x, rtx before)
|
{
|
{
|
rtx last = NULL_RTX, insn;
|
rtx last = NULL_RTX, insn;
|
|
|
gcc_assert (before);
|
gcc_assert (before);
|
|
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case DEBUG_INSN:
|
case DEBUG_INSN:
|
case INSN:
|
case INSN:
|
case JUMP_INSN:
|
case JUMP_INSN:
|
case CALL_INSN:
|
case CALL_INSN:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case BARRIER:
|
case BARRIER:
|
case NOTE:
|
case NOTE:
|
insn = x;
|
insn = x;
|
while (insn)
|
while (insn)
|
{
|
{
|
rtx next = NEXT_INSN (insn);
|
rtx next = NEXT_INSN (insn);
|
add_insn_before (insn, before, NULL);
|
add_insn_before (insn, before, NULL);
|
last = insn;
|
last = insn;
|
insn = next;
|
insn = next;
|
}
|
}
|
break;
|
break;
|
|
|
#ifdef ENABLE_RTL_CHECKING
|
#ifdef ENABLE_RTL_CHECKING
|
case SEQUENCE:
|
case SEQUENCE:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
break;
|
break;
|
#endif
|
#endif
|
|
|
default:
|
default:
|
last = make_debug_insn_raw (x);
|
last = make_debug_insn_raw (x);
|
add_insn_before (last, before, NULL);
|
add_insn_before (last, before, NULL);
|
break;
|
break;
|
}
|
}
|
|
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Make an insn of code BARRIER
|
/* Make an insn of code BARRIER
|
and output it before the insn BEFORE. */
|
and output it before the insn BEFORE. */
|
|
|
rtx
|
rtx
|
emit_barrier_before (rtx before)
|
emit_barrier_before (rtx before)
|
{
|
{
|
rtx insn = rtx_alloc (BARRIER);
|
rtx insn = rtx_alloc (BARRIER);
|
|
|
INSN_UID (insn) = cur_insn_uid++;
|
INSN_UID (insn) = cur_insn_uid++;
|
|
|
add_insn_before (insn, before, NULL);
|
add_insn_before (insn, before, NULL);
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Emit the label LABEL before the insn BEFORE. */
|
/* Emit the label LABEL before the insn BEFORE. */
|
|
|
rtx
|
rtx
|
emit_label_before (rtx label, rtx before)
|
emit_label_before (rtx label, rtx before)
|
{
|
{
|
/* This can be called twice for the same label as a result of the
|
/* This can be called twice for the same label as a result of the
|
confusion that follows a syntax error! So make it harmless. */
|
confusion that follows a syntax error! So make it harmless. */
|
if (INSN_UID (label) == 0)
|
if (INSN_UID (label) == 0)
|
{
|
{
|
INSN_UID (label) = cur_insn_uid++;
|
INSN_UID (label) = cur_insn_uid++;
|
add_insn_before (label, before, NULL);
|
add_insn_before (label, before, NULL);
|
}
|
}
|
|
|
return label;
|
return label;
|
}
|
}
|
|
|
/* Emit a note of subtype SUBTYPE before the insn BEFORE. */
|
/* Emit a note of subtype SUBTYPE before the insn BEFORE. */
|
|
|
rtx
|
rtx
|
emit_note_before (enum insn_note subtype, rtx before)
|
emit_note_before (enum insn_note subtype, rtx before)
|
{
|
{
|
rtx note = rtx_alloc (NOTE);
|
rtx note = rtx_alloc (NOTE);
|
INSN_UID (note) = cur_insn_uid++;
|
INSN_UID (note) = cur_insn_uid++;
|
NOTE_KIND (note) = subtype;
|
NOTE_KIND (note) = subtype;
|
BLOCK_FOR_INSN (note) = NULL;
|
BLOCK_FOR_INSN (note) = NULL;
|
memset (&NOTE_DATA (note), 0, sizeof (NOTE_DATA (note)));
|
memset (&NOTE_DATA (note), 0, sizeof (NOTE_DATA (note)));
|
|
|
add_insn_before (note, before, NULL);
|
add_insn_before (note, before, NULL);
|
return note;
|
return note;
|
}
|
}
|
|
|
/* Helper for emit_insn_after, handles lists of instructions
|
/* Helper for emit_insn_after, handles lists of instructions
|
efficiently. */
|
efficiently. */
|
|
|
static rtx
|
static rtx
|
emit_insn_after_1 (rtx first, rtx after, basic_block bb)
|
emit_insn_after_1 (rtx first, rtx after, basic_block bb)
|
{
|
{
|
rtx last;
|
rtx last;
|
rtx after_after;
|
rtx after_after;
|
if (!bb && !BARRIER_P (after))
|
if (!bb && !BARRIER_P (after))
|
bb = BLOCK_FOR_INSN (after);
|
bb = BLOCK_FOR_INSN (after);
|
|
|
if (bb)
|
if (bb)
|
{
|
{
|
df_set_bb_dirty (bb);
|
df_set_bb_dirty (bb);
|
for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
|
for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
|
if (!BARRIER_P (last))
|
if (!BARRIER_P (last))
|
{
|
{
|
set_block_for_insn (last, bb);
|
set_block_for_insn (last, bb);
|
df_insn_rescan (last);
|
df_insn_rescan (last);
|
}
|
}
|
if (!BARRIER_P (last))
|
if (!BARRIER_P (last))
|
{
|
{
|
set_block_for_insn (last, bb);
|
set_block_for_insn (last, bb);
|
df_insn_rescan (last);
|
df_insn_rescan (last);
|
}
|
}
|
if (BB_END (bb) == after)
|
if (BB_END (bb) == after)
|
BB_END (bb) = last;
|
BB_END (bb) = last;
|
}
|
}
|
else
|
else
|
for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
|
for (last = first; NEXT_INSN (last); last = NEXT_INSN (last))
|
continue;
|
continue;
|
|
|
after_after = NEXT_INSN (after);
|
after_after = NEXT_INSN (after);
|
|
|
NEXT_INSN (after) = first;
|
NEXT_INSN (after) = first;
|
PREV_INSN (first) = after;
|
PREV_INSN (first) = after;
|
NEXT_INSN (last) = after_after;
|
NEXT_INSN (last) = after_after;
|
if (after_after)
|
if (after_after)
|
PREV_INSN (after_after) = last;
|
PREV_INSN (after_after) = last;
|
|
|
if (after == last_insn)
|
if (after == last_insn)
|
last_insn = last;
|
last_insn = last;
|
|
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Make X be output after the insn AFTER and set the BB of insn. If
|
/* Make X be output after the insn AFTER and set the BB of insn. If
|
BB is NULL, an attempt is made to infer the BB from AFTER. */
|
BB is NULL, an attempt is made to infer the BB from AFTER. */
|
|
|
rtx
|
rtx
|
emit_insn_after_noloc (rtx x, rtx after, basic_block bb)
|
emit_insn_after_noloc (rtx x, rtx after, basic_block bb)
|
{
|
{
|
rtx last = after;
|
rtx last = after;
|
|
|
gcc_assert (after);
|
gcc_assert (after);
|
|
|
if (x == NULL_RTX)
|
if (x == NULL_RTX)
|
return last;
|
return last;
|
|
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case DEBUG_INSN:
|
case DEBUG_INSN:
|
case INSN:
|
case INSN:
|
case JUMP_INSN:
|
case JUMP_INSN:
|
case CALL_INSN:
|
case CALL_INSN:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case BARRIER:
|
case BARRIER:
|
case NOTE:
|
case NOTE:
|
last = emit_insn_after_1 (x, after, bb);
|
last = emit_insn_after_1 (x, after, bb);
|
break;
|
break;
|
|
|
#ifdef ENABLE_RTL_CHECKING
|
#ifdef ENABLE_RTL_CHECKING
|
case SEQUENCE:
|
case SEQUENCE:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
break;
|
break;
|
#endif
|
#endif
|
|
|
default:
|
default:
|
last = make_insn_raw (x);
|
last = make_insn_raw (x);
|
add_insn_after (last, after, bb);
|
add_insn_after (last, after, bb);
|
break;
|
break;
|
}
|
}
|
|
|
return last;
|
return last;
|
}
|
}
|
|
|
|
|
/* Make an insn of code JUMP_INSN with body X
|
/* Make an insn of code JUMP_INSN with body X
|
and output it after the insn AFTER. */
|
and output it after the insn AFTER. */
|
|
|
rtx
|
rtx
|
emit_jump_insn_after_noloc (rtx x, rtx after)
|
emit_jump_insn_after_noloc (rtx x, rtx after)
|
{
|
{
|
rtx last;
|
rtx last;
|
|
|
gcc_assert (after);
|
gcc_assert (after);
|
|
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case DEBUG_INSN:
|
case DEBUG_INSN:
|
case INSN:
|
case INSN:
|
case JUMP_INSN:
|
case JUMP_INSN:
|
case CALL_INSN:
|
case CALL_INSN:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case BARRIER:
|
case BARRIER:
|
case NOTE:
|
case NOTE:
|
last = emit_insn_after_1 (x, after, NULL);
|
last = emit_insn_after_1 (x, after, NULL);
|
break;
|
break;
|
|
|
#ifdef ENABLE_RTL_CHECKING
|
#ifdef ENABLE_RTL_CHECKING
|
case SEQUENCE:
|
case SEQUENCE:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
break;
|
break;
|
#endif
|
#endif
|
|
|
default:
|
default:
|
last = make_jump_insn_raw (x);
|
last = make_jump_insn_raw (x);
|
add_insn_after (last, after, NULL);
|
add_insn_after (last, after, NULL);
|
break;
|
break;
|
}
|
}
|
|
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Make an instruction with body X and code CALL_INSN
|
/* Make an instruction with body X and code CALL_INSN
|
and output it after the instruction AFTER. */
|
and output it after the instruction AFTER. */
|
|
|
rtx
|
rtx
|
emit_call_insn_after_noloc (rtx x, rtx after)
|
emit_call_insn_after_noloc (rtx x, rtx after)
|
{
|
{
|
rtx last;
|
rtx last;
|
|
|
gcc_assert (after);
|
gcc_assert (after);
|
|
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case DEBUG_INSN:
|
case DEBUG_INSN:
|
case INSN:
|
case INSN:
|
case JUMP_INSN:
|
case JUMP_INSN:
|
case CALL_INSN:
|
case CALL_INSN:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case BARRIER:
|
case BARRIER:
|
case NOTE:
|
case NOTE:
|
last = emit_insn_after_1 (x, after, NULL);
|
last = emit_insn_after_1 (x, after, NULL);
|
break;
|
break;
|
|
|
#ifdef ENABLE_RTL_CHECKING
|
#ifdef ENABLE_RTL_CHECKING
|
case SEQUENCE:
|
case SEQUENCE:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
break;
|
break;
|
#endif
|
#endif
|
|
|
default:
|
default:
|
last = make_call_insn_raw (x);
|
last = make_call_insn_raw (x);
|
add_insn_after (last, after, NULL);
|
add_insn_after (last, after, NULL);
|
break;
|
break;
|
}
|
}
|
|
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Make an instruction with body X and code CALL_INSN
|
/* Make an instruction with body X and code CALL_INSN
|
and output it after the instruction AFTER. */
|
and output it after the instruction AFTER. */
|
|
|
rtx
|
rtx
|
emit_debug_insn_after_noloc (rtx x, rtx after)
|
emit_debug_insn_after_noloc (rtx x, rtx after)
|
{
|
{
|
rtx last;
|
rtx last;
|
|
|
gcc_assert (after);
|
gcc_assert (after);
|
|
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case DEBUG_INSN:
|
case DEBUG_INSN:
|
case INSN:
|
case INSN:
|
case JUMP_INSN:
|
case JUMP_INSN:
|
case CALL_INSN:
|
case CALL_INSN:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case BARRIER:
|
case BARRIER:
|
case NOTE:
|
case NOTE:
|
last = emit_insn_after_1 (x, after, NULL);
|
last = emit_insn_after_1 (x, after, NULL);
|
break;
|
break;
|
|
|
#ifdef ENABLE_RTL_CHECKING
|
#ifdef ENABLE_RTL_CHECKING
|
case SEQUENCE:
|
case SEQUENCE:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
break;
|
break;
|
#endif
|
#endif
|
|
|
default:
|
default:
|
last = make_debug_insn_raw (x);
|
last = make_debug_insn_raw (x);
|
add_insn_after (last, after, NULL);
|
add_insn_after (last, after, NULL);
|
break;
|
break;
|
}
|
}
|
|
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Make an insn of code BARRIER
|
/* Make an insn of code BARRIER
|
and output it after the insn AFTER. */
|
and output it after the insn AFTER. */
|
|
|
rtx
|
rtx
|
emit_barrier_after (rtx after)
|
emit_barrier_after (rtx after)
|
{
|
{
|
rtx insn = rtx_alloc (BARRIER);
|
rtx insn = rtx_alloc (BARRIER);
|
|
|
INSN_UID (insn) = cur_insn_uid++;
|
INSN_UID (insn) = cur_insn_uid++;
|
|
|
add_insn_after (insn, after, NULL);
|
add_insn_after (insn, after, NULL);
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Emit the label LABEL after the insn AFTER. */
|
/* Emit the label LABEL after the insn AFTER. */
|
|
|
rtx
|
rtx
|
emit_label_after (rtx label, rtx after)
|
emit_label_after (rtx label, rtx after)
|
{
|
{
|
/* This can be called twice for the same label
|
/* This can be called twice for the same label
|
as a result of the confusion that follows a syntax error!
|
as a result of the confusion that follows a syntax error!
|
So make it harmless. */
|
So make it harmless. */
|
if (INSN_UID (label) == 0)
|
if (INSN_UID (label) == 0)
|
{
|
{
|
INSN_UID (label) = cur_insn_uid++;
|
INSN_UID (label) = cur_insn_uid++;
|
add_insn_after (label, after, NULL);
|
add_insn_after (label, after, NULL);
|
}
|
}
|
|
|
return label;
|
return label;
|
}
|
}
|
|
|
/* Emit a note of subtype SUBTYPE after the insn AFTER. */
|
/* Emit a note of subtype SUBTYPE after the insn AFTER. */
|
|
|
rtx
|
rtx
|
emit_note_after (enum insn_note subtype, rtx after)
|
emit_note_after (enum insn_note subtype, rtx after)
|
{
|
{
|
rtx note = rtx_alloc (NOTE);
|
rtx note = rtx_alloc (NOTE);
|
INSN_UID (note) = cur_insn_uid++;
|
INSN_UID (note) = cur_insn_uid++;
|
NOTE_KIND (note) = subtype;
|
NOTE_KIND (note) = subtype;
|
BLOCK_FOR_INSN (note) = NULL;
|
BLOCK_FOR_INSN (note) = NULL;
|
memset (&NOTE_DATA (note), 0, sizeof (NOTE_DATA (note)));
|
memset (&NOTE_DATA (note), 0, sizeof (NOTE_DATA (note)));
|
add_insn_after (note, after, NULL);
|
add_insn_after (note, after, NULL);
|
return note;
|
return note;
|
}
|
}
|
|
|
/* Like emit_insn_after_noloc, but set INSN_LOCATOR according to SCOPE. */
|
/* Like emit_insn_after_noloc, but set INSN_LOCATOR according to SCOPE. */
|
rtx
|
rtx
|
emit_insn_after_setloc (rtx pattern, rtx after, int loc)
|
emit_insn_after_setloc (rtx pattern, rtx after, int loc)
|
{
|
{
|
rtx last = emit_insn_after_noloc (pattern, after, NULL);
|
rtx last = emit_insn_after_noloc (pattern, after, NULL);
|
|
|
if (pattern == NULL_RTX || !loc)
|
if (pattern == NULL_RTX || !loc)
|
return last;
|
return last;
|
|
|
after = NEXT_INSN (after);
|
after = NEXT_INSN (after);
|
while (1)
|
while (1)
|
{
|
{
|
if (active_insn_p (after) && !INSN_LOCATOR (after))
|
if (active_insn_p (after) && !INSN_LOCATOR (after))
|
INSN_LOCATOR (after) = loc;
|
INSN_LOCATOR (after) = loc;
|
if (after == last)
|
if (after == last)
|
break;
|
break;
|
after = NEXT_INSN (after);
|
after = NEXT_INSN (after);
|
}
|
}
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Like emit_insn_after_noloc, but set INSN_LOCATOR according to AFTER. */
|
/* Like emit_insn_after_noloc, but set INSN_LOCATOR according to AFTER. */
|
rtx
|
rtx
|
emit_insn_after (rtx pattern, rtx after)
|
emit_insn_after (rtx pattern, rtx after)
|
{
|
{
|
rtx prev = after;
|
rtx prev = after;
|
|
|
while (DEBUG_INSN_P (prev))
|
while (DEBUG_INSN_P (prev))
|
prev = PREV_INSN (prev);
|
prev = PREV_INSN (prev);
|
|
|
if (INSN_P (prev))
|
if (INSN_P (prev))
|
return emit_insn_after_setloc (pattern, after, INSN_LOCATOR (prev));
|
return emit_insn_after_setloc (pattern, after, INSN_LOCATOR (prev));
|
else
|
else
|
return emit_insn_after_noloc (pattern, after, NULL);
|
return emit_insn_after_noloc (pattern, after, NULL);
|
}
|
}
|
|
|
/* Like emit_jump_insn_after_noloc, but set INSN_LOCATOR according to SCOPE. */
|
/* Like emit_jump_insn_after_noloc, but set INSN_LOCATOR according to SCOPE. */
|
rtx
|
rtx
|
emit_jump_insn_after_setloc (rtx pattern, rtx after, int loc)
|
emit_jump_insn_after_setloc (rtx pattern, rtx after, int loc)
|
{
|
{
|
rtx last = emit_jump_insn_after_noloc (pattern, after);
|
rtx last = emit_jump_insn_after_noloc (pattern, after);
|
|
|
if (pattern == NULL_RTX || !loc)
|
if (pattern == NULL_RTX || !loc)
|
return last;
|
return last;
|
|
|
after = NEXT_INSN (after);
|
after = NEXT_INSN (after);
|
while (1)
|
while (1)
|
{
|
{
|
if (active_insn_p (after) && !INSN_LOCATOR (after))
|
if (active_insn_p (after) && !INSN_LOCATOR (after))
|
INSN_LOCATOR (after) = loc;
|
INSN_LOCATOR (after) = loc;
|
if (after == last)
|
if (after == last)
|
break;
|
break;
|
after = NEXT_INSN (after);
|
after = NEXT_INSN (after);
|
}
|
}
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Like emit_jump_insn_after_noloc, but set INSN_LOCATOR according to AFTER. */
|
/* Like emit_jump_insn_after_noloc, but set INSN_LOCATOR according to AFTER. */
|
rtx
|
rtx
|
emit_jump_insn_after (rtx pattern, rtx after)
|
emit_jump_insn_after (rtx pattern, rtx after)
|
{
|
{
|
rtx prev = after;
|
rtx prev = after;
|
|
|
while (DEBUG_INSN_P (prev))
|
while (DEBUG_INSN_P (prev))
|
prev = PREV_INSN (prev);
|
prev = PREV_INSN (prev);
|
|
|
if (INSN_P (prev))
|
if (INSN_P (prev))
|
return emit_jump_insn_after_setloc (pattern, after, INSN_LOCATOR (prev));
|
return emit_jump_insn_after_setloc (pattern, after, INSN_LOCATOR (prev));
|
else
|
else
|
return emit_jump_insn_after_noloc (pattern, after);
|
return emit_jump_insn_after_noloc (pattern, after);
|
}
|
}
|
|
|
/* Like emit_call_insn_after_noloc, but set INSN_LOCATOR according to SCOPE. */
|
/* Like emit_call_insn_after_noloc, but set INSN_LOCATOR according to SCOPE. */
|
rtx
|
rtx
|
emit_call_insn_after_setloc (rtx pattern, rtx after, int loc)
|
emit_call_insn_after_setloc (rtx pattern, rtx after, int loc)
|
{
|
{
|
rtx last = emit_call_insn_after_noloc (pattern, after);
|
rtx last = emit_call_insn_after_noloc (pattern, after);
|
|
|
if (pattern == NULL_RTX || !loc)
|
if (pattern == NULL_RTX || !loc)
|
return last;
|
return last;
|
|
|
after = NEXT_INSN (after);
|
after = NEXT_INSN (after);
|
while (1)
|
while (1)
|
{
|
{
|
if (active_insn_p (after) && !INSN_LOCATOR (after))
|
if (active_insn_p (after) && !INSN_LOCATOR (after))
|
INSN_LOCATOR (after) = loc;
|
INSN_LOCATOR (after) = loc;
|
if (after == last)
|
if (after == last)
|
break;
|
break;
|
after = NEXT_INSN (after);
|
after = NEXT_INSN (after);
|
}
|
}
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Like emit_call_insn_after_noloc, but set INSN_LOCATOR according to AFTER. */
|
/* Like emit_call_insn_after_noloc, but set INSN_LOCATOR according to AFTER. */
|
rtx
|
rtx
|
emit_call_insn_after (rtx pattern, rtx after)
|
emit_call_insn_after (rtx pattern, rtx after)
|
{
|
{
|
rtx prev = after;
|
rtx prev = after;
|
|
|
while (DEBUG_INSN_P (prev))
|
while (DEBUG_INSN_P (prev))
|
prev = PREV_INSN (prev);
|
prev = PREV_INSN (prev);
|
|
|
if (INSN_P (prev))
|
if (INSN_P (prev))
|
return emit_call_insn_after_setloc (pattern, after, INSN_LOCATOR (prev));
|
return emit_call_insn_after_setloc (pattern, after, INSN_LOCATOR (prev));
|
else
|
else
|
return emit_call_insn_after_noloc (pattern, after);
|
return emit_call_insn_after_noloc (pattern, after);
|
}
|
}
|
|
|
/* Like emit_debug_insn_after_noloc, but set INSN_LOCATOR according to SCOPE. */
|
/* Like emit_debug_insn_after_noloc, but set INSN_LOCATOR according to SCOPE. */
|
rtx
|
rtx
|
emit_debug_insn_after_setloc (rtx pattern, rtx after, int loc)
|
emit_debug_insn_after_setloc (rtx pattern, rtx after, int loc)
|
{
|
{
|
rtx last = emit_debug_insn_after_noloc (pattern, after);
|
rtx last = emit_debug_insn_after_noloc (pattern, after);
|
|
|
if (pattern == NULL_RTX || !loc)
|
if (pattern == NULL_RTX || !loc)
|
return last;
|
return last;
|
|
|
after = NEXT_INSN (after);
|
after = NEXT_INSN (after);
|
while (1)
|
while (1)
|
{
|
{
|
if (active_insn_p (after) && !INSN_LOCATOR (after))
|
if (active_insn_p (after) && !INSN_LOCATOR (after))
|
INSN_LOCATOR (after) = loc;
|
INSN_LOCATOR (after) = loc;
|
if (after == last)
|
if (after == last)
|
break;
|
break;
|
after = NEXT_INSN (after);
|
after = NEXT_INSN (after);
|
}
|
}
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Like emit_debug_insn_after_noloc, but set INSN_LOCATOR according to AFTER. */
|
/* Like emit_debug_insn_after_noloc, but set INSN_LOCATOR according to AFTER. */
|
rtx
|
rtx
|
emit_debug_insn_after (rtx pattern, rtx after)
|
emit_debug_insn_after (rtx pattern, rtx after)
|
{
|
{
|
if (INSN_P (after))
|
if (INSN_P (after))
|
return emit_debug_insn_after_setloc (pattern, after, INSN_LOCATOR (after));
|
return emit_debug_insn_after_setloc (pattern, after, INSN_LOCATOR (after));
|
else
|
else
|
return emit_debug_insn_after_noloc (pattern, after);
|
return emit_debug_insn_after_noloc (pattern, after);
|
}
|
}
|
|
|
/* Like emit_insn_before_noloc, but set INSN_LOCATOR according to SCOPE. */
|
/* Like emit_insn_before_noloc, but set INSN_LOCATOR according to SCOPE. */
|
rtx
|
rtx
|
emit_insn_before_setloc (rtx pattern, rtx before, int loc)
|
emit_insn_before_setloc (rtx pattern, rtx before, int loc)
|
{
|
{
|
rtx first = PREV_INSN (before);
|
rtx first = PREV_INSN (before);
|
rtx last = emit_insn_before_noloc (pattern, before, NULL);
|
rtx last = emit_insn_before_noloc (pattern, before, NULL);
|
|
|
if (pattern == NULL_RTX || !loc)
|
if (pattern == NULL_RTX || !loc)
|
return last;
|
return last;
|
|
|
if (!first)
|
if (!first)
|
first = get_insns ();
|
first = get_insns ();
|
else
|
else
|
first = NEXT_INSN (first);
|
first = NEXT_INSN (first);
|
while (1)
|
while (1)
|
{
|
{
|
if (active_insn_p (first) && !INSN_LOCATOR (first))
|
if (active_insn_p (first) && !INSN_LOCATOR (first))
|
INSN_LOCATOR (first) = loc;
|
INSN_LOCATOR (first) = loc;
|
if (first == last)
|
if (first == last)
|
break;
|
break;
|
first = NEXT_INSN (first);
|
first = NEXT_INSN (first);
|
}
|
}
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Like emit_insn_before_noloc, but set INSN_LOCATOR according to BEFORE. */
|
/* Like emit_insn_before_noloc, but set INSN_LOCATOR according to BEFORE. */
|
rtx
|
rtx
|
emit_insn_before (rtx pattern, rtx before)
|
emit_insn_before (rtx pattern, rtx before)
|
{
|
{
|
rtx next = before;
|
rtx next = before;
|
|
|
while (DEBUG_INSN_P (next))
|
while (DEBUG_INSN_P (next))
|
next = PREV_INSN (next);
|
next = PREV_INSN (next);
|
|
|
if (INSN_P (next))
|
if (INSN_P (next))
|
return emit_insn_before_setloc (pattern, before, INSN_LOCATOR (next));
|
return emit_insn_before_setloc (pattern, before, INSN_LOCATOR (next));
|
else
|
else
|
return emit_insn_before_noloc (pattern, before, NULL);
|
return emit_insn_before_noloc (pattern, before, NULL);
|
}
|
}
|
|
|
/* like emit_insn_before_noloc, but set insn_locator according to scope. */
|
/* like emit_insn_before_noloc, but set insn_locator according to scope. */
|
rtx
|
rtx
|
emit_jump_insn_before_setloc (rtx pattern, rtx before, int loc)
|
emit_jump_insn_before_setloc (rtx pattern, rtx before, int loc)
|
{
|
{
|
rtx first = PREV_INSN (before);
|
rtx first = PREV_INSN (before);
|
rtx last = emit_jump_insn_before_noloc (pattern, before);
|
rtx last = emit_jump_insn_before_noloc (pattern, before);
|
|
|
if (pattern == NULL_RTX)
|
if (pattern == NULL_RTX)
|
return last;
|
return last;
|
|
|
first = NEXT_INSN (first);
|
first = NEXT_INSN (first);
|
while (1)
|
while (1)
|
{
|
{
|
if (active_insn_p (first) && !INSN_LOCATOR (first))
|
if (active_insn_p (first) && !INSN_LOCATOR (first))
|
INSN_LOCATOR (first) = loc;
|
INSN_LOCATOR (first) = loc;
|
if (first == last)
|
if (first == last)
|
break;
|
break;
|
first = NEXT_INSN (first);
|
first = NEXT_INSN (first);
|
}
|
}
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Like emit_jump_insn_before_noloc, but set INSN_LOCATOR according to BEFORE. */
|
/* Like emit_jump_insn_before_noloc, but set INSN_LOCATOR according to BEFORE. */
|
rtx
|
rtx
|
emit_jump_insn_before (rtx pattern, rtx before)
|
emit_jump_insn_before (rtx pattern, rtx before)
|
{
|
{
|
rtx next = before;
|
rtx next = before;
|
|
|
while (DEBUG_INSN_P (next))
|
while (DEBUG_INSN_P (next))
|
next = PREV_INSN (next);
|
next = PREV_INSN (next);
|
|
|
if (INSN_P (next))
|
if (INSN_P (next))
|
return emit_jump_insn_before_setloc (pattern, before, INSN_LOCATOR (next));
|
return emit_jump_insn_before_setloc (pattern, before, INSN_LOCATOR (next));
|
else
|
else
|
return emit_jump_insn_before_noloc (pattern, before);
|
return emit_jump_insn_before_noloc (pattern, before);
|
}
|
}
|
|
|
/* like emit_insn_before_noloc, but set insn_locator according to scope. */
|
/* like emit_insn_before_noloc, but set insn_locator according to scope. */
|
rtx
|
rtx
|
emit_call_insn_before_setloc (rtx pattern, rtx before, int loc)
|
emit_call_insn_before_setloc (rtx pattern, rtx before, int loc)
|
{
|
{
|
rtx first = PREV_INSN (before);
|
rtx first = PREV_INSN (before);
|
rtx last = emit_call_insn_before_noloc (pattern, before);
|
rtx last = emit_call_insn_before_noloc (pattern, before);
|
|
|
if (pattern == NULL_RTX)
|
if (pattern == NULL_RTX)
|
return last;
|
return last;
|
|
|
first = NEXT_INSN (first);
|
first = NEXT_INSN (first);
|
while (1)
|
while (1)
|
{
|
{
|
if (active_insn_p (first) && !INSN_LOCATOR (first))
|
if (active_insn_p (first) && !INSN_LOCATOR (first))
|
INSN_LOCATOR (first) = loc;
|
INSN_LOCATOR (first) = loc;
|
if (first == last)
|
if (first == last)
|
break;
|
break;
|
first = NEXT_INSN (first);
|
first = NEXT_INSN (first);
|
}
|
}
|
return last;
|
return last;
|
}
|
}
|
|
|
/* like emit_call_insn_before_noloc,
|
/* like emit_call_insn_before_noloc,
|
but set insn_locator according to before. */
|
but set insn_locator according to before. */
|
rtx
|
rtx
|
emit_call_insn_before (rtx pattern, rtx before)
|
emit_call_insn_before (rtx pattern, rtx before)
|
{
|
{
|
rtx next = before;
|
rtx next = before;
|
|
|
while (DEBUG_INSN_P (next))
|
while (DEBUG_INSN_P (next))
|
next = PREV_INSN (next);
|
next = PREV_INSN (next);
|
|
|
if (INSN_P (next))
|
if (INSN_P (next))
|
return emit_call_insn_before_setloc (pattern, before, INSN_LOCATOR (next));
|
return emit_call_insn_before_setloc (pattern, before, INSN_LOCATOR (next));
|
else
|
else
|
return emit_call_insn_before_noloc (pattern, before);
|
return emit_call_insn_before_noloc (pattern, before);
|
}
|
}
|
|
|
/* like emit_insn_before_noloc, but set insn_locator according to scope. */
|
/* like emit_insn_before_noloc, but set insn_locator according to scope. */
|
rtx
|
rtx
|
emit_debug_insn_before_setloc (rtx pattern, rtx before, int loc)
|
emit_debug_insn_before_setloc (rtx pattern, rtx before, int loc)
|
{
|
{
|
rtx first = PREV_INSN (before);
|
rtx first = PREV_INSN (before);
|
rtx last = emit_debug_insn_before_noloc (pattern, before);
|
rtx last = emit_debug_insn_before_noloc (pattern, before);
|
|
|
if (pattern == NULL_RTX)
|
if (pattern == NULL_RTX)
|
return last;
|
return last;
|
|
|
first = NEXT_INSN (first);
|
first = NEXT_INSN (first);
|
while (1)
|
while (1)
|
{
|
{
|
if (active_insn_p (first) && !INSN_LOCATOR (first))
|
if (active_insn_p (first) && !INSN_LOCATOR (first))
|
INSN_LOCATOR (first) = loc;
|
INSN_LOCATOR (first) = loc;
|
if (first == last)
|
if (first == last)
|
break;
|
break;
|
first = NEXT_INSN (first);
|
first = NEXT_INSN (first);
|
}
|
}
|
return last;
|
return last;
|
}
|
}
|
|
|
/* like emit_debug_insn_before_noloc,
|
/* like emit_debug_insn_before_noloc,
|
but set insn_locator according to before. */
|
but set insn_locator according to before. */
|
rtx
|
rtx
|
emit_debug_insn_before (rtx pattern, rtx before)
|
emit_debug_insn_before (rtx pattern, rtx before)
|
{
|
{
|
if (INSN_P (before))
|
if (INSN_P (before))
|
return emit_debug_insn_before_setloc (pattern, before, INSN_LOCATOR (before));
|
return emit_debug_insn_before_setloc (pattern, before, INSN_LOCATOR (before));
|
else
|
else
|
return emit_debug_insn_before_noloc (pattern, before);
|
return emit_debug_insn_before_noloc (pattern, before);
|
}
|
}
|
|
|
/* Take X and emit it at the end of the doubly-linked
|
/* Take X and emit it at the end of the doubly-linked
|
INSN list.
|
INSN list.
|
|
|
Returns the last insn emitted. */
|
Returns the last insn emitted. */
|
|
|
rtx
|
rtx
|
emit_insn (rtx x)
|
emit_insn (rtx x)
|
{
|
{
|
rtx last = last_insn;
|
rtx last = last_insn;
|
rtx insn;
|
rtx insn;
|
|
|
if (x == NULL_RTX)
|
if (x == NULL_RTX)
|
return last;
|
return last;
|
|
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case DEBUG_INSN:
|
case DEBUG_INSN:
|
case INSN:
|
case INSN:
|
case JUMP_INSN:
|
case JUMP_INSN:
|
case CALL_INSN:
|
case CALL_INSN:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case BARRIER:
|
case BARRIER:
|
case NOTE:
|
case NOTE:
|
insn = x;
|
insn = x;
|
while (insn)
|
while (insn)
|
{
|
{
|
rtx next = NEXT_INSN (insn);
|
rtx next = NEXT_INSN (insn);
|
add_insn (insn);
|
add_insn (insn);
|
last = insn;
|
last = insn;
|
insn = next;
|
insn = next;
|
}
|
}
|
break;
|
break;
|
|
|
#ifdef ENABLE_RTL_CHECKING
|
#ifdef ENABLE_RTL_CHECKING
|
case SEQUENCE:
|
case SEQUENCE:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
break;
|
break;
|
#endif
|
#endif
|
|
|
default:
|
default:
|
last = make_insn_raw (x);
|
last = make_insn_raw (x);
|
add_insn (last);
|
add_insn (last);
|
break;
|
break;
|
}
|
}
|
|
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Make an insn of code DEBUG_INSN with pattern X
|
/* Make an insn of code DEBUG_INSN with pattern X
|
and add it to the end of the doubly-linked list. */
|
and add it to the end of the doubly-linked list. */
|
|
|
rtx
|
rtx
|
emit_debug_insn (rtx x)
|
emit_debug_insn (rtx x)
|
{
|
{
|
rtx last = last_insn;
|
rtx last = last_insn;
|
rtx insn;
|
rtx insn;
|
|
|
if (x == NULL_RTX)
|
if (x == NULL_RTX)
|
return last;
|
return last;
|
|
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case DEBUG_INSN:
|
case DEBUG_INSN:
|
case INSN:
|
case INSN:
|
case JUMP_INSN:
|
case JUMP_INSN:
|
case CALL_INSN:
|
case CALL_INSN:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case BARRIER:
|
case BARRIER:
|
case NOTE:
|
case NOTE:
|
insn = x;
|
insn = x;
|
while (insn)
|
while (insn)
|
{
|
{
|
rtx next = NEXT_INSN (insn);
|
rtx next = NEXT_INSN (insn);
|
add_insn (insn);
|
add_insn (insn);
|
last = insn;
|
last = insn;
|
insn = next;
|
insn = next;
|
}
|
}
|
break;
|
break;
|
|
|
#ifdef ENABLE_RTL_CHECKING
|
#ifdef ENABLE_RTL_CHECKING
|
case SEQUENCE:
|
case SEQUENCE:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
break;
|
break;
|
#endif
|
#endif
|
|
|
default:
|
default:
|
last = make_debug_insn_raw (x);
|
last = make_debug_insn_raw (x);
|
add_insn (last);
|
add_insn (last);
|
break;
|
break;
|
}
|
}
|
|
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Make an insn of code JUMP_INSN with pattern X
|
/* Make an insn of code JUMP_INSN with pattern X
|
and add it to the end of the doubly-linked list. */
|
and add it to the end of the doubly-linked list. */
|
|
|
rtx
|
rtx
|
emit_jump_insn (rtx x)
|
emit_jump_insn (rtx x)
|
{
|
{
|
rtx last = NULL_RTX, insn;
|
rtx last = NULL_RTX, insn;
|
|
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case DEBUG_INSN:
|
case DEBUG_INSN:
|
case INSN:
|
case INSN:
|
case JUMP_INSN:
|
case JUMP_INSN:
|
case CALL_INSN:
|
case CALL_INSN:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case BARRIER:
|
case BARRIER:
|
case NOTE:
|
case NOTE:
|
insn = x;
|
insn = x;
|
while (insn)
|
while (insn)
|
{
|
{
|
rtx next = NEXT_INSN (insn);
|
rtx next = NEXT_INSN (insn);
|
add_insn (insn);
|
add_insn (insn);
|
last = insn;
|
last = insn;
|
insn = next;
|
insn = next;
|
}
|
}
|
break;
|
break;
|
|
|
#ifdef ENABLE_RTL_CHECKING
|
#ifdef ENABLE_RTL_CHECKING
|
case SEQUENCE:
|
case SEQUENCE:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
break;
|
break;
|
#endif
|
#endif
|
|
|
default:
|
default:
|
last = make_jump_insn_raw (x);
|
last = make_jump_insn_raw (x);
|
add_insn (last);
|
add_insn (last);
|
break;
|
break;
|
}
|
}
|
|
|
return last;
|
return last;
|
}
|
}
|
|
|
/* Make an insn of code CALL_INSN with pattern X
|
/* Make an insn of code CALL_INSN with pattern X
|
and add it to the end of the doubly-linked list. */
|
and add it to the end of the doubly-linked list. */
|
|
|
rtx
|
rtx
|
emit_call_insn (rtx x)
|
emit_call_insn (rtx x)
|
{
|
{
|
rtx insn;
|
rtx insn;
|
|
|
switch (GET_CODE (x))
|
switch (GET_CODE (x))
|
{
|
{
|
case DEBUG_INSN:
|
case DEBUG_INSN:
|
case INSN:
|
case INSN:
|
case JUMP_INSN:
|
case JUMP_INSN:
|
case CALL_INSN:
|
case CALL_INSN:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case BARRIER:
|
case BARRIER:
|
case NOTE:
|
case NOTE:
|
insn = emit_insn (x);
|
insn = emit_insn (x);
|
break;
|
break;
|
|
|
#ifdef ENABLE_RTL_CHECKING
|
#ifdef ENABLE_RTL_CHECKING
|
case SEQUENCE:
|
case SEQUENCE:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
break;
|
break;
|
#endif
|
#endif
|
|
|
default:
|
default:
|
insn = make_call_insn_raw (x);
|
insn = make_call_insn_raw (x);
|
add_insn (insn);
|
add_insn (insn);
|
break;
|
break;
|
}
|
}
|
|
|
return insn;
|
return insn;
|
}
|
}
|
|
|
/* Add the label LABEL to the end of the doubly-linked list. */
|
/* Add the label LABEL to the end of the doubly-linked list. */
|
|
|
rtx
|
rtx
|
emit_label (rtx label)
|
emit_label (rtx label)
|
{
|
{
|
/* This can be called twice for the same label
|
/* This can be called twice for the same label
|
as a result of the confusion that follows a syntax error!
|
as a result of the confusion that follows a syntax error!
|
So make it harmless. */
|
So make it harmless. */
|
if (INSN_UID (label) == 0)
|
if (INSN_UID (label) == 0)
|
{
|
{
|
INSN_UID (label) = cur_insn_uid++;
|
INSN_UID (label) = cur_insn_uid++;
|
add_insn (label);
|
add_insn (label);
|
}
|
}
|
return label;
|
return label;
|
}
|
}
|
|
|
/* Make an insn of code BARRIER
|
/* Make an insn of code BARRIER
|
and add it to the end of the doubly-linked list. */
|
and add it to the end of the doubly-linked list. */
|
|
|
rtx
|
rtx
|
emit_barrier (void)
|
emit_barrier (void)
|
{
|
{
|
rtx barrier = rtx_alloc (BARRIER);
|
rtx barrier = rtx_alloc (BARRIER);
|
INSN_UID (barrier) = cur_insn_uid++;
|
INSN_UID (barrier) = cur_insn_uid++;
|
add_insn (barrier);
|
add_insn (barrier);
|
return barrier;
|
return barrier;
|
}
|
}
|
|
|
/* Emit a copy of note ORIG. */
|
/* Emit a copy of note ORIG. */
|
|
|
rtx
|
rtx
|
emit_note_copy (rtx orig)
|
emit_note_copy (rtx orig)
|
{
|
{
|
rtx note;
|
rtx note;
|
|
|
note = rtx_alloc (NOTE);
|
note = rtx_alloc (NOTE);
|
|
|
INSN_UID (note) = cur_insn_uid++;
|
INSN_UID (note) = cur_insn_uid++;
|
NOTE_DATA (note) = NOTE_DATA (orig);
|
NOTE_DATA (note) = NOTE_DATA (orig);
|
NOTE_KIND (note) = NOTE_KIND (orig);
|
NOTE_KIND (note) = NOTE_KIND (orig);
|
BLOCK_FOR_INSN (note) = NULL;
|
BLOCK_FOR_INSN (note) = NULL;
|
add_insn (note);
|
add_insn (note);
|
|
|
return note;
|
return note;
|
}
|
}
|
|
|
/* Make an insn of code NOTE or type NOTE_NO
|
/* Make an insn of code NOTE or type NOTE_NO
|
and add it to the end of the doubly-linked list. */
|
and add it to the end of the doubly-linked list. */
|
|
|
rtx
|
rtx
|
emit_note (enum insn_note kind)
|
emit_note (enum insn_note kind)
|
{
|
{
|
rtx note;
|
rtx note;
|
|
|
note = rtx_alloc (NOTE);
|
note = rtx_alloc (NOTE);
|
INSN_UID (note) = cur_insn_uid++;
|
INSN_UID (note) = cur_insn_uid++;
|
NOTE_KIND (note) = kind;
|
NOTE_KIND (note) = kind;
|
memset (&NOTE_DATA (note), 0, sizeof (NOTE_DATA (note)));
|
memset (&NOTE_DATA (note), 0, sizeof (NOTE_DATA (note)));
|
BLOCK_FOR_INSN (note) = NULL;
|
BLOCK_FOR_INSN (note) = NULL;
|
add_insn (note);
|
add_insn (note);
|
return note;
|
return note;
|
}
|
}
|
|
|
/* Emit a clobber of lvalue X. */
|
/* Emit a clobber of lvalue X. */
|
|
|
rtx
|
rtx
|
emit_clobber (rtx x)
|
emit_clobber (rtx x)
|
{
|
{
|
/* CONCATs should not appear in the insn stream. */
|
/* CONCATs should not appear in the insn stream. */
|
if (GET_CODE (x) == CONCAT)
|
if (GET_CODE (x) == CONCAT)
|
{
|
{
|
emit_clobber (XEXP (x, 0));
|
emit_clobber (XEXP (x, 0));
|
return emit_clobber (XEXP (x, 1));
|
return emit_clobber (XEXP (x, 1));
|
}
|
}
|
return emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
|
return emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
|
}
|
}
|
|
|
/* Return a sequence of insns to clobber lvalue X. */
|
/* Return a sequence of insns to clobber lvalue X. */
|
|
|
rtx
|
rtx
|
gen_clobber (rtx x)
|
gen_clobber (rtx x)
|
{
|
{
|
rtx seq;
|
rtx seq;
|
|
|
start_sequence ();
|
start_sequence ();
|
emit_clobber (x);
|
emit_clobber (x);
|
seq = get_insns ();
|
seq = get_insns ();
|
end_sequence ();
|
end_sequence ();
|
return seq;
|
return seq;
|
}
|
}
|
|
|
/* Emit a use of rvalue X. */
|
/* Emit a use of rvalue X. */
|
|
|
rtx
|
rtx
|
emit_use (rtx x)
|
emit_use (rtx x)
|
{
|
{
|
/* CONCATs should not appear in the insn stream. */
|
/* CONCATs should not appear in the insn stream. */
|
if (GET_CODE (x) == CONCAT)
|
if (GET_CODE (x) == CONCAT)
|
{
|
{
|
emit_use (XEXP (x, 0));
|
emit_use (XEXP (x, 0));
|
return emit_use (XEXP (x, 1));
|
return emit_use (XEXP (x, 1));
|
}
|
}
|
return emit_insn (gen_rtx_USE (VOIDmode, x));
|
return emit_insn (gen_rtx_USE (VOIDmode, x));
|
}
|
}
|
|
|
/* Return a sequence of insns to use rvalue X. */
|
/* Return a sequence of insns to use rvalue X. */
|
|
|
rtx
|
rtx
|
gen_use (rtx x)
|
gen_use (rtx x)
|
{
|
{
|
rtx seq;
|
rtx seq;
|
|
|
start_sequence ();
|
start_sequence ();
|
emit_use (x);
|
emit_use (x);
|
seq = get_insns ();
|
seq = get_insns ();
|
end_sequence ();
|
end_sequence ();
|
return seq;
|
return seq;
|
}
|
}
|
|
|
/* Cause next statement to emit a line note even if the line number
|
/* Cause next statement to emit a line note even if the line number
|
has not changed. */
|
has not changed. */
|
|
|
void
|
void
|
force_next_line_note (void)
|
force_next_line_note (void)
|
{
|
{
|
last_location = -1;
|
last_location = -1;
|
}
|
}
|
|
|
/* Place a note of KIND on insn INSN with DATUM as the datum. If a
|
/* Place a note of KIND on insn INSN with DATUM as the datum. If a
|
note of this type already exists, remove it first. */
|
note of this type already exists, remove it first. */
|
|
|
rtx
|
rtx
|
set_unique_reg_note (rtx insn, enum reg_note kind, rtx datum)
|
set_unique_reg_note (rtx insn, enum reg_note kind, rtx datum)
|
{
|
{
|
rtx note = find_reg_note (insn, kind, NULL_RTX);
|
rtx note = find_reg_note (insn, kind, NULL_RTX);
|
|
|
switch (kind)
|
switch (kind)
|
{
|
{
|
case REG_EQUAL:
|
case REG_EQUAL:
|
case REG_EQUIV:
|
case REG_EQUIV:
|
/* Don't add REG_EQUAL/REG_EQUIV notes if the insn
|
/* Don't add REG_EQUAL/REG_EQUIV notes if the insn
|
has multiple sets (some callers assume single_set
|
has multiple sets (some callers assume single_set
|
means the insn only has one set, when in fact it
|
means the insn only has one set, when in fact it
|
means the insn only has one * useful * set). */
|
means the insn only has one * useful * set). */
|
if (GET_CODE (PATTERN (insn)) == PARALLEL && multiple_sets (insn))
|
if (GET_CODE (PATTERN (insn)) == PARALLEL && multiple_sets (insn))
|
{
|
{
|
gcc_assert (!note);
|
gcc_assert (!note);
|
return NULL_RTX;
|
return NULL_RTX;
|
}
|
}
|
|
|
/* Don't add ASM_OPERAND REG_EQUAL/REG_EQUIV notes.
|
/* Don't add ASM_OPERAND REG_EQUAL/REG_EQUIV notes.
|
It serves no useful purpose and breaks eliminate_regs. */
|
It serves no useful purpose and breaks eliminate_regs. */
|
if (GET_CODE (datum) == ASM_OPERANDS)
|
if (GET_CODE (datum) == ASM_OPERANDS)
|
return NULL_RTX;
|
return NULL_RTX;
|
|
|
if (note)
|
if (note)
|
{
|
{
|
XEXP (note, 0) = datum;
|
XEXP (note, 0) = datum;
|
df_notes_rescan (insn);
|
df_notes_rescan (insn);
|
return note;
|
return note;
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
if (note)
|
if (note)
|
{
|
{
|
XEXP (note, 0) = datum;
|
XEXP (note, 0) = datum;
|
return note;
|
return note;
|
}
|
}
|
break;
|
break;
|
}
|
}
|
|
|
add_reg_note (insn, kind, datum);
|
add_reg_note (insn, kind, datum);
|
|
|
switch (kind)
|
switch (kind)
|
{
|
{
|
case REG_EQUAL:
|
case REG_EQUAL:
|
case REG_EQUIV:
|
case REG_EQUIV:
|
df_notes_rescan (insn);
|
df_notes_rescan (insn);
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
return REG_NOTES (insn);
|
return REG_NOTES (insn);
|
}
|
}
|
|
|
/* Return an indication of which type of insn should have X as a body.
|
/* Return an indication of which type of insn should have X as a body.
|
The value is CODE_LABEL, INSN, CALL_INSN or JUMP_INSN. */
|
The value is CODE_LABEL, INSN, CALL_INSN or JUMP_INSN. */
|
|
|
static enum rtx_code
|
static enum rtx_code
|
classify_insn (rtx x)
|
classify_insn (rtx x)
|
{
|
{
|
if (LABEL_P (x))
|
if (LABEL_P (x))
|
return CODE_LABEL;
|
return CODE_LABEL;
|
if (GET_CODE (x) == CALL)
|
if (GET_CODE (x) == CALL)
|
return CALL_INSN;
|
return CALL_INSN;
|
if (GET_CODE (x) == RETURN)
|
if (GET_CODE (x) == RETURN)
|
return JUMP_INSN;
|
return JUMP_INSN;
|
if (GET_CODE (x) == SET)
|
if (GET_CODE (x) == SET)
|
{
|
{
|
if (SET_DEST (x) == pc_rtx)
|
if (SET_DEST (x) == pc_rtx)
|
return JUMP_INSN;
|
return JUMP_INSN;
|
else if (GET_CODE (SET_SRC (x)) == CALL)
|
else if (GET_CODE (SET_SRC (x)) == CALL)
|
return CALL_INSN;
|
return CALL_INSN;
|
else
|
else
|
return INSN;
|
return INSN;
|
}
|
}
|
if (GET_CODE (x) == PARALLEL)
|
if (GET_CODE (x) == PARALLEL)
|
{
|
{
|
int j;
|
int j;
|
for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
|
for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
|
if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
|
if (GET_CODE (XVECEXP (x, 0, j)) == CALL)
|
return CALL_INSN;
|
return CALL_INSN;
|
else if (GET_CODE (XVECEXP (x, 0, j)) == SET
|
else if (GET_CODE (XVECEXP (x, 0, j)) == SET
|
&& SET_DEST (XVECEXP (x, 0, j)) == pc_rtx)
|
&& SET_DEST (XVECEXP (x, 0, j)) == pc_rtx)
|
return JUMP_INSN;
|
return JUMP_INSN;
|
else if (GET_CODE (XVECEXP (x, 0, j)) == SET
|
else if (GET_CODE (XVECEXP (x, 0, j)) == SET
|
&& GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
|
&& GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL)
|
return CALL_INSN;
|
return CALL_INSN;
|
}
|
}
|
return INSN;
|
return INSN;
|
}
|
}
|
|
|
/* Emit the rtl pattern X as an appropriate kind of insn.
|
/* Emit the rtl pattern X as an appropriate kind of insn.
|
If X is a label, it is simply added into the insn chain. */
|
If X is a label, it is simply added into the insn chain. */
|
|
|
rtx
|
rtx
|
emit (rtx x)
|
emit (rtx x)
|
{
|
{
|
enum rtx_code code = classify_insn (x);
|
enum rtx_code code = classify_insn (x);
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case CODE_LABEL:
|
case CODE_LABEL:
|
return emit_label (x);
|
return emit_label (x);
|
case INSN:
|
case INSN:
|
return emit_insn (x);
|
return emit_insn (x);
|
case JUMP_INSN:
|
case JUMP_INSN:
|
{
|
{
|
rtx insn = emit_jump_insn (x);
|
rtx insn = emit_jump_insn (x);
|
if (any_uncondjump_p (insn) || GET_CODE (x) == RETURN)
|
if (any_uncondjump_p (insn) || GET_CODE (x) == RETURN)
|
return emit_barrier ();
|
return emit_barrier ();
|
return insn;
|
return insn;
|
}
|
}
|
case CALL_INSN:
|
case CALL_INSN:
|
return emit_call_insn (x);
|
return emit_call_insn (x);
|
case DEBUG_INSN:
|
case DEBUG_INSN:
|
return emit_debug_insn (x);
|
return emit_debug_insn (x);
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Space for free sequence stack entries. */
|
/* Space for free sequence stack entries. */
|
static GTY ((deletable)) struct sequence_stack *free_sequence_stack;
|
static GTY ((deletable)) struct sequence_stack *free_sequence_stack;
|
|
|
/* Begin emitting insns to a sequence. If this sequence will contain
|
/* Begin emitting insns to a sequence. If this sequence will contain
|
something that might cause the compiler to pop arguments to function
|
something that might cause the compiler to pop arguments to function
|
calls (because those pops have previously been deferred; see
|
calls (because those pops have previously been deferred; see
|
INHIBIT_DEFER_POP for more details), use do_pending_stack_adjust
|
INHIBIT_DEFER_POP for more details), use do_pending_stack_adjust
|
before calling this function. That will ensure that the deferred
|
before calling this function. That will ensure that the deferred
|
pops are not accidentally emitted in the middle of this sequence. */
|
pops are not accidentally emitted in the middle of this sequence. */
|
|
|
void
|
void
|
start_sequence (void)
|
start_sequence (void)
|
{
|
{
|
struct sequence_stack *tem;
|
struct sequence_stack *tem;
|
|
|
if (free_sequence_stack != NULL)
|
if (free_sequence_stack != NULL)
|
{
|
{
|
tem = free_sequence_stack;
|
tem = free_sequence_stack;
|
free_sequence_stack = tem->next;
|
free_sequence_stack = tem->next;
|
}
|
}
|
else
|
else
|
tem = GGC_NEW (struct sequence_stack);
|
tem = GGC_NEW (struct sequence_stack);
|
|
|
tem->next = seq_stack;
|
tem->next = seq_stack;
|
tem->first = first_insn;
|
tem->first = first_insn;
|
tem->last = last_insn;
|
tem->last = last_insn;
|
|
|
seq_stack = tem;
|
seq_stack = tem;
|
|
|
first_insn = 0;
|
first_insn = 0;
|
last_insn = 0;
|
last_insn = 0;
|
}
|
}
|
|
|
/* Set up the insn chain starting with FIRST as the current sequence,
|
/* Set up the insn chain starting with FIRST as the current sequence,
|
saving the previously current one. See the documentation for
|
saving the previously current one. See the documentation for
|
start_sequence for more information about how to use this function. */
|
start_sequence for more information about how to use this function. */
|
|
|
void
|
void
|
push_to_sequence (rtx first)
|
push_to_sequence (rtx first)
|
{
|
{
|
rtx last;
|
rtx last;
|
|
|
start_sequence ();
|
start_sequence ();
|
|
|
for (last = first; last && NEXT_INSN (last); last = NEXT_INSN (last));
|
for (last = first; last && NEXT_INSN (last); last = NEXT_INSN (last));
|
|
|
first_insn = first;
|
first_insn = first;
|
last_insn = last;
|
last_insn = last;
|
}
|
}
|
|
|
/* Like push_to_sequence, but take the last insn as an argument to avoid
|
/* Like push_to_sequence, but take the last insn as an argument to avoid
|
looping through the list. */
|
looping through the list. */
|
|
|
void
|
void
|
push_to_sequence2 (rtx first, rtx last)
|
push_to_sequence2 (rtx first, rtx last)
|
{
|
{
|
start_sequence ();
|
start_sequence ();
|
|
|
first_insn = first;
|
first_insn = first;
|
last_insn = last;
|
last_insn = last;
|
}
|
}
|
|
|
/* Set up the outer-level insn chain
|
/* Set up the outer-level insn chain
|
as the current sequence, saving the previously current one. */
|
as the current sequence, saving the previously current one. */
|
|
|
void
|
void
|
push_topmost_sequence (void)
|
push_topmost_sequence (void)
|
{
|
{
|
struct sequence_stack *stack, *top = NULL;
|
struct sequence_stack *stack, *top = NULL;
|
|
|
start_sequence ();
|
start_sequence ();
|
|
|
for (stack = seq_stack; stack; stack = stack->next)
|
for (stack = seq_stack; stack; stack = stack->next)
|
top = stack;
|
top = stack;
|
|
|
first_insn = top->first;
|
first_insn = top->first;
|
last_insn = top->last;
|
last_insn = top->last;
|
}
|
}
|
|
|
/* After emitting to the outer-level insn chain, update the outer-level
|
/* After emitting to the outer-level insn chain, update the outer-level
|
insn chain, and restore the previous saved state. */
|
insn chain, and restore the previous saved state. */
|
|
|
void
|
void
|
pop_topmost_sequence (void)
|
pop_topmost_sequence (void)
|
{
|
{
|
struct sequence_stack *stack, *top = NULL;
|
struct sequence_stack *stack, *top = NULL;
|
|
|
for (stack = seq_stack; stack; stack = stack->next)
|
for (stack = seq_stack; stack; stack = stack->next)
|
top = stack;
|
top = stack;
|
|
|
top->first = first_insn;
|
top->first = first_insn;
|
top->last = last_insn;
|
top->last = last_insn;
|
|
|
end_sequence ();
|
end_sequence ();
|
}
|
}
|
|
|
/* After emitting to a sequence, restore previous saved state.
|
/* After emitting to a sequence, restore previous saved state.
|
|
|
To get the contents of the sequence just made, you must call
|
To get the contents of the sequence just made, you must call
|
`get_insns' *before* calling here.
|
`get_insns' *before* calling here.
|
|
|
If the compiler might have deferred popping arguments while
|
If the compiler might have deferred popping arguments while
|
generating this sequence, and this sequence will not be immediately
|
generating this sequence, and this sequence will not be immediately
|
inserted into the instruction stream, use do_pending_stack_adjust
|
inserted into the instruction stream, use do_pending_stack_adjust
|
before calling get_insns. That will ensure that the deferred
|
before calling get_insns. That will ensure that the deferred
|
pops are inserted into this sequence, and not into some random
|
pops are inserted into this sequence, and not into some random
|
location in the instruction stream. See INHIBIT_DEFER_POP for more
|
location in the instruction stream. See INHIBIT_DEFER_POP for more
|
information about deferred popping of arguments. */
|
information about deferred popping of arguments. */
|
|
|
void
|
void
|
end_sequence (void)
|
end_sequence (void)
|
{
|
{
|
struct sequence_stack *tem = seq_stack;
|
struct sequence_stack *tem = seq_stack;
|
|
|
first_insn = tem->first;
|
first_insn = tem->first;
|
last_insn = tem->last;
|
last_insn = tem->last;
|
seq_stack = tem->next;
|
seq_stack = tem->next;
|
|
|
memset (tem, 0, sizeof (*tem));
|
memset (tem, 0, sizeof (*tem));
|
tem->next = free_sequence_stack;
|
tem->next = free_sequence_stack;
|
free_sequence_stack = tem;
|
free_sequence_stack = tem;
|
}
|
}
|
|
|
/* Return 1 if currently emitting into a sequence. */
|
/* Return 1 if currently emitting into a sequence. */
|
|
|
int
|
int
|
in_sequence_p (void)
|
in_sequence_p (void)
|
{
|
{
|
return seq_stack != 0;
|
return seq_stack != 0;
|
}
|
}
|
|
|
/* Put the various virtual registers into REGNO_REG_RTX. */
|
/* Put the various virtual registers into REGNO_REG_RTX. */
|
|
|
static void
|
static void
|
init_virtual_regs (void)
|
init_virtual_regs (void)
|
{
|
{
|
regno_reg_rtx[VIRTUAL_INCOMING_ARGS_REGNUM] = virtual_incoming_args_rtx;
|
regno_reg_rtx[VIRTUAL_INCOMING_ARGS_REGNUM] = virtual_incoming_args_rtx;
|
regno_reg_rtx[VIRTUAL_STACK_VARS_REGNUM] = virtual_stack_vars_rtx;
|
regno_reg_rtx[VIRTUAL_STACK_VARS_REGNUM] = virtual_stack_vars_rtx;
|
regno_reg_rtx[VIRTUAL_STACK_DYNAMIC_REGNUM] = virtual_stack_dynamic_rtx;
|
regno_reg_rtx[VIRTUAL_STACK_DYNAMIC_REGNUM] = virtual_stack_dynamic_rtx;
|
regno_reg_rtx[VIRTUAL_OUTGOING_ARGS_REGNUM] = virtual_outgoing_args_rtx;
|
regno_reg_rtx[VIRTUAL_OUTGOING_ARGS_REGNUM] = virtual_outgoing_args_rtx;
|
regno_reg_rtx[VIRTUAL_CFA_REGNUM] = virtual_cfa_rtx;
|
regno_reg_rtx[VIRTUAL_CFA_REGNUM] = virtual_cfa_rtx;
|
}
|
}
|
|
|
|
|
/* Used by copy_insn_1 to avoid copying SCRATCHes more than once. */
|
/* Used by copy_insn_1 to avoid copying SCRATCHes more than once. */
|
static rtx copy_insn_scratch_in[MAX_RECOG_OPERANDS];
|
static rtx copy_insn_scratch_in[MAX_RECOG_OPERANDS];
|
static rtx copy_insn_scratch_out[MAX_RECOG_OPERANDS];
|
static rtx copy_insn_scratch_out[MAX_RECOG_OPERANDS];
|
static int copy_insn_n_scratches;
|
static int copy_insn_n_scratches;
|
|
|
/* When an insn is being copied by copy_insn_1, this is nonzero if we have
|
/* When an insn is being copied by copy_insn_1, this is nonzero if we have
|
copied an ASM_OPERANDS.
|
copied an ASM_OPERANDS.
|
In that case, it is the original input-operand vector. */
|
In that case, it is the original input-operand vector. */
|
static rtvec orig_asm_operands_vector;
|
static rtvec orig_asm_operands_vector;
|
|
|
/* When an insn is being copied by copy_insn_1, this is nonzero if we have
|
/* When an insn is being copied by copy_insn_1, this is nonzero if we have
|
copied an ASM_OPERANDS.
|
copied an ASM_OPERANDS.
|
In that case, it is the copied input-operand vector. */
|
In that case, it is the copied input-operand vector. */
|
static rtvec copy_asm_operands_vector;
|
static rtvec copy_asm_operands_vector;
|
|
|
/* Likewise for the constraints vector. */
|
/* Likewise for the constraints vector. */
|
static rtvec orig_asm_constraints_vector;
|
static rtvec orig_asm_constraints_vector;
|
static rtvec copy_asm_constraints_vector;
|
static rtvec copy_asm_constraints_vector;
|
|
|
/* Recursively create a new copy of an rtx for copy_insn.
|
/* Recursively create a new copy of an rtx for copy_insn.
|
This function differs from copy_rtx in that it handles SCRATCHes and
|
This function differs from copy_rtx in that it handles SCRATCHes and
|
ASM_OPERANDs properly.
|
ASM_OPERANDs properly.
|
Normally, this function is not used directly; use copy_insn as front end.
|
Normally, this function is not used directly; use copy_insn as front end.
|
However, you could first copy an insn pattern with copy_insn and then use
|
However, you could first copy an insn pattern with copy_insn and then use
|
this function afterwards to properly copy any REG_NOTEs containing
|
this function afterwards to properly copy any REG_NOTEs containing
|
SCRATCHes. */
|
SCRATCHes. */
|
|
|
rtx
|
rtx
|
copy_insn_1 (rtx orig)
|
copy_insn_1 (rtx orig)
|
{
|
{
|
rtx copy;
|
rtx copy;
|
int i, j;
|
int i, j;
|
RTX_CODE code;
|
RTX_CODE code;
|
const char *format_ptr;
|
const char *format_ptr;
|
|
|
if (orig == NULL)
|
if (orig == NULL)
|
return NULL;
|
return NULL;
|
|
|
code = GET_CODE (orig);
|
code = GET_CODE (orig);
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case REG:
|
case REG:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_FIXED:
|
case CONST_FIXED:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case PC:
|
case PC:
|
case CC0:
|
case CC0:
|
return orig;
|
return orig;
|
case CLOBBER:
|
case CLOBBER:
|
if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER)
|
if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER)
|
return orig;
|
return orig;
|
break;
|
break;
|
|
|
case SCRATCH:
|
case SCRATCH:
|
for (i = 0; i < copy_insn_n_scratches; i++)
|
for (i = 0; i < copy_insn_n_scratches; i++)
|
if (copy_insn_scratch_in[i] == orig)
|
if (copy_insn_scratch_in[i] == orig)
|
return copy_insn_scratch_out[i];
|
return copy_insn_scratch_out[i];
|
break;
|
break;
|
|
|
case CONST:
|
case CONST:
|
if (shared_const_p (orig))
|
if (shared_const_p (orig))
|
return orig;
|
return orig;
|
break;
|
break;
|
|
|
/* A MEM with a constant address is not sharable. The problem is that
|
/* A MEM with a constant address is not sharable. The problem is that
|
the constant address may need to be reloaded. If the mem is shared,
|
the constant address may need to be reloaded. If the mem is shared,
|
then reloading one copy of this mem will cause all copies to appear
|
then reloading one copy of this mem will cause all copies to appear
|
to have been reloaded. */
|
to have been reloaded. */
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* Copy the various flags, fields, and other information. We assume
|
/* Copy the various flags, fields, and other information. We assume
|
that all fields need copying, and then clear the fields that should
|
that all fields need copying, and then clear the fields that should
|
not be copied. That is the sensible default behavior, and forces
|
not be copied. That is the sensible default behavior, and forces
|
us to explicitly document why we are *not* copying a flag. */
|
us to explicitly document why we are *not* copying a flag. */
|
copy = shallow_copy_rtx (orig);
|
copy = shallow_copy_rtx (orig);
|
|
|
/* We do not copy the USED flag, which is used as a mark bit during
|
/* We do not copy the USED flag, which is used as a mark bit during
|
walks over the RTL. */
|
walks over the RTL. */
|
RTX_FLAG (copy, used) = 0;
|
RTX_FLAG (copy, used) = 0;
|
|
|
/* We do not copy JUMP, CALL, or FRAME_RELATED for INSNs. */
|
/* We do not copy JUMP, CALL, or FRAME_RELATED for INSNs. */
|
if (INSN_P (orig))
|
if (INSN_P (orig))
|
{
|
{
|
RTX_FLAG (copy, jump) = 0;
|
RTX_FLAG (copy, jump) = 0;
|
RTX_FLAG (copy, call) = 0;
|
RTX_FLAG (copy, call) = 0;
|
RTX_FLAG (copy, frame_related) = 0;
|
RTX_FLAG (copy, frame_related) = 0;
|
}
|
}
|
|
|
format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
|
format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
|
|
|
for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
|
for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
|
switch (*format_ptr++)
|
switch (*format_ptr++)
|
{
|
{
|
case 'e':
|
case 'e':
|
if (XEXP (orig, i) != NULL)
|
if (XEXP (orig, i) != NULL)
|
XEXP (copy, i) = copy_insn_1 (XEXP (orig, i));
|
XEXP (copy, i) = copy_insn_1 (XEXP (orig, i));
|
break;
|
break;
|
|
|
case 'E':
|
case 'E':
|
case 'V':
|
case 'V':
|
if (XVEC (orig, i) == orig_asm_constraints_vector)
|
if (XVEC (orig, i) == orig_asm_constraints_vector)
|
XVEC (copy, i) = copy_asm_constraints_vector;
|
XVEC (copy, i) = copy_asm_constraints_vector;
|
else if (XVEC (orig, i) == orig_asm_operands_vector)
|
else if (XVEC (orig, i) == orig_asm_operands_vector)
|
XVEC (copy, i) = copy_asm_operands_vector;
|
XVEC (copy, i) = copy_asm_operands_vector;
|
else if (XVEC (orig, i) != NULL)
|
else if (XVEC (orig, i) != NULL)
|
{
|
{
|
XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
|
XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
|
for (j = 0; j < XVECLEN (copy, i); j++)
|
for (j = 0; j < XVECLEN (copy, i); j++)
|
XVECEXP (copy, i, j) = copy_insn_1 (XVECEXP (orig, i, j));
|
XVECEXP (copy, i, j) = copy_insn_1 (XVECEXP (orig, i, j));
|
}
|
}
|
break;
|
break;
|
|
|
case 't':
|
case 't':
|
case 'w':
|
case 'w':
|
case 'i':
|
case 'i':
|
case 's':
|
case 's':
|
case 'S':
|
case 'S':
|
case 'u':
|
case 'u':
|
case '0':
|
case '0':
|
/* These are left unchanged. */
|
/* These are left unchanged. */
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
if (code == SCRATCH)
|
if (code == SCRATCH)
|
{
|
{
|
i = copy_insn_n_scratches++;
|
i = copy_insn_n_scratches++;
|
gcc_assert (i < MAX_RECOG_OPERANDS);
|
gcc_assert (i < MAX_RECOG_OPERANDS);
|
copy_insn_scratch_in[i] = orig;
|
copy_insn_scratch_in[i] = orig;
|
copy_insn_scratch_out[i] = copy;
|
copy_insn_scratch_out[i] = copy;
|
}
|
}
|
else if (code == ASM_OPERANDS)
|
else if (code == ASM_OPERANDS)
|
{
|
{
|
orig_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (orig);
|
orig_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (orig);
|
copy_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (copy);
|
copy_asm_operands_vector = ASM_OPERANDS_INPUT_VEC (copy);
|
orig_asm_constraints_vector = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (orig);
|
orig_asm_constraints_vector = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (orig);
|
copy_asm_constraints_vector = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy);
|
copy_asm_constraints_vector = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (copy);
|
}
|
}
|
|
|
return copy;
|
return copy;
|
}
|
}
|
|
|
/* Create a new copy of an rtx.
|
/* Create a new copy of an rtx.
|
This function differs from copy_rtx in that it handles SCRATCHes and
|
This function differs from copy_rtx in that it handles SCRATCHes and
|
ASM_OPERANDs properly.
|
ASM_OPERANDs properly.
|
INSN doesn't really have to be a full INSN; it could be just the
|
INSN doesn't really have to be a full INSN; it could be just the
|
pattern. */
|
pattern. */
|
rtx
|
rtx
|
copy_insn (rtx insn)
|
copy_insn (rtx insn)
|
{
|
{
|
copy_insn_n_scratches = 0;
|
copy_insn_n_scratches = 0;
|
orig_asm_operands_vector = 0;
|
orig_asm_operands_vector = 0;
|
orig_asm_constraints_vector = 0;
|
orig_asm_constraints_vector = 0;
|
copy_asm_operands_vector = 0;
|
copy_asm_operands_vector = 0;
|
copy_asm_constraints_vector = 0;
|
copy_asm_constraints_vector = 0;
|
return copy_insn_1 (insn);
|
return copy_insn_1 (insn);
|
}
|
}
|
|
|
/* Initialize data structures and variables in this file
|
/* Initialize data structures and variables in this file
|
before generating rtl for each function. */
|
before generating rtl for each function. */
|
|
|
void
|
void
|
init_emit (void)
|
init_emit (void)
|
{
|
{
|
first_insn = NULL;
|
first_insn = NULL;
|
last_insn = NULL;
|
last_insn = NULL;
|
if (MIN_NONDEBUG_INSN_UID)
|
if (MIN_NONDEBUG_INSN_UID)
|
cur_insn_uid = MIN_NONDEBUG_INSN_UID;
|
cur_insn_uid = MIN_NONDEBUG_INSN_UID;
|
else
|
else
|
cur_insn_uid = 1;
|
cur_insn_uid = 1;
|
cur_debug_insn_uid = 1;
|
cur_debug_insn_uid = 1;
|
reg_rtx_no = LAST_VIRTUAL_REGISTER + 1;
|
reg_rtx_no = LAST_VIRTUAL_REGISTER + 1;
|
last_location = UNKNOWN_LOCATION;
|
last_location = UNKNOWN_LOCATION;
|
first_label_num = label_num;
|
first_label_num = label_num;
|
seq_stack = NULL;
|
seq_stack = NULL;
|
|
|
/* Init the tables that describe all the pseudo regs. */
|
/* Init the tables that describe all the pseudo regs. */
|
|
|
crtl->emit.regno_pointer_align_length = LAST_VIRTUAL_REGISTER + 101;
|
crtl->emit.regno_pointer_align_length = LAST_VIRTUAL_REGISTER + 101;
|
|
|
crtl->emit.regno_pointer_align
|
crtl->emit.regno_pointer_align
|
= XCNEWVEC (unsigned char, crtl->emit.regno_pointer_align_length);
|
= XCNEWVEC (unsigned char, crtl->emit.regno_pointer_align_length);
|
|
|
regno_reg_rtx
|
regno_reg_rtx
|
= GGC_NEWVEC (rtx, crtl->emit.regno_pointer_align_length);
|
= GGC_NEWVEC (rtx, crtl->emit.regno_pointer_align_length);
|
|
|
/* Put copies of all the hard registers into regno_reg_rtx. */
|
/* Put copies of all the hard registers into regno_reg_rtx. */
|
memcpy (regno_reg_rtx,
|
memcpy (regno_reg_rtx,
|
static_regno_reg_rtx,
|
static_regno_reg_rtx,
|
FIRST_PSEUDO_REGISTER * sizeof (rtx));
|
FIRST_PSEUDO_REGISTER * sizeof (rtx));
|
|
|
/* Put copies of all the virtual register rtx into regno_reg_rtx. */
|
/* Put copies of all the virtual register rtx into regno_reg_rtx. */
|
init_virtual_regs ();
|
init_virtual_regs ();
|
|
|
/* Indicate that the virtual registers and stack locations are
|
/* Indicate that the virtual registers and stack locations are
|
all pointers. */
|
all pointers. */
|
REG_POINTER (stack_pointer_rtx) = 1;
|
REG_POINTER (stack_pointer_rtx) = 1;
|
REG_POINTER (frame_pointer_rtx) = 1;
|
REG_POINTER (frame_pointer_rtx) = 1;
|
REG_POINTER (hard_frame_pointer_rtx) = 1;
|
REG_POINTER (hard_frame_pointer_rtx) = 1;
|
REG_POINTER (arg_pointer_rtx) = 1;
|
REG_POINTER (arg_pointer_rtx) = 1;
|
|
|
REG_POINTER (virtual_incoming_args_rtx) = 1;
|
REG_POINTER (virtual_incoming_args_rtx) = 1;
|
REG_POINTER (virtual_stack_vars_rtx) = 1;
|
REG_POINTER (virtual_stack_vars_rtx) = 1;
|
REG_POINTER (virtual_stack_dynamic_rtx) = 1;
|
REG_POINTER (virtual_stack_dynamic_rtx) = 1;
|
REG_POINTER (virtual_outgoing_args_rtx) = 1;
|
REG_POINTER (virtual_outgoing_args_rtx) = 1;
|
REG_POINTER (virtual_cfa_rtx) = 1;
|
REG_POINTER (virtual_cfa_rtx) = 1;
|
|
|
#ifdef STACK_BOUNDARY
|
#ifdef STACK_BOUNDARY
|
REGNO_POINTER_ALIGN (STACK_POINTER_REGNUM) = STACK_BOUNDARY;
|
REGNO_POINTER_ALIGN (STACK_POINTER_REGNUM) = STACK_BOUNDARY;
|
REGNO_POINTER_ALIGN (FRAME_POINTER_REGNUM) = STACK_BOUNDARY;
|
REGNO_POINTER_ALIGN (FRAME_POINTER_REGNUM) = STACK_BOUNDARY;
|
REGNO_POINTER_ALIGN (HARD_FRAME_POINTER_REGNUM) = STACK_BOUNDARY;
|
REGNO_POINTER_ALIGN (HARD_FRAME_POINTER_REGNUM) = STACK_BOUNDARY;
|
REGNO_POINTER_ALIGN (ARG_POINTER_REGNUM) = STACK_BOUNDARY;
|
REGNO_POINTER_ALIGN (ARG_POINTER_REGNUM) = STACK_BOUNDARY;
|
|
|
REGNO_POINTER_ALIGN (VIRTUAL_INCOMING_ARGS_REGNUM) = STACK_BOUNDARY;
|
REGNO_POINTER_ALIGN (VIRTUAL_INCOMING_ARGS_REGNUM) = STACK_BOUNDARY;
|
REGNO_POINTER_ALIGN (VIRTUAL_STACK_VARS_REGNUM) = STACK_BOUNDARY;
|
REGNO_POINTER_ALIGN (VIRTUAL_STACK_VARS_REGNUM) = STACK_BOUNDARY;
|
REGNO_POINTER_ALIGN (VIRTUAL_STACK_DYNAMIC_REGNUM) = STACK_BOUNDARY;
|
REGNO_POINTER_ALIGN (VIRTUAL_STACK_DYNAMIC_REGNUM) = STACK_BOUNDARY;
|
REGNO_POINTER_ALIGN (VIRTUAL_OUTGOING_ARGS_REGNUM) = STACK_BOUNDARY;
|
REGNO_POINTER_ALIGN (VIRTUAL_OUTGOING_ARGS_REGNUM) = STACK_BOUNDARY;
|
REGNO_POINTER_ALIGN (VIRTUAL_CFA_REGNUM) = BITS_PER_WORD;
|
REGNO_POINTER_ALIGN (VIRTUAL_CFA_REGNUM) = BITS_PER_WORD;
|
#endif
|
#endif
|
|
|
#ifdef INIT_EXPANDERS
|
#ifdef INIT_EXPANDERS
|
INIT_EXPANDERS;
|
INIT_EXPANDERS;
|
#endif
|
#endif
|
}
|
}
|
|
|
/* Generate a vector constant for mode MODE and constant value CONSTANT. */
|
/* Generate a vector constant for mode MODE and constant value CONSTANT. */
|
|
|
static rtx
|
static rtx
|
gen_const_vector (enum machine_mode mode, int constant)
|
gen_const_vector (enum machine_mode mode, int constant)
|
{
|
{
|
rtx tem;
|
rtx tem;
|
rtvec v;
|
rtvec v;
|
int units, i;
|
int units, i;
|
enum machine_mode inner;
|
enum machine_mode inner;
|
|
|
units = GET_MODE_NUNITS (mode);
|
units = GET_MODE_NUNITS (mode);
|
inner = GET_MODE_INNER (mode);
|
inner = GET_MODE_INNER (mode);
|
|
|
gcc_assert (!DECIMAL_FLOAT_MODE_P (inner));
|
gcc_assert (!DECIMAL_FLOAT_MODE_P (inner));
|
|
|
v = rtvec_alloc (units);
|
v = rtvec_alloc (units);
|
|
|
/* We need to call this function after we set the scalar const_tiny_rtx
|
/* We need to call this function after we set the scalar const_tiny_rtx
|
entries. */
|
entries. */
|
gcc_assert (const_tiny_rtx[constant][(int) inner]);
|
gcc_assert (const_tiny_rtx[constant][(int) inner]);
|
|
|
for (i = 0; i < units; ++i)
|
for (i = 0; i < units; ++i)
|
RTVEC_ELT (v, i) = const_tiny_rtx[constant][(int) inner];
|
RTVEC_ELT (v, i) = const_tiny_rtx[constant][(int) inner];
|
|
|
tem = gen_rtx_raw_CONST_VECTOR (mode, v);
|
tem = gen_rtx_raw_CONST_VECTOR (mode, v);
|
return tem;
|
return tem;
|
}
|
}
|
|
|
/* Generate a vector like gen_rtx_raw_CONST_VEC, but use the zero vector when
|
/* Generate a vector like gen_rtx_raw_CONST_VEC, but use the zero vector when
|
all elements are zero, and the one vector when all elements are one. */
|
all elements are zero, and the one vector when all elements are one. */
|
rtx
|
rtx
|
gen_rtx_CONST_VECTOR (enum machine_mode mode, rtvec v)
|
gen_rtx_CONST_VECTOR (enum machine_mode mode, rtvec v)
|
{
|
{
|
enum machine_mode inner = GET_MODE_INNER (mode);
|
enum machine_mode inner = GET_MODE_INNER (mode);
|
int nunits = GET_MODE_NUNITS (mode);
|
int nunits = GET_MODE_NUNITS (mode);
|
rtx x;
|
rtx x;
|
int i;
|
int i;
|
|
|
/* Check to see if all of the elements have the same value. */
|
/* Check to see if all of the elements have the same value. */
|
x = RTVEC_ELT (v, nunits - 1);
|
x = RTVEC_ELT (v, nunits - 1);
|
for (i = nunits - 2; i >= 0; i--)
|
for (i = nunits - 2; i >= 0; i--)
|
if (RTVEC_ELT (v, i) != x)
|
if (RTVEC_ELT (v, i) != x)
|
break;
|
break;
|
|
|
/* If the values are all the same, check to see if we can use one of the
|
/* If the values are all the same, check to see if we can use one of the
|
standard constant vectors. */
|
standard constant vectors. */
|
if (i == -1)
|
if (i == -1)
|
{
|
{
|
if (x == CONST0_RTX (inner))
|
if (x == CONST0_RTX (inner))
|
return CONST0_RTX (mode);
|
return CONST0_RTX (mode);
|
else if (x == CONST1_RTX (inner))
|
else if (x == CONST1_RTX (inner))
|
return CONST1_RTX (mode);
|
return CONST1_RTX (mode);
|
}
|
}
|
|
|
return gen_rtx_raw_CONST_VECTOR (mode, v);
|
return gen_rtx_raw_CONST_VECTOR (mode, v);
|
}
|
}
|
|
|
/* Initialise global register information required by all functions. */
|
/* Initialise global register information required by all functions. */
|
|
|
void
|
void
|
init_emit_regs (void)
|
init_emit_regs (void)
|
{
|
{
|
int i;
|
int i;
|
|
|
/* Reset register attributes */
|
/* Reset register attributes */
|
htab_empty (reg_attrs_htab);
|
htab_empty (reg_attrs_htab);
|
|
|
/* We need reg_raw_mode, so initialize the modes now. */
|
/* We need reg_raw_mode, so initialize the modes now. */
|
init_reg_modes_target ();
|
init_reg_modes_target ();
|
|
|
/* Assign register numbers to the globally defined register rtx. */
|
/* Assign register numbers to the globally defined register rtx. */
|
pc_rtx = gen_rtx_PC (VOIDmode);
|
pc_rtx = gen_rtx_PC (VOIDmode);
|
cc0_rtx = gen_rtx_CC0 (VOIDmode);
|
cc0_rtx = gen_rtx_CC0 (VOIDmode);
|
stack_pointer_rtx = gen_raw_REG (Pmode, STACK_POINTER_REGNUM);
|
stack_pointer_rtx = gen_raw_REG (Pmode, STACK_POINTER_REGNUM);
|
frame_pointer_rtx = gen_raw_REG (Pmode, FRAME_POINTER_REGNUM);
|
frame_pointer_rtx = gen_raw_REG (Pmode, FRAME_POINTER_REGNUM);
|
hard_frame_pointer_rtx = gen_raw_REG (Pmode, HARD_FRAME_POINTER_REGNUM);
|
hard_frame_pointer_rtx = gen_raw_REG (Pmode, HARD_FRAME_POINTER_REGNUM);
|
arg_pointer_rtx = gen_raw_REG (Pmode, ARG_POINTER_REGNUM);
|
arg_pointer_rtx = gen_raw_REG (Pmode, ARG_POINTER_REGNUM);
|
virtual_incoming_args_rtx =
|
virtual_incoming_args_rtx =
|
gen_raw_REG (Pmode, VIRTUAL_INCOMING_ARGS_REGNUM);
|
gen_raw_REG (Pmode, VIRTUAL_INCOMING_ARGS_REGNUM);
|
virtual_stack_vars_rtx =
|
virtual_stack_vars_rtx =
|
gen_raw_REG (Pmode, VIRTUAL_STACK_VARS_REGNUM);
|
gen_raw_REG (Pmode, VIRTUAL_STACK_VARS_REGNUM);
|
virtual_stack_dynamic_rtx =
|
virtual_stack_dynamic_rtx =
|
gen_raw_REG (Pmode, VIRTUAL_STACK_DYNAMIC_REGNUM);
|
gen_raw_REG (Pmode, VIRTUAL_STACK_DYNAMIC_REGNUM);
|
virtual_outgoing_args_rtx =
|
virtual_outgoing_args_rtx =
|
gen_raw_REG (Pmode, VIRTUAL_OUTGOING_ARGS_REGNUM);
|
gen_raw_REG (Pmode, VIRTUAL_OUTGOING_ARGS_REGNUM);
|
virtual_cfa_rtx = gen_raw_REG (Pmode, VIRTUAL_CFA_REGNUM);
|
virtual_cfa_rtx = gen_raw_REG (Pmode, VIRTUAL_CFA_REGNUM);
|
|
|
/* Initialize RTL for commonly used hard registers. These are
|
/* Initialize RTL for commonly used hard registers. These are
|
copied into regno_reg_rtx as we begin to compile each function. */
|
copied into regno_reg_rtx as we begin to compile each function. */
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
static_regno_reg_rtx[i] = gen_raw_REG (reg_raw_mode[i], i);
|
static_regno_reg_rtx[i] = gen_raw_REG (reg_raw_mode[i], i);
|
|
|
#ifdef RETURN_ADDRESS_POINTER_REGNUM
|
#ifdef RETURN_ADDRESS_POINTER_REGNUM
|
return_address_pointer_rtx
|
return_address_pointer_rtx
|
= gen_raw_REG (Pmode, RETURN_ADDRESS_POINTER_REGNUM);
|
= gen_raw_REG (Pmode, RETURN_ADDRESS_POINTER_REGNUM);
|
#endif
|
#endif
|
|
|
if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
|
if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
|
pic_offset_table_rtx = gen_raw_REG (Pmode, PIC_OFFSET_TABLE_REGNUM);
|
pic_offset_table_rtx = gen_raw_REG (Pmode, PIC_OFFSET_TABLE_REGNUM);
|
else
|
else
|
pic_offset_table_rtx = NULL_RTX;
|
pic_offset_table_rtx = NULL_RTX;
|
}
|
}
|
|
|
/* Create some permanent unique rtl objects shared between all functions. */
|
/* Create some permanent unique rtl objects shared between all functions. */
|
|
|
void
|
void
|
init_emit_once (void)
|
init_emit_once (void)
|
{
|
{
|
int i;
|
int i;
|
enum machine_mode mode;
|
enum machine_mode mode;
|
enum machine_mode double_mode;
|
enum machine_mode double_mode;
|
|
|
/* Initialize the CONST_INT, CONST_DOUBLE, CONST_FIXED, and memory attribute
|
/* Initialize the CONST_INT, CONST_DOUBLE, CONST_FIXED, and memory attribute
|
hash tables. */
|
hash tables. */
|
const_int_htab = htab_create_ggc (37, const_int_htab_hash,
|
const_int_htab = htab_create_ggc (37, const_int_htab_hash,
|
const_int_htab_eq, NULL);
|
const_int_htab_eq, NULL);
|
|
|
const_double_htab = htab_create_ggc (37, const_double_htab_hash,
|
const_double_htab = htab_create_ggc (37, const_double_htab_hash,
|
const_double_htab_eq, NULL);
|
const_double_htab_eq, NULL);
|
|
|
const_fixed_htab = htab_create_ggc (37, const_fixed_htab_hash,
|
const_fixed_htab = htab_create_ggc (37, const_fixed_htab_hash,
|
const_fixed_htab_eq, NULL);
|
const_fixed_htab_eq, NULL);
|
|
|
mem_attrs_htab = htab_create_ggc (37, mem_attrs_htab_hash,
|
mem_attrs_htab = htab_create_ggc (37, mem_attrs_htab_hash,
|
mem_attrs_htab_eq, NULL);
|
mem_attrs_htab_eq, NULL);
|
reg_attrs_htab = htab_create_ggc (37, reg_attrs_htab_hash,
|
reg_attrs_htab = htab_create_ggc (37, reg_attrs_htab_hash,
|
reg_attrs_htab_eq, NULL);
|
reg_attrs_htab_eq, NULL);
|
|
|
/* Compute the word and byte modes. */
|
/* Compute the word and byte modes. */
|
|
|
byte_mode = VOIDmode;
|
byte_mode = VOIDmode;
|
word_mode = VOIDmode;
|
word_mode = VOIDmode;
|
double_mode = VOIDmode;
|
double_mode = VOIDmode;
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
{
|
{
|
if (GET_MODE_BITSIZE (mode) == BITS_PER_UNIT
|
if (GET_MODE_BITSIZE (mode) == BITS_PER_UNIT
|
&& byte_mode == VOIDmode)
|
&& byte_mode == VOIDmode)
|
byte_mode = mode;
|
byte_mode = mode;
|
|
|
if (GET_MODE_BITSIZE (mode) == BITS_PER_WORD
|
if (GET_MODE_BITSIZE (mode) == BITS_PER_WORD
|
&& word_mode == VOIDmode)
|
&& word_mode == VOIDmode)
|
word_mode = mode;
|
word_mode = mode;
|
}
|
}
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
{
|
{
|
if (GET_MODE_BITSIZE (mode) == DOUBLE_TYPE_SIZE
|
if (GET_MODE_BITSIZE (mode) == DOUBLE_TYPE_SIZE
|
&& double_mode == VOIDmode)
|
&& double_mode == VOIDmode)
|
double_mode = mode;
|
double_mode = mode;
|
}
|
}
|
|
|
ptr_mode = mode_for_size (POINTER_SIZE, GET_MODE_CLASS (Pmode), 0);
|
ptr_mode = mode_for_size (POINTER_SIZE, GET_MODE_CLASS (Pmode), 0);
|
|
|
#ifdef INIT_EXPANDERS
|
#ifdef INIT_EXPANDERS
|
/* This is to initialize {init|mark|free}_machine_status before the first
|
/* This is to initialize {init|mark|free}_machine_status before the first
|
call to push_function_context_to. This is needed by the Chill front
|
call to push_function_context_to. This is needed by the Chill front
|
end which calls push_function_context_to before the first call to
|
end which calls push_function_context_to before the first call to
|
init_function_start. */
|
init_function_start. */
|
INIT_EXPANDERS;
|
INIT_EXPANDERS;
|
#endif
|
#endif
|
|
|
/* Create the unique rtx's for certain rtx codes and operand values. */
|
/* Create the unique rtx's for certain rtx codes and operand values. */
|
|
|
/* Don't use gen_rtx_CONST_INT here since gen_rtx_CONST_INT in this case
|
/* Don't use gen_rtx_CONST_INT here since gen_rtx_CONST_INT in this case
|
tries to use these variables. */
|
tries to use these variables. */
|
for (i = - MAX_SAVED_CONST_INT; i <= MAX_SAVED_CONST_INT; i++)
|
for (i = - MAX_SAVED_CONST_INT; i <= MAX_SAVED_CONST_INT; i++)
|
const_int_rtx[i + MAX_SAVED_CONST_INT] =
|
const_int_rtx[i + MAX_SAVED_CONST_INT] =
|
gen_rtx_raw_CONST_INT (VOIDmode, (HOST_WIDE_INT) i);
|
gen_rtx_raw_CONST_INT (VOIDmode, (HOST_WIDE_INT) i);
|
|
|
if (STORE_FLAG_VALUE >= - MAX_SAVED_CONST_INT
|
if (STORE_FLAG_VALUE >= - MAX_SAVED_CONST_INT
|
&& STORE_FLAG_VALUE <= MAX_SAVED_CONST_INT)
|
&& STORE_FLAG_VALUE <= MAX_SAVED_CONST_INT)
|
const_true_rtx = const_int_rtx[STORE_FLAG_VALUE + MAX_SAVED_CONST_INT];
|
const_true_rtx = const_int_rtx[STORE_FLAG_VALUE + MAX_SAVED_CONST_INT];
|
else
|
else
|
const_true_rtx = gen_rtx_CONST_INT (VOIDmode, STORE_FLAG_VALUE);
|
const_true_rtx = gen_rtx_CONST_INT (VOIDmode, STORE_FLAG_VALUE);
|
|
|
REAL_VALUE_FROM_INT (dconst0, 0, 0, double_mode);
|
REAL_VALUE_FROM_INT (dconst0, 0, 0, double_mode);
|
REAL_VALUE_FROM_INT (dconst1, 1, 0, double_mode);
|
REAL_VALUE_FROM_INT (dconst1, 1, 0, double_mode);
|
REAL_VALUE_FROM_INT (dconst2, 2, 0, double_mode);
|
REAL_VALUE_FROM_INT (dconst2, 2, 0, double_mode);
|
|
|
dconstm1 = dconst1;
|
dconstm1 = dconst1;
|
dconstm1.sign = 1;
|
dconstm1.sign = 1;
|
|
|
dconsthalf = dconst1;
|
dconsthalf = dconst1;
|
SET_REAL_EXP (&dconsthalf, REAL_EXP (&dconsthalf) - 1);
|
SET_REAL_EXP (&dconsthalf, REAL_EXP (&dconsthalf) - 1);
|
|
|
for (i = 0; i < (int) ARRAY_SIZE (const_tiny_rtx); i++)
|
for (i = 0; i < (int) ARRAY_SIZE (const_tiny_rtx); i++)
|
{
|
{
|
const REAL_VALUE_TYPE *const r =
|
const REAL_VALUE_TYPE *const r =
|
(i == 0 ? &dconst0 : i == 1 ? &dconst1 : &dconst2);
|
(i == 0 ? &dconst0 : i == 1 ? &dconst1 : &dconst2);
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
const_tiny_rtx[i][(int) mode] =
|
const_tiny_rtx[i][(int) mode] =
|
CONST_DOUBLE_FROM_REAL_VALUE (*r, mode);
|
CONST_DOUBLE_FROM_REAL_VALUE (*r, mode);
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_DECIMAL_FLOAT);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_DECIMAL_FLOAT);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
const_tiny_rtx[i][(int) mode] =
|
const_tiny_rtx[i][(int) mode] =
|
CONST_DOUBLE_FROM_REAL_VALUE (*r, mode);
|
CONST_DOUBLE_FROM_REAL_VALUE (*r, mode);
|
|
|
const_tiny_rtx[i][(int) VOIDmode] = GEN_INT (i);
|
const_tiny_rtx[i][(int) VOIDmode] = GEN_INT (i);
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
const_tiny_rtx[i][(int) mode] = GEN_INT (i);
|
const_tiny_rtx[i][(int) mode] = GEN_INT (i);
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_PARTIAL_INT);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_PARTIAL_INT);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
const_tiny_rtx[i][(int) mode] = GEN_INT (i);
|
const_tiny_rtx[i][(int) mode] = GEN_INT (i);
|
}
|
}
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_COMPLEX_INT);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_COMPLEX_INT);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
{
|
{
|
rtx inner = const_tiny_rtx[0][(int)GET_MODE_INNER (mode)];
|
rtx inner = const_tiny_rtx[0][(int)GET_MODE_INNER (mode)];
|
const_tiny_rtx[0][(int) mode] = gen_rtx_CONCAT (mode, inner, inner);
|
const_tiny_rtx[0][(int) mode] = gen_rtx_CONCAT (mode, inner, inner);
|
}
|
}
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_COMPLEX_FLOAT);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_COMPLEX_FLOAT);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
{
|
{
|
rtx inner = const_tiny_rtx[0][(int)GET_MODE_INNER (mode)];
|
rtx inner = const_tiny_rtx[0][(int)GET_MODE_INNER (mode)];
|
const_tiny_rtx[0][(int) mode] = gen_rtx_CONCAT (mode, inner, inner);
|
const_tiny_rtx[0][(int) mode] = gen_rtx_CONCAT (mode, inner, inner);
|
}
|
}
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_INT);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_INT);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
{
|
{
|
const_tiny_rtx[0][(int) mode] = gen_const_vector (mode, 0);
|
const_tiny_rtx[0][(int) mode] = gen_const_vector (mode, 0);
|
const_tiny_rtx[1][(int) mode] = gen_const_vector (mode, 1);
|
const_tiny_rtx[1][(int) mode] = gen_const_vector (mode, 1);
|
}
|
}
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FLOAT);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FLOAT);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
{
|
{
|
const_tiny_rtx[0][(int) mode] = gen_const_vector (mode, 0);
|
const_tiny_rtx[0][(int) mode] = gen_const_vector (mode, 0);
|
const_tiny_rtx[1][(int) mode] = gen_const_vector (mode, 1);
|
const_tiny_rtx[1][(int) mode] = gen_const_vector (mode, 1);
|
}
|
}
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_FRACT);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_FRACT);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
{
|
{
|
FCONST0(mode).data.high = 0;
|
FCONST0(mode).data.high = 0;
|
FCONST0(mode).data.low = 0;
|
FCONST0(mode).data.low = 0;
|
FCONST0(mode).mode = mode;
|
FCONST0(mode).mode = mode;
|
const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
|
const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
|
FCONST0 (mode), mode);
|
FCONST0 (mode), mode);
|
}
|
}
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_UFRACT);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_UFRACT);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
{
|
{
|
FCONST0(mode).data.high = 0;
|
FCONST0(mode).data.high = 0;
|
FCONST0(mode).data.low = 0;
|
FCONST0(mode).data.low = 0;
|
FCONST0(mode).mode = mode;
|
FCONST0(mode).mode = mode;
|
const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
|
const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
|
FCONST0 (mode), mode);
|
FCONST0 (mode), mode);
|
}
|
}
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_ACCUM);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_ACCUM);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
{
|
{
|
FCONST0(mode).data.high = 0;
|
FCONST0(mode).data.high = 0;
|
FCONST0(mode).data.low = 0;
|
FCONST0(mode).data.low = 0;
|
FCONST0(mode).mode = mode;
|
FCONST0(mode).mode = mode;
|
const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
|
const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
|
FCONST0 (mode), mode);
|
FCONST0 (mode), mode);
|
|
|
/* We store the value 1. */
|
/* We store the value 1. */
|
FCONST1(mode).data.high = 0;
|
FCONST1(mode).data.high = 0;
|
FCONST1(mode).data.low = 0;
|
FCONST1(mode).data.low = 0;
|
FCONST1(mode).mode = mode;
|
FCONST1(mode).mode = mode;
|
lshift_double (1, 0, GET_MODE_FBIT (mode),
|
lshift_double (1, 0, GET_MODE_FBIT (mode),
|
2 * HOST_BITS_PER_WIDE_INT,
|
2 * HOST_BITS_PER_WIDE_INT,
|
&FCONST1(mode).data.low,
|
&FCONST1(mode).data.low,
|
&FCONST1(mode).data.high,
|
&FCONST1(mode).data.high,
|
SIGNED_FIXED_POINT_MODE_P (mode));
|
SIGNED_FIXED_POINT_MODE_P (mode));
|
const_tiny_rtx[1][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
|
const_tiny_rtx[1][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
|
FCONST1 (mode), mode);
|
FCONST1 (mode), mode);
|
}
|
}
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_UACCUM);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_UACCUM);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
{
|
{
|
FCONST0(mode).data.high = 0;
|
FCONST0(mode).data.high = 0;
|
FCONST0(mode).data.low = 0;
|
FCONST0(mode).data.low = 0;
|
FCONST0(mode).mode = mode;
|
FCONST0(mode).mode = mode;
|
const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
|
const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
|
FCONST0 (mode), mode);
|
FCONST0 (mode), mode);
|
|
|
/* We store the value 1. */
|
/* We store the value 1. */
|
FCONST1(mode).data.high = 0;
|
FCONST1(mode).data.high = 0;
|
FCONST1(mode).data.low = 0;
|
FCONST1(mode).data.low = 0;
|
FCONST1(mode).mode = mode;
|
FCONST1(mode).mode = mode;
|
lshift_double (1, 0, GET_MODE_FBIT (mode),
|
lshift_double (1, 0, GET_MODE_FBIT (mode),
|
2 * HOST_BITS_PER_WIDE_INT,
|
2 * HOST_BITS_PER_WIDE_INT,
|
&FCONST1(mode).data.low,
|
&FCONST1(mode).data.low,
|
&FCONST1(mode).data.high,
|
&FCONST1(mode).data.high,
|
SIGNED_FIXED_POINT_MODE_P (mode));
|
SIGNED_FIXED_POINT_MODE_P (mode));
|
const_tiny_rtx[1][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
|
const_tiny_rtx[1][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
|
FCONST1 (mode), mode);
|
FCONST1 (mode), mode);
|
}
|
}
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FRACT);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FRACT);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
{
|
{
|
const_tiny_rtx[0][(int) mode] = gen_const_vector (mode, 0);
|
const_tiny_rtx[0][(int) mode] = gen_const_vector (mode, 0);
|
}
|
}
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_UFRACT);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_UFRACT);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
{
|
{
|
const_tiny_rtx[0][(int) mode] = gen_const_vector (mode, 0);
|
const_tiny_rtx[0][(int) mode] = gen_const_vector (mode, 0);
|
}
|
}
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_ACCUM);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_ACCUM);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
{
|
{
|
const_tiny_rtx[0][(int) mode] = gen_const_vector (mode, 0);
|
const_tiny_rtx[0][(int) mode] = gen_const_vector (mode, 0);
|
const_tiny_rtx[1][(int) mode] = gen_const_vector (mode, 1);
|
const_tiny_rtx[1][(int) mode] = gen_const_vector (mode, 1);
|
}
|
}
|
|
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_UACCUM);
|
for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_UACCUM);
|
mode != VOIDmode;
|
mode != VOIDmode;
|
mode = GET_MODE_WIDER_MODE (mode))
|
mode = GET_MODE_WIDER_MODE (mode))
|
{
|
{
|
const_tiny_rtx[0][(int) mode] = gen_const_vector (mode, 0);
|
const_tiny_rtx[0][(int) mode] = gen_const_vector (mode, 0);
|
const_tiny_rtx[1][(int) mode] = gen_const_vector (mode, 1);
|
const_tiny_rtx[1][(int) mode] = gen_const_vector (mode, 1);
|
}
|
}
|
|
|
for (i = (int) CCmode; i < (int) MAX_MACHINE_MODE; ++i)
|
for (i = (int) CCmode; i < (int) MAX_MACHINE_MODE; ++i)
|
if (GET_MODE_CLASS ((enum machine_mode) i) == MODE_CC)
|
if (GET_MODE_CLASS ((enum machine_mode) i) == MODE_CC)
|
const_tiny_rtx[0][i] = const0_rtx;
|
const_tiny_rtx[0][i] = const0_rtx;
|
|
|
const_tiny_rtx[0][(int) BImode] = const0_rtx;
|
const_tiny_rtx[0][(int) BImode] = const0_rtx;
|
if (STORE_FLAG_VALUE == 1)
|
if (STORE_FLAG_VALUE == 1)
|
const_tiny_rtx[1][(int) BImode] = const1_rtx;
|
const_tiny_rtx[1][(int) BImode] = const1_rtx;
|
}
|
}
|
|
|
/* Produce exact duplicate of insn INSN after AFTER.
|
/* Produce exact duplicate of insn INSN after AFTER.
|
Care updating of libcall regions if present. */
|
Care updating of libcall regions if present. */
|
|
|
rtx
|
rtx
|
emit_copy_of_insn_after (rtx insn, rtx after)
|
emit_copy_of_insn_after (rtx insn, rtx after)
|
{
|
{
|
rtx new_rtx, link;
|
rtx new_rtx, link;
|
|
|
switch (GET_CODE (insn))
|
switch (GET_CODE (insn))
|
{
|
{
|
case INSN:
|
case INSN:
|
new_rtx = emit_insn_after (copy_insn (PATTERN (insn)), after);
|
new_rtx = emit_insn_after (copy_insn (PATTERN (insn)), after);
|
break;
|
break;
|
|
|
case JUMP_INSN:
|
case JUMP_INSN:
|
new_rtx = emit_jump_insn_after (copy_insn (PATTERN (insn)), after);
|
new_rtx = emit_jump_insn_after (copy_insn (PATTERN (insn)), after);
|
break;
|
break;
|
|
|
case DEBUG_INSN:
|
case DEBUG_INSN:
|
new_rtx = emit_debug_insn_after (copy_insn (PATTERN (insn)), after);
|
new_rtx = emit_debug_insn_after (copy_insn (PATTERN (insn)), after);
|
break;
|
break;
|
|
|
case CALL_INSN:
|
case CALL_INSN:
|
new_rtx = emit_call_insn_after (copy_insn (PATTERN (insn)), after);
|
new_rtx = emit_call_insn_after (copy_insn (PATTERN (insn)), after);
|
if (CALL_INSN_FUNCTION_USAGE (insn))
|
if (CALL_INSN_FUNCTION_USAGE (insn))
|
CALL_INSN_FUNCTION_USAGE (new_rtx)
|
CALL_INSN_FUNCTION_USAGE (new_rtx)
|
= copy_insn (CALL_INSN_FUNCTION_USAGE (insn));
|
= copy_insn (CALL_INSN_FUNCTION_USAGE (insn));
|
SIBLING_CALL_P (new_rtx) = SIBLING_CALL_P (insn);
|
SIBLING_CALL_P (new_rtx) = SIBLING_CALL_P (insn);
|
RTL_CONST_CALL_P (new_rtx) = RTL_CONST_CALL_P (insn);
|
RTL_CONST_CALL_P (new_rtx) = RTL_CONST_CALL_P (insn);
|
RTL_PURE_CALL_P (new_rtx) = RTL_PURE_CALL_P (insn);
|
RTL_PURE_CALL_P (new_rtx) = RTL_PURE_CALL_P (insn);
|
RTL_LOOPING_CONST_OR_PURE_CALL_P (new_rtx)
|
RTL_LOOPING_CONST_OR_PURE_CALL_P (new_rtx)
|
= RTL_LOOPING_CONST_OR_PURE_CALL_P (insn);
|
= RTL_LOOPING_CONST_OR_PURE_CALL_P (insn);
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
/* Update LABEL_NUSES. */
|
/* Update LABEL_NUSES. */
|
mark_jump_label (PATTERN (new_rtx), new_rtx, 0);
|
mark_jump_label (PATTERN (new_rtx), new_rtx, 0);
|
|
|
INSN_LOCATOR (new_rtx) = INSN_LOCATOR (insn);
|
INSN_LOCATOR (new_rtx) = INSN_LOCATOR (insn);
|
|
|
/* If the old insn is frame related, then so is the new one. This is
|
/* If the old insn is frame related, then so is the new one. This is
|
primarily needed for IA-64 unwind info which marks epilogue insns,
|
primarily needed for IA-64 unwind info which marks epilogue insns,
|
which may be duplicated by the basic block reordering code. */
|
which may be duplicated by the basic block reordering code. */
|
RTX_FRAME_RELATED_P (new_rtx) = RTX_FRAME_RELATED_P (insn);
|
RTX_FRAME_RELATED_P (new_rtx) = RTX_FRAME_RELATED_P (insn);
|
|
|
/* Copy all REG_NOTES except REG_LABEL_OPERAND since mark_jump_label
|
/* Copy all REG_NOTES except REG_LABEL_OPERAND since mark_jump_label
|
will make them. REG_LABEL_TARGETs are created there too, but are
|
will make them. REG_LABEL_TARGETs are created there too, but are
|
supposed to be sticky, so we copy them. */
|
supposed to be sticky, so we copy them. */
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
|
if (REG_NOTE_KIND (link) != REG_LABEL_OPERAND)
|
if (REG_NOTE_KIND (link) != REG_LABEL_OPERAND)
|
{
|
{
|
if (GET_CODE (link) == EXPR_LIST)
|
if (GET_CODE (link) == EXPR_LIST)
|
add_reg_note (new_rtx, REG_NOTE_KIND (link),
|
add_reg_note (new_rtx, REG_NOTE_KIND (link),
|
copy_insn_1 (XEXP (link, 0)));
|
copy_insn_1 (XEXP (link, 0)));
|
else
|
else
|
add_reg_note (new_rtx, REG_NOTE_KIND (link), XEXP (link, 0));
|
add_reg_note (new_rtx, REG_NOTE_KIND (link), XEXP (link, 0));
|
}
|
}
|
|
|
INSN_CODE (new_rtx) = INSN_CODE (insn);
|
INSN_CODE (new_rtx) = INSN_CODE (insn);
|
return new_rtx;
|
return new_rtx;
|
}
|
}
|
|
|
static GTY((deletable)) rtx hard_reg_clobbers [NUM_MACHINE_MODES][FIRST_PSEUDO_REGISTER];
|
static GTY((deletable)) rtx hard_reg_clobbers [NUM_MACHINE_MODES][FIRST_PSEUDO_REGISTER];
|
rtx
|
rtx
|
gen_hard_reg_clobber (enum machine_mode mode, unsigned int regno)
|
gen_hard_reg_clobber (enum machine_mode mode, unsigned int regno)
|
{
|
{
|
if (hard_reg_clobbers[mode][regno])
|
if (hard_reg_clobbers[mode][regno])
|
return hard_reg_clobbers[mode][regno];
|
return hard_reg_clobbers[mode][regno];
|
else
|
else
|
return (hard_reg_clobbers[mode][regno] =
|
return (hard_reg_clobbers[mode][regno] =
|
gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (mode, regno)));
|
gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (mode, regno)));
|
}
|
}
|
|
|
#include "gt-emit-rtl.h"
|
#include "gt-emit-rtl.h"
|
|
|
