blob: 4813f7a7921414eb7304e36b0b4c64fafddbd431 [file] [log] [blame]
/* Subroutines used for code generation on Xilinx MicroBlaze.
Copyright (C) 2009-2021 Free Software Foundation, Inc.
Contributed by Michael Eager <eager@eagercon.com>.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published
by the Free Software Foundation; either version 3, or (at your
option) any later version.
GCC is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
License for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
#define IN_TARGET_CODE 1
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "backend.h"
#include "target.h"
#include "rtl.h"
#include "tree.h"
#include "stringpool.h"
#include "attribs.h"
#include "df.h"
#include "memmodel.h"
#include "tm_p.h"
#include "optabs.h"
#include "regs.h"
#include "emit-rtl.h"
#include "recog.h"
#include "cgraph.h"
#include "diagnostic-core.h"
#include "varasm.h"
#include "stor-layout.h"
#include "calls.h"
#include "explow.h"
#include "expr.h"
#include "reload.h"
#include "output.h"
#include "builtins.h"
#include "rtl-iter.h"
#include "cfgloop.h"
#include "insn-addr.h"
#include "cfgrtl.h"
#include "opts.h"
/* This file should be included last. */
#include "target-def.h"
#define MICROBLAZE_VERSION_COMPARE(VA,VB) strcasecmp (VA, VB)
/* Classifies an address.
ADDRESS_INVALID
An invalid address.
ADDRESS_REG
A natural register or a register + const_int offset address.
The register satisfies microblaze_valid_base_register_p and the
offset is a const_arith_operand.
ADDRESS_REG_INDEX
A natural register offset by the index contained in an index register. The base
register satisfies microblaze_valid_base_register_p and the index register
satisfies microblaze_valid_index_register_p
ADDRESS_CONST_INT
A signed 16/32-bit constant address.
ADDRESS_SYMBOLIC:
A constant symbolic address or a (register + symbol). */
enum microblaze_address_type
{
ADDRESS_INVALID,
ADDRESS_REG,
ADDRESS_REG_INDEX,
ADDRESS_CONST_INT,
ADDRESS_SYMBOLIC,
ADDRESS_GOTOFF,
ADDRESS_PLT,
ADDRESS_TLS,
ADDRESS_SYMBOLIC_TXT_REL
};
/* Classifies symbols
SYMBOL_TYPE_GENERAL
A general symbol. */
enum microblaze_symbol_type
{
SYMBOL_TYPE_INVALID,
SYMBOL_TYPE_GENERAL
};
/* TLS Address Type. */
enum tls_reloc {
TLS_GD,
TLS_LDM,
TLS_DTPREL,
TLS_IE,
TLS_LE
};
/* Classification of a MicroBlaze address. */
struct microblaze_address_info
{
enum microblaze_address_type type;
rtx regA; /* Contains valid values on ADDRESS_REG, ADDRESS_REG_INDEX,
ADDRESS_SYMBOLIC. */
rtx regB; /* Contains valid values on ADDRESS_REG_INDEX. */
rtx offset; /* Contains valid values on ADDRESS_CONST_INT and ADDRESS_REG. */
rtx symbol; /* Contains valid values on ADDRESS_SYMBOLIC. */
enum microblaze_symbol_type symbol_type;
enum tls_reloc tls_type;
};
/* Structure to be filled in by compute_frame_size with register
save masks, and offsets for the current function. */
struct GTY(()) microblaze_frame_info {
long total_size; /* # bytes that the entire frame takes up. */
long var_size; /* # bytes that variables take up. */
long args_size; /* # bytes that outgoing arguments take up. */
int link_debug_size; /* # bytes for the link reg and back pointer. */
int gp_reg_size; /* # bytes needed to store gp regs. */
long gp_offset; /* offset from new sp to store gp registers. */
long mask; /* mask of saved gp registers. */
int initialized; /* != 0 if frame size already calculated. */
int num_gp; /* number of gp registers saved. */
long insns_len; /* length of insns. */
int alloc_stack; /* Flag to indicate if the current function
must not create stack space. (As an optimization). */
};
/* Global variables for machine-dependent things. */
/* Toggle which pipleline interface to use. */
static GTY(()) int microblaze_sched_use_dfa = 0;
/* Threshold for data being put into the small data/bss area, instead
of the normal data area (references to the small data/bss area take
1 instruction, and use the global pointer, references to the normal
data area takes 2 instructions). */
int microblaze_section_threshold = -1;
/* Prevent scheduling potentially exception causing instructions in
delay slots. -mcpu=v3.00.a or v4.00.a turns this on. */
int microblaze_no_unsafe_delay;
/* Set to one if the targeted core has the CLZ insn. */
int microblaze_has_clz = 0;
/* Which CPU pipeline do we use. We haven't really standardized on a CPU
version having only a particular type of pipeline. There can still be
options on the CPU to scale pipeline features up or down. :(
Bad Presentation (??), so we let the MD file rely on the value of
this variable instead Making PIPE_5 the default. It should be backward
optimal with PIPE_3 MicroBlazes. */
enum pipeline_type microblaze_pipe = MICROBLAZE_PIPE_5;
/* High and low marks for floating point values which we will accept
as legitimate constants for TARGET_LEGITIMATE_CONSTANT_P. These are
initialized in override_options. */
REAL_VALUE_TYPE dfhigh, dflow, sfhigh, sflow;
/* Array giving truth value on whether or not a given hard register
can support a given mode. */
static char microblaze_hard_regno_mode_ok_p[(int)MAX_MACHINE_MODE]
[FIRST_PSEUDO_REGISTER];
/* Current frame information calculated by compute_frame_size. */
struct microblaze_frame_info current_frame_info;
/* Zero structure to initialize current_frame_info. */
struct microblaze_frame_info zero_frame_info;
/* List of all MICROBLAZE punctuation characters used by print_operand. */
char microblaze_print_operand_punct[256];
/* Map GCC register number to debugger register number. */
int microblaze_dbx_regno[FIRST_PSEUDO_REGISTER];
/* Map hard register number to register class. */
enum reg_class microblaze_regno_to_class[] =
{
GR_REGS, GR_REGS, GR_REGS, GR_REGS,
GR_REGS, GR_REGS, GR_REGS, GR_REGS,
GR_REGS, GR_REGS, GR_REGS, GR_REGS,
GR_REGS, GR_REGS, GR_REGS, GR_REGS,
GR_REGS, GR_REGS, GR_REGS, GR_REGS,
GR_REGS, GR_REGS, GR_REGS, GR_REGS,
GR_REGS, GR_REGS, GR_REGS, GR_REGS,
GR_REGS, GR_REGS, GR_REGS, GR_REGS,
ST_REGS, GR_REGS, GR_REGS, GR_REGS
};
/* MicroBlaze specific machine attributes.
interrupt_handler - Interrupt handler attribute to add interrupt prologue
and epilogue and use appropriate interrupt return.
save_volatiles - Similar to interrupt handler, but use normal return. */
int interrupt_handler;
int break_handler;
int fast_interrupt;
int save_volatiles;
const struct attribute_spec microblaze_attribute_table[] = {
/* name min_len, max_len, decl_req, type_req, fn_type_req,
affects_type_identity, handler, exclude */
{"interrupt_handler", 0, 0, true, false, false, false, NULL, NULL },
{"break_handler", 0, 0, true, false, false, false, NULL, NULL },
{"fast_interrupt", 0, 0, true, false, false, false, NULL, NULL },
{"save_volatiles", 0, 0, true, false, false, false, NULL, NULL },
{ NULL, 0, 0, false, false, false, false, NULL, NULL }
};
static int microblaze_interrupt_function_p (tree);
static void microblaze_elf_asm_constructor (rtx, int) ATTRIBUTE_UNUSED;
static void microblaze_elf_asm_destructor (rtx, int) ATTRIBUTE_UNUSED;
section *sdata2_section;
#ifdef HAVE_AS_TLS
#undef TARGET_HAVE_TLS
#define TARGET_HAVE_TLS true
#endif
/* Return truth value if a CONST_DOUBLE is ok to be a legitimate constant. */
static bool
microblaze_const_double_ok (rtx op, machine_mode mode)
{
REAL_VALUE_TYPE d;
if (GET_CODE (op) != CONST_DOUBLE)
return 0;
if (GET_MODE (op) == VOIDmode)
return 1;
if (mode != SFmode && mode != DFmode)
return 0;
if (op == CONST0_RTX (mode))
return 1;
d = *CONST_DOUBLE_REAL_VALUE (op);
if (REAL_VALUE_ISNAN (d))
return FALSE;
if (REAL_VALUE_NEGATIVE (d))
d = real_value_negate (&d);
if (mode == DFmode)
{
if (real_less (&d, &dfhigh) && real_less (&dflow, &d))
return 1;
}
else
{
if (real_less (&d, &sfhigh) && real_less (&sflow, &d))
return 1;
}
return 0;
}
/* Return truth value if a memory operand fits in a single instruction
(ie, register + small offset) or (register + register). */
int
simple_memory_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
{
rtx addr, plus0, plus1;
/* Eliminate non-memory operations. */
if (GET_CODE (op) != MEM)
return 0;
/* dword operations really put out 2 instructions, so eliminate them. */
/* ??? This isn't strictly correct. It is OK to accept multiword modes
here, since the length attributes are being set correctly, but only
if the address is offsettable. */
if (GET_MODE_SIZE (GET_MODE (op)) > UNITS_PER_WORD)
return 0;
/* Decode the address now. */
addr = XEXP (op, 0);
switch (GET_CODE (addr))
{
case REG:
return 1;
case PLUS:
plus0 = XEXP (addr, 0);
plus1 = XEXP (addr, 1);
if (GET_CODE (plus0) != REG)
return 0;
if (GET_CODE (plus0) == REG && GET_CODE (plus1) == CONST_INT
&& SMALL_INT (plus1))
{
return 1;
}
else if (GET_CODE (plus1) == REG && GET_CODE (plus0) == CONST_INT)
{
return 1;
}
else if (GET_CODE (plus0) == REG && GET_CODE (plus1) == REG)
{
return 1;
}
else
return 0;
case SYMBOL_REF:
return 0;
default:
break;
}
return 0;
}
/* Return nonzero for a memory address that can be used to load or store
a doubleword. */
int
double_memory_operand (rtx op, machine_mode mode)
{
rtx addr;
if (GET_CODE (op) != MEM || !memory_operand (op, mode))
{
/* During reload, we accept a pseudo register if it has an
appropriate memory address. If we don't do this, we will
wind up reloading into a register, and then reloading that
register from memory, when we could just reload directly from
memory. */
if (reload_in_progress
&& GET_CODE (op) == REG
&& REGNO (op) >= FIRST_PSEUDO_REGISTER
&& reg_renumber[REGNO (op)] < 0
&& reg_equiv_mem (REGNO (op)) != 0
&& double_memory_operand (reg_equiv_mem (REGNO (op)), mode))
return 1;
return 0;
}
/* Make sure that 4 added to the address is a valid memory address.
This essentially just checks for overflow in an added constant. */
addr = XEXP (op, 0);
if (CONSTANT_ADDRESS_P (addr))
return 1;
return memory_address_p ((GET_MODE_CLASS (mode) == MODE_INT
? E_SImode : E_SFmode),
plus_constant (Pmode, addr, 4));
}
/* Implement REG_OK_FOR_BASE_P -and- REG_OK_FOR_INDEX_P. */
int
microblaze_regno_ok_for_base_p (int regno, int strict)
{
if (regno >= FIRST_PSEUDO_REGISTER)
{
if (!strict)
return true;
regno = reg_renumber[regno];
}
/* These fake registers will be eliminated to either the stack or
hard frame pointer, both of which are usually valid base registers.
Reload deals with the cases where the eliminated form isn't valid. */
if (regno == ARG_POINTER_REGNUM || regno == FRAME_POINTER_REGNUM)
return true;
return GP_REG_P (regno);
}
/* Return true if X is a valid base register for the given mode.
Allow only hard registers if STRICT. */
static bool
microblaze_valid_base_register_p (rtx x,
machine_mode mode ATTRIBUTE_UNUSED,
int strict)
{
if (!strict && GET_CODE (x) == SUBREG)
x = SUBREG_REG (x);
return (GET_CODE (x) == REG
&& microblaze_regno_ok_for_base_p (REGNO (x), strict));
}
/* Build the SYMBOL_REF for __tls_get_addr. */
static GTY(()) rtx tls_get_addr_libfunc;
static rtx
get_tls_get_addr (void)
{
if (!tls_get_addr_libfunc)
tls_get_addr_libfunc = init_one_libfunc ("__tls_get_addr");
return tls_get_addr_libfunc;
}
/* Return TRUE if X is a thread-local symbol. */
bool
microblaze_tls_symbol_p (rtx x)
{
if (!TARGET_HAVE_TLS)
return false;
if (GET_CODE (x) != SYMBOL_REF)
return false;
return SYMBOL_REF_TLS_MODEL (x) != 0;
}
/* Return TRUE if X contains any TLS symbol references. */
bool
microblaze_tls_referenced_p (rtx x)
{
if (!TARGET_HAVE_TLS)
return false;
subrtx_iterator::array_type array;
FOR_EACH_SUBRTX (iter, array, x, ALL)
{
const_rtx x = *iter;
if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (x) != 0)
return true;
/* Don't recurse into UNSPEC_TLS looking for TLS symbols; these are
TLS offsets, not real symbol references. */
if (GET_CODE (x) == UNSPEC && XINT (x, 1) == UNSPEC_TLS)
iter.skip_subrtxes ();
}
return false;
}
bool
microblaze_cannot_force_const_mem (machine_mode mode ATTRIBUTE_UNUSED, rtx x)
{
return microblaze_tls_referenced_p(x);
}
/* Return TRUE if X references a SYMBOL_REF. */
int
symbol_mentioned_p (rtx x)
{
const char * fmt;
int i;
if (GET_CODE (x) == SYMBOL_REF)
return 1;
/* UNSPEC entries for a symbol include the SYMBOL_REF, but they
are constant offsets, not symbols. */
if (GET_CODE (x) == UNSPEC)
return 0;
fmt = GET_RTX_FORMAT (GET_CODE (x));
for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
{
if (fmt[i] == 'E')
{
int j;
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
if (symbol_mentioned_p (XVECEXP (x, i, j)))
return 1;
}
else if (fmt[i] == 'e' && symbol_mentioned_p (XEXP (x, i)))
return 1;
}
return 0;
}
/* Return TRUE if X references a LABEL_REF. */
int
label_mentioned_p (rtx x)
{
const char * fmt;
int i;
if (GET_CODE (x) == LABEL_REF)
return 1;
/* UNSPEC entries for a symbol include a LABEL_REF for the referencing
instruction, but they are constant offsets, not symbols. */
if (GET_CODE (x) == UNSPEC)
return 0;
fmt = GET_RTX_FORMAT (GET_CODE (x));
for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
{
if (fmt[i] == 'E')
{
int j;
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
if (label_mentioned_p (XVECEXP (x, i, j)))
return 1;
}
else if (fmt[i] == 'e' && label_mentioned_p (XEXP (x, i)))
return 1;
}
return 0;
}
int
tls_mentioned_p (rtx x)
{
switch (GET_CODE (x))
{
case CONST:
return tls_mentioned_p (XEXP (x, 0));
case UNSPEC:
if (XINT (x, 1) == UNSPEC_TLS)
return 1;
return 0;
default:
return 0;
}
}
static rtx
load_tls_operand (rtx x, rtx reg)
{
rtx tmp;
if (reg == NULL_RTX)
reg = gen_reg_rtx (Pmode);
tmp = gen_rtx_CONST (Pmode, x);
emit_insn (gen_rtx_SET (reg,
gen_rtx_PLUS (Pmode, pic_offset_table_rtx, tmp)));
return reg;
}
static rtx_insn *
microblaze_call_tls_get_addr (rtx x, rtx reg, rtx *valuep, int reloc)
{
rtx_insn *insns;
rtx tls_entry;
df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
start_sequence ();
tls_entry = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, x, GEN_INT (reloc)),
UNSPEC_TLS);
reg = load_tls_operand (tls_entry, reg);
*valuep = emit_library_call_value (get_tls_get_addr (), NULL_RTX,
LCT_PURE, /* LCT_CONST? */
Pmode, reg, Pmode);
insns = get_insns ();
end_sequence ();
return insns;
}
rtx
microblaze_legitimize_tls_address(rtx x, rtx reg)
{
rtx dest, ret, eqv, addend;
rtx_insn *insns;
enum tls_model model;
model = SYMBOL_REF_TLS_MODEL (x);
switch (model)
{
case TLS_MODEL_LOCAL_DYNAMIC:
case TLS_MODEL_GLOBAL_DYNAMIC:
case TLS_MODEL_INITIAL_EXEC:
insns = microblaze_call_tls_get_addr (x, reg, &ret, TLS_GD);
dest = gen_reg_rtx (Pmode);
emit_libcall_block (insns, dest, ret, x);
break;
case TLS_MODEL_LOCAL_EXEC:
insns = microblaze_call_tls_get_addr (x, reg, &ret, TLS_LDM);
/* Attach a unique REG_EQUIV, to allow the RTL optimizers to
share the LDM result with other LD model accesses. */
eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const1_rtx), UNSPEC_TLS);
dest = gen_reg_rtx (Pmode);
emit_libcall_block (insns, dest, ret, eqv);
/* Load the addend. */
addend = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, x, GEN_INT (TLS_DTPREL)),
UNSPEC_TLS);
addend = force_reg (SImode, gen_rtx_CONST (SImode, addend));
dest = gen_rtx_PLUS (Pmode, dest, addend);
break;
default:
gcc_unreachable ();
}
return dest;
}
static bool
microblaze_classify_unspec (struct microblaze_address_info *info, rtx x)
{
info->symbol_type = SYMBOL_TYPE_GENERAL;
info->symbol = XVECEXP (x, 0, 0);
if (XINT (x, 1) == UNSPEC_GOTOFF)
{
info->regA = gen_rtx_REG (SImode, PIC_OFFSET_TABLE_REGNUM);
info->type = ADDRESS_GOTOFF;
}
else if (XINT (x, 1) == UNSPEC_PLT)
{
info->type = ADDRESS_PLT;
}
else if (XINT (x, 1) == UNSPEC_TLS)
{
info->type = ADDRESS_TLS;
info->tls_type = tls_reloc (INTVAL (XVECEXP (x, 0, 1)));
}
else if (XINT (x, 1) == UNSPEC_TEXT)
{
info->type = ADDRESS_SYMBOLIC_TXT_REL;
}
else
{
return false;
}
return true;
}
/* Return true if X is a valid index register for the given mode.
Allow only hard registers if STRICT. */
static bool
microblaze_valid_index_register_p (rtx x,
machine_mode mode ATTRIBUTE_UNUSED,
int strict)
{
if (!strict && GET_CODE (x) == SUBREG)
x = SUBREG_REG (x);
return (GET_CODE (x) == REG
/* A base register is good enough to be an index register on MicroBlaze. */
&& microblaze_regno_ok_for_base_p (REGNO (x), strict));
}
/* Get the base register for accessing a value from the memory or
Symbol ref. Used for MicroBlaze Small Data Area Pointer Optimization. */
static int
get_base_reg (rtx x)
{
tree decl;
int base_reg;
if (!flag_pic || microblaze_tls_symbol_p(x))
base_reg = MB_ABI_BASE_REGNUM;
else if (flag_pic)
base_reg = MB_ABI_PIC_ADDR_REGNUM;
if (TARGET_XLGPOPT
&& GET_CODE (x) == SYMBOL_REF
&& SYMBOL_REF_SMALL_P (x) && (decl = SYMBOL_REF_DECL (x)) != NULL)
{
if (TREE_READONLY (decl))
base_reg = MB_ABI_GPRO_REGNUM;
else
base_reg = MB_ABI_GPRW_REGNUM;
}
return base_reg;
}
/* Return true if X is a valid address for machine mode MODE. If it is,
fill in INFO appropriately.
STRICT > 0 if we should only accept hard base registers.
STRICT = 2 if the operand address is being printed thus
function has been called by print_operand_address.
type regA regB offset symbol
ADDRESS_INVALID NULL NULL NULL NULL
ADDRESS_REG %0 NULL const_0 / NULL
const_int
ADDRESS_REG_INDEX %0 %1 NULL NULL
ADDRESS_SYMBOLIC r0 / NULL NULL symbol
sda_base_reg
ADDRESS_CONST_INT r0 NULL const NULL
For modes spanning multiple registers (DFmode in 32-bit GPRs,
DImode, TImode), indexed addressing cannot be used because
adjacent memory cells are accessed by adding word-sized offsets
during assembly output. */
static bool
microblaze_classify_address (struct microblaze_address_info *info, rtx x,
machine_mode mode, int strict)
{
rtx xplus0;
rtx xplus1;
rtx offset;
info->type = ADDRESS_INVALID;
info->regA = NULL;
info->regB = NULL;
info->offset = NULL;
info->symbol = NULL;
info->symbol_type = SYMBOL_TYPE_INVALID;
offset = NULL;
switch (GET_CODE (x))
{
case REG:
case SUBREG:
{
info->type = ADDRESS_REG;
info->regA = x;
info->offset = const0_rtx;
return microblaze_valid_base_register_p (info->regA, mode, strict);
}
case PLUS:
{
xplus0 = XEXP (x, 0);
xplus1 = XEXP (x, 1);
if (microblaze_valid_base_register_p (xplus0, mode, strict))
{
info->type = ADDRESS_REG;
info->regA = xplus0;
if (GET_CODE (xplus1) == CONST_INT)
{
info->offset = xplus1;
return true;
}
else if (GET_CODE (xplus1) == UNSPEC)
{
/* Need offsettable address. */
if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
return false;
return microblaze_classify_unspec (info, xplus1);
}
else if ((GET_CODE (xplus1) == SYMBOL_REF ||
GET_CODE (xplus1) == LABEL_REF))
{
if (flag_pic == 2 || microblaze_tls_symbol_p(xplus1))
return false;
info->type = ADDRESS_SYMBOLIC;
info->symbol = xplus1;
info->symbol_type = SYMBOL_TYPE_GENERAL;
return true;
}
else if (GET_CODE (xplus1) == CONST)
{
rtx xconst0 = XEXP(xplus1, 0);
/* base + unspec. */
if (GET_CODE (xconst0) == UNSPEC)
{
/* Need offsettable address. */
if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
return false;
return microblaze_classify_unspec(info, xconst0);
}
/* for (plus x const_int) just look at x. */
if (GET_CODE (xconst0) == PLUS
&& GET_CODE (XEXP (xconst0, 1)) == CONST_INT
&& (SMALL_INT (XEXP (xconst0, 1))
|| GET_CODE (XEXP (xconst0, 0)) == UNSPEC))
{
/* Hold CONST_INT Value in offset in case of
UNSPEC + CONST_INT. */
offset = XEXP (xconst0, 1);
/* This is ok as info->symbol is set to xplus1 the full
const-expression below. */
xconst0 = XEXP (xconst0, 0);
}
if (GET_CODE (xconst0) == SYMBOL_REF
|| GET_CODE (xconst0) == LABEL_REF)
{
if (flag_pic == 2 || microblaze_tls_symbol_p(xconst0))
return false;
info->type = ADDRESS_SYMBOLIC;
info->symbol = xplus1;
info->symbol_type = SYMBOL_TYPE_GENERAL;
return true;
}
if (GET_CODE (xconst0) == UNSPEC && TARGET_PIC_DATA_TEXT_REL)
{
if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
return false;
info->offset = offset;
return microblaze_classify_unspec (info, xconst0);
}
/* Not base + symbol || base + UNSPEC. */
return false;
}
else if (GET_CODE (xplus1) == REG
&& microblaze_valid_index_register_p (xplus1, mode,
strict)
&& (GET_MODE_SIZE (mode) <= UNITS_PER_WORD))
{
/* Restrict larger than word-width modes from using an index register. */
info->type = ADDRESS_REG_INDEX;
info->regB = xplus1;
return true;
}
}
break;
}
case CONST_INT:
{
info->regA = gen_raw_REG (mode, 0);
info->type = ADDRESS_CONST_INT;
info->offset = x;
return true;
}
case CONST:
case LABEL_REF:
case SYMBOL_REF:
{
info->type = ADDRESS_SYMBOLIC;
info->symbol_type = SYMBOL_TYPE_GENERAL;
info->symbol = x;
info->regA = gen_raw_REG (mode, get_base_reg (x));
if (GET_CODE (x) == CONST)
{
if (GET_CODE (XEXP (x, 0)) == UNSPEC)
{
info->regA = gen_raw_REG (mode,
get_base_reg (XVECEXP (XEXP (x,0), 0, 0)));
return microblaze_classify_unspec (info, XEXP (x, 0));
}
return !(flag_pic && pic_address_needs_scratch (x));
}
/* Avoid error in print_operand_address in case UNSPEC
is removed from SYMBOL or LABEL REFS during optimization. */
if ((GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF)
&& flag_pic && TARGET_PIC_DATA_TEXT_REL && strict == 2)
{
info->type = ADDRESS_SYMBOLIC_TXT_REL;
return true;
}
if (flag_pic == 2)
return false;
else if (microblaze_tls_symbol_p(x))
return false;
return true;
}
case UNSPEC:
{
if (reload_in_progress)
df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
return microblaze_classify_unspec (info, x);
}
default:
return false;
}
return false;
}
/* This function is used to implement GO_IF_LEGITIMATE_ADDRESS. It
returns a nonzero value if X is a legitimate address for a memory
operand of the indicated MODE. STRICT is nonzero if this function
is called during reload. */
bool
microblaze_legitimate_address_p (machine_mode mode, rtx x, bool strict)
{
struct microblaze_address_info addr;
return microblaze_classify_address (&addr, x, mode, strict);
}
bool
microblaze_constant_address_p (rtx x)
{
return ((GET_CODE (x) == LABEL_REF) || (GET_CODE (x) == SYMBOL_REF)
|| GET_CODE (x) == CONST_INT
|| (GET_CODE (x) == CONST
&& ! (flag_pic && pic_address_needs_scratch (x))));
}
int
microblaze_valid_pic_const (rtx x)
{
switch (GET_CODE (x))
{
case CONST:
case CONST_INT:
case CONST_DOUBLE:
return true;
default:
return false;
}
}
int
microblaze_legitimate_pic_operand (rtx x)
{
if (flag_pic == 2 && (symbol_mentioned_p (x) || label_mentioned_p (x))
&& !(TARGET_PIC_DATA_TEXT_REL && call_insn_operand (x,VOIDmode)))
return 0;
if (microblaze_tls_referenced_p(x))
return 0;
return 1;
}
/* Try machine-dependent ways of modifying an illegitimate address
to be legitimate. If we find one, return the new, valid address.
This is used from only one place: `memory_address' in explow.c.
OLDX is the address as it was before break_out_memory_refs was
called. In some cases it is useful to look at this to decide what
needs to be done.
It is always safe for this function to do nothing. It exists to
recognize opportunities to optimize the output.
For the MicroBlaze, transform:
memory(X + <large int>)
into:
Y = <large int> & ~0x7fff;
Z = X + Y
memory (Z + (<large int> & 0x7fff));
This is for CSE to find several similar references, and only use one Z.
When PIC, convert addresses of the form memory (symbol+large int) to
memory (reg+large int). */
static rtx
microblaze_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
machine_mode mode ATTRIBUTE_UNUSED)
{
rtx xinsn = x, result;
if (GET_CODE (xinsn) == CONST
&& flag_pic && pic_address_needs_scratch (xinsn))
{
rtx ptr_reg = gen_reg_rtx (Pmode);
rtx constant = XEXP (XEXP (xinsn, 0), 1);
emit_move_insn (ptr_reg, XEXP (XEXP (xinsn, 0), 0));
result = gen_rtx_PLUS (Pmode, ptr_reg, constant);
if (SMALL_INT (constant))
return result;
/* Otherwise we fall through so the code below will fix the
constant. */
xinsn = result;
}
if (GET_CODE (xinsn) == PLUS)
{
rtx xplus0 = XEXP (xinsn, 0);
rtx xplus1 = XEXP (xinsn, 1);
enum rtx_code code0 = GET_CODE (xplus0);
enum rtx_code code1 = GET_CODE (xplus1);
if (code0 != REG && code1 == REG)
{
xplus0 = XEXP (xinsn, 1);
xplus1 = XEXP (xinsn, 0);
code0 = GET_CODE (xplus0);
code1 = GET_CODE (xplus1);
}
if (code0 == REG && REG_OK_FOR_BASE_P (xplus0)
&& code1 == CONST_INT && !SMALL_INT (xplus1))
{
rtx int_reg = gen_reg_rtx (Pmode);
rtx ptr_reg = gen_reg_rtx (Pmode);
emit_move_insn (int_reg, GEN_INT (INTVAL (xplus1) & ~0x7fff));
emit_insn (gen_rtx_SET (ptr_reg,
gen_rtx_PLUS (Pmode, xplus0, int_reg)));
result = gen_rtx_PLUS (Pmode, ptr_reg,
GEN_INT (INTVAL (xplus1) & 0x7fff));
return result;
}
if (code0 == REG && REG_OK_FOR_BASE_P (xplus0))
{
if (reload_in_progress)
df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
if (code1 == CONST)
{
xplus1 = XEXP (xplus1, 0);
code1 = GET_CODE (xplus1);
}
if (code1 == SYMBOL_REF)
{
if (microblaze_tls_symbol_p(xplus1))
{
rtx tls_ref, reg;
reg = gen_reg_rtx (Pmode);
tls_ref = microblaze_legitimize_tls_address (xplus1,
NULL_RTX);
emit_move_insn (reg, tls_ref);
result = gen_rtx_PLUS (Pmode, xplus0, reg);
return result;
}
else if (flag_pic == 2)
{
if (!TARGET_PIC_DATA_TEXT_REL)
{
rtx pic_ref, reg;
reg = gen_reg_rtx (Pmode);
pic_ref = gen_rtx_UNSPEC (Pmode,
gen_rtvec (1, xplus1),
UNSPEC_GOTOFF);
pic_ref = gen_rtx_CONST (Pmode, pic_ref);
pic_ref = gen_rtx_PLUS (Pmode,
pic_offset_table_rtx, pic_ref);
pic_ref = gen_const_mem (Pmode, pic_ref);
emit_move_insn (reg, pic_ref);
result = gen_rtx_PLUS (Pmode, xplus0, reg);
return result;
}
else
{
rtx pic_ref, reg;
reg = gen_reg_rtx (Pmode);
pic_ref = gen_rtx_UNSPEC (Pmode,
gen_rtvec (1, xplus1),
UNSPEC_TEXT);
pic_ref = gen_rtx_CONST (Pmode, pic_ref);
emit_insn (gen_addsi3 (reg,
pic_offset_table_rtx, xplus0));
result = gen_rtx_PLUS (Pmode, reg, pic_ref);
return result;
}
}
}
}
}
if (GET_CODE (xinsn) == SYMBOL_REF)
{
rtx reg;
if (microblaze_tls_symbol_p(xinsn))
{
reg = microblaze_legitimize_tls_address (xinsn, NULL_RTX);
}
else if (flag_pic == 2)
{
if (reload_in_progress)
df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
if (!TARGET_PIC_DATA_TEXT_REL)
{
rtx pic_ref;
pic_ref = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, xinsn), UNSPEC_GOTOFF);
pic_ref = gen_rtx_CONST (Pmode, pic_ref);
pic_ref = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, pic_ref);
pic_ref = gen_const_mem (Pmode, pic_ref);
reg = pic_ref;
}
else
{
rtx pic_ref;
pic_ref = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, xinsn), UNSPEC_TEXT);
pic_ref = gen_rtx_CONST (Pmode, pic_ref);
pic_ref = gen_rtx_PLUS (Pmode, pic_offset_table_rtx, pic_ref);
reg = pic_ref;
}
}
return reg;
}
return x;
}
/* Block Moves. */
#define MAX_MOVE_REGS 8
#define MAX_MOVE_BYTES (MAX_MOVE_REGS * UNITS_PER_WORD)
/* Emit straight-line code to move LENGTH bytes from SRC to DEST.
Assume that the areas do not overlap. */
static void
microblaze_block_move_straight (rtx dest, rtx src, HOST_WIDE_INT length)
{
HOST_WIDE_INT offset, delta;
unsigned HOST_WIDE_INT bits;
int i;
machine_mode mode;
rtx *regs;
bits = BITS_PER_WORD;
mode = int_mode_for_size (bits, 0).require ();
delta = bits / BITS_PER_UNIT;
/* Allocate a buffer for the temporary registers. */
regs = XALLOCAVEC (rtx, length / delta);
/* Load as many BITS-sized chunks as possible. Use a normal load if
the source has enough alignment, otherwise use left/right pairs. */
for (offset = 0, i = 0; offset + delta <= length; offset += delta, i++)
{
regs[i] = gen_reg_rtx (mode);
emit_move_insn (regs[i], adjust_address (src, mode, offset));
}
/* Copy the chunks to the destination. */
for (offset = 0, i = 0; offset + delta <= length; offset += delta, i++)
emit_move_insn (adjust_address (dest, mode, offset), regs[i]);
/* Mop up any left-over bytes. */
if (offset < length)
{
src = adjust_address (src, BLKmode, offset);
dest = adjust_address (dest, BLKmode, offset);
move_by_pieces (dest, src, length - offset,
MIN (MEM_ALIGN (src), MEM_ALIGN (dest)), RETURN_BEGIN);
}
}
/* Helper function for doing a loop-based block operation on memory
reference MEM. Each iteration of the loop will operate on LENGTH
bytes of MEM.
Create a new base register for use within the loop and point it to
the start of MEM. Create a new memory reference that uses this
register. Store them in *LOOP_REG and *LOOP_MEM respectively. */
static void
microblaze_adjust_block_mem (rtx mem, HOST_WIDE_INT length,
rtx * loop_reg, rtx * loop_mem)
{
*loop_reg = copy_addr_to_reg (XEXP (mem, 0));
/* Although the new mem does not refer to a known location,
it does keep up to LENGTH bytes of alignment. */
*loop_mem = change_address (mem, BLKmode, *loop_reg);
set_mem_align (*loop_mem,
MIN ((HOST_WIDE_INT) MEM_ALIGN (mem),
length * BITS_PER_UNIT));
}
/* Move LENGTH bytes from SRC to DEST using a loop that moves MAX_MOVE_BYTES
per iteration. LENGTH must be at least MAX_MOVE_BYTES. Assume that the
memory regions do not overlap. */
static void
microblaze_block_move_loop (rtx dest, rtx src, HOST_WIDE_INT length)
{
rtx_code_label *label;
rtx src_reg, dest_reg, final_src;
HOST_WIDE_INT leftover;
leftover = length % MAX_MOVE_BYTES;
length -= leftover;
/* Create registers and memory references for use within the loop. */
microblaze_adjust_block_mem (src, MAX_MOVE_BYTES, &src_reg, &src);
microblaze_adjust_block_mem (dest, MAX_MOVE_BYTES, &dest_reg, &dest);
/* Calculate the value that SRC_REG should have after the last iteration
of the loop. */
final_src = expand_simple_binop (Pmode, PLUS, src_reg, GEN_INT (length),
0, 0, OPTAB_WIDEN);
/* Emit the start of the loop. */
label = gen_label_rtx ();
emit_label (label);
/* Emit the loop body. */
microblaze_block_move_straight (dest, src, MAX_MOVE_BYTES);
/* Move on to the next block. */
emit_move_insn (src_reg, plus_constant (Pmode, src_reg, MAX_MOVE_BYTES));
emit_move_insn (dest_reg, plus_constant (Pmode, dest_reg, MAX_MOVE_BYTES));
/* Emit the test & branch. */
emit_insn (gen_cbranchsi4 (gen_rtx_NE (SImode, src_reg, final_src),
src_reg, final_src, label));
/* Mop up any left-over bytes. */
if (leftover)
microblaze_block_move_straight (dest, src, leftover);
}
/* Expand a cpymemsi instruction. */
bool
microblaze_expand_block_move (rtx dest, rtx src, rtx length, rtx align_rtx)
{
if (GET_CODE (length) == CONST_INT)
{
unsigned HOST_WIDE_INT bytes = UINTVAL (length);
unsigned int align = UINTVAL (align_rtx);
if (align > UNITS_PER_WORD)
{
align = UNITS_PER_WORD; /* We can't do any better. */
}
else if (align < UNITS_PER_WORD)
{
if (UINTVAL (length) <= MAX_MOVE_BYTES)
{
move_by_pieces (dest, src, bytes, align, RETURN_BEGIN);
return true;
}
else
return false;
}
if (UINTVAL (length) <= 2 * MAX_MOVE_BYTES)
{
microblaze_block_move_straight (dest, src, UINTVAL (length));
return true;
}
else if (optimize)
{
microblaze_block_move_loop (dest, src, UINTVAL (length));
return true;
}
}
return false;
}
static bool
microblaze_rtx_costs (rtx x, machine_mode mode, int outer_code ATTRIBUTE_UNUSED,
int opno ATTRIBUTE_UNUSED, int *total,
bool speed ATTRIBUTE_UNUSED)
{
int code = GET_CODE (x);
switch (code)
{
case MEM:
{
int num_words = (GET_MODE_SIZE (mode) > UNITS_PER_WORD) ? 2 : 1;
if (simple_memory_operand (x, mode))
*total = COSTS_N_INSNS (2 * num_words);
else
*total = COSTS_N_INSNS (2 * (2 * num_words));
return true;
}
case NOT:
{
if (mode == DImode)
{
*total = COSTS_N_INSNS (2);
}
else
*total = COSTS_N_INSNS (1);
return false;
}
case AND:
case IOR:
case XOR:
{
if (mode == DImode)
{
*total = COSTS_N_INSNS (2);
}
else
*total = COSTS_N_INSNS (1);
return false;
}
case ASHIFT:
case ASHIFTRT:
case LSHIFTRT:
{
if (TARGET_BARREL_SHIFT)
{
if (MICROBLAZE_VERSION_COMPARE (microblaze_select_cpu, "v5.00.a")
>= 0)
*total = COSTS_N_INSNS (1);
else
*total = COSTS_N_INSNS (2);
}
else if (!TARGET_SOFT_MUL)
*total = COSTS_N_INSNS (1);
else if (GET_CODE (XEXP (x, 1)) == CONST_INT)
{
/* Add 1 to make shift slightly more expensive than add. */
*total = COSTS_N_INSNS (INTVAL (XEXP (x, 1))) + 1;
/* Reduce shift costs for special circumstances. */
if (optimize_size && INTVAL (XEXP (x, 1)) > 5)
*total -= 2;
if (!optimize_size && INTVAL (XEXP (x, 1)) > 17)
*total -= 2;
}
else
/* Double the worst cost of shifts when there is no barrel shifter and
the shift amount is in a reg. */
*total = COSTS_N_INSNS (32 * 4);
return true;
}
case PLUS:
case MINUS:
{
if (mode == SFmode || mode == DFmode)
{
if (TARGET_HARD_FLOAT)
*total = COSTS_N_INSNS (6);
return true;
}
else if (mode == DImode)
{
*total = COSTS_N_INSNS (4);
return true;
}
else
{
*total = COSTS_N_INSNS (1);
return true;
}
return false;
}
case NEG:
{
if (mode == DImode)
*total = COSTS_N_INSNS (4);
return false;
}
case MULT:
{
if (mode == SFmode)
{
if (TARGET_HARD_FLOAT)
*total = COSTS_N_INSNS (6);
}
else if (!TARGET_SOFT_MUL)
{
if (MICROBLAZE_VERSION_COMPARE (microblaze_select_cpu, "v5.00.a")
>= 0)
*total = COSTS_N_INSNS (1);
else
*total = COSTS_N_INSNS (3);
}
else
*total = COSTS_N_INSNS (10);
return true;
}
case DIV:
case UDIV:
{
if (mode == SFmode)
{
if (TARGET_HARD_FLOAT)
*total = COSTS_N_INSNS (23);
}
return false;
}
case SIGN_EXTEND:
{
*total = COSTS_N_INSNS (1);
return false;
}
case ZERO_EXTEND:
{
*total = COSTS_N_INSNS (1);
return false;
}
}
return false;
}
/* Return the number of instructions needed to load or store a value
of mode MODE at X. Return 0 if X isn't valid for MODE. */
static int
microblaze_address_insns (rtx x, machine_mode mode)
{
struct microblaze_address_info addr;
if (microblaze_classify_address (&addr, x, mode, false))
{
switch (addr.type)
{
case ADDRESS_REG:
if (SMALL_INT (addr.offset))
return 1;
else
return 2;
case ADDRESS_CONST_INT:
if (SMALL_INT (x))
return 1;
else
return 2;
case ADDRESS_REG_INDEX:
return 1;
case ADDRESS_SYMBOLIC:
case ADDRESS_SYMBOLIC_TXT_REL:
case ADDRESS_GOTOFF:
return 2;
case ADDRESS_TLS:
switch (addr.tls_type)
{
case TLS_GD:
return 2;
case TLS_LDM:
return 2;
case TLS_DTPREL:
return 1;
default :
abort();
}
default:
break;
}
}
return 0;
}
/* Provide the costs of an addressing mode that contains ADDR.
If ADDR is not a valid address, its cost is irrelevant. */
static int
microblaze_address_cost (rtx addr, machine_mode mode ATTRIBUTE_UNUSED,
addr_space_t as ATTRIBUTE_UNUSED,
bool speed ATTRIBUTE_UNUSED)
{
return COSTS_N_INSNS (microblaze_address_insns (addr, GET_MODE (addr)));
}
/* Return nonzero if X is an address which needs a temporary register when
reloaded while generating PIC code. */
int
pic_address_needs_scratch (rtx x)
{
if (GET_CODE (x) == CONST && GET_CODE (XEXP (x,0)) == PLUS)
{
rtx p0, p1;
p0 = XEXP (XEXP (x, 0), 0);
p1 = XEXP (XEXP (x, 0), 1);
if ((GET_CODE (p0) == SYMBOL_REF || GET_CODE (p0) == LABEL_REF)
&& (GET_CODE (p1) == CONST_INT)
&& (flag_pic == 2 || microblaze_tls_symbol_p (p0) || !SMALL_INT (p1)))
return 1;
}
return 0;
}
/* Argument support functions. */
/* Initialize CUMULATIVE_ARGS for a function. */
void
init_cumulative_args (CUMULATIVE_ARGS * cum, tree fntype,
rtx libname ATTRIBUTE_UNUSED)
{
static CUMULATIVE_ARGS zero_cum;
tree param, next_param;
*cum = zero_cum;
/* Determine if this function has variable arguments. This is
indicated by the last argument being 'void_type_mode' if there
are no variable arguments. The standard MicroBlaze calling sequence
passes all arguments in the general purpose registers in this case. */
for (param = fntype ? TYPE_ARG_TYPES (fntype) : 0;
param != 0; param = next_param)
{
next_param = TREE_CHAIN (param);
if (next_param == 0 && TREE_VALUE (param) != void_type_node)
cum->gp_reg_found = 1;
}
}
/* Advance the argument to the next argument position. */
static void
microblaze_function_arg_advance (cumulative_args_t cum_v,
const function_arg_info &arg)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
cum->arg_number++;
switch (arg.mode)
{
case E_VOIDmode:
break;
default:
gcc_assert (GET_MODE_CLASS (arg.mode) == MODE_COMPLEX_INT
|| GET_MODE_CLASS (arg.mode) == MODE_COMPLEX_FLOAT);
cum->gp_reg_found = 1;
cum->arg_words += ((GET_MODE_SIZE (arg.mode) + UNITS_PER_WORD - 1)
/ UNITS_PER_WORD);
break;
case E_BLKmode:
cum->gp_reg_found = 1;
cum->arg_words += ((int_size_in_bytes (arg.type) + UNITS_PER_WORD - 1)
/ UNITS_PER_WORD);
break;
case E_SFmode:
cum->arg_words++;
if (!cum->gp_reg_found && cum->arg_number <= 2)
cum->fp_code += 1 << ((cum->arg_number - 1) * 2);
break;
case E_DFmode:
cum->arg_words += 2;
if (!cum->gp_reg_found && cum->arg_number <= 2)
cum->fp_code += 2 << ((cum->arg_number - 1) * 2);
break;
case E_DImode:
cum->gp_reg_found = 1;
cum->arg_words += 2;
break;
case E_QImode:
case E_HImode:
case E_SImode:
case E_TImode:
cum->gp_reg_found = 1;
cum->arg_words++;
break;
}
}
/* Return an RTL expression containing the register for the given argument
or 0 if the argument is to be passed on the stack. */
static rtx
microblaze_function_arg (cumulative_args_t cum_v, const function_arg_info &arg)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
rtx ret;
int regbase = -1;
int *arg_words = &cum->arg_words;
cum->last_arg_fp = 0;
switch (arg.mode)
{
case E_SFmode:
case E_DFmode:
case E_VOIDmode:
case E_QImode:
case E_HImode:
case E_SImode:
case E_DImode:
case E_TImode:
regbase = GP_ARG_FIRST;
break;
default:
gcc_assert (GET_MODE_CLASS (arg.mode) == MODE_COMPLEX_INT
|| GET_MODE_CLASS (arg.mode) == MODE_COMPLEX_FLOAT);
/* FALLTHRU */
case E_BLKmode:
regbase = GP_ARG_FIRST;
break;
}
if (*arg_words >= MAX_ARGS_IN_REGISTERS)
ret = 0;
else
{
gcc_assert (regbase != -1);
ret = gen_rtx_REG (arg.mode, regbase + *arg_words);
}
if (arg.end_marker_p ())
{
if (cum->num_adjusts > 0)
ret = gen_rtx_PARALLEL ((machine_mode) cum->fp_code,
gen_rtvec_v (cum->num_adjusts, cum->adjust));
}
return ret;
}
/* Return number of bytes of argument to put in registers. */
static int
function_arg_partial_bytes (cumulative_args_t cum_v,
const function_arg_info &arg)
{
CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
if ((arg.mode == BLKmode
|| GET_MODE_CLASS (arg.mode) != MODE_COMPLEX_INT
|| GET_MODE_CLASS (arg.mode) != MODE_COMPLEX_FLOAT)
&& cum->arg_words < MAX_ARGS_IN_REGISTERS)
{
int words = ((arg.promoted_size_in_bytes () + UNITS_PER_WORD - 1)
/ UNITS_PER_WORD);
if (words + cum->arg_words <= MAX_ARGS_IN_REGISTERS)
return 0; /* structure fits in registers */
return (MAX_ARGS_IN_REGISTERS - cum->arg_words) * UNITS_PER_WORD;
}
else if (arg.mode == DImode && cum->arg_words == MAX_ARGS_IN_REGISTERS - 1)
return UNITS_PER_WORD;
return 0;
}
/* Convert a version number of the form "vX.YY.Z" to an integer encoding
for easier range comparison. */
static int
microblaze_version_to_int (const char *version)
{
const char *p, *v;
const char *tmpl = "vXX.YY.Z";
int iver = 0;
p = version;
v = tmpl;
while (*p)
{
if (*v == 'X')
{ /* Looking for major */
if (*p == '.')
{
v++;
}
else
{
if (!(*p >= '0' && *p <= '9'))
return -1;
iver += (int) (*p - '0');
iver *= 10;
}
}
else if (*v == 'Y')
{ /* Looking for minor */
if (!(*p >= '0' && *p <= '9'))
return -1;
iver += (int) (*p - '0');
iver *= 10;
}
else if (*v == 'Z')
{ /* Looking for compat */
if (!(*p >= 'a' && *p <= 'z'))
return -1;
iver *= 10;
iver += (int) (*p - 'a');
}
else
{
if (*p != *v)
return -1;
}
v++;
p++;
}
if (*p)
return -1;
return iver;
}
static void
microblaze_option_override (void)
{
int i, start;
int regno;
machine_mode mode;
int ver;
microblaze_section_threshold = (OPTION_SET_P (g_switch_value)
? g_switch_value
: MICROBLAZE_DEFAULT_GVALUE);
if (flag_pic)
{
/* Make sure it's 2, we only support one kind of PIC. */
flag_pic = 2;
if (!TARGET_SUPPORTS_PIC)
{
error ("%<-fPIC%>/%<-fpic%> not supported for this target");
/* Clear it to avoid further errors. */
flag_pic = 0;
}
}
/* Check the MicroBlaze CPU version for any special action to be done. */
if (microblaze_select_cpu == NULL)
microblaze_select_cpu = MICROBLAZE_DEFAULT_CPU;
ver = microblaze_version_to_int (microblaze_select_cpu);
if (ver == -1)
{
error ("%qs is an invalid argument to %<-mcpu=%>", microblaze_select_cpu);
}
ver = MICROBLAZE_VERSION_COMPARE (microblaze_select_cpu, "v3.00.a");
if (ver < 0)
{
/* No hardware exceptions in earlier versions. So no worries. */
#if 0
microblaze_select_flags &= ~(MICROBLAZE_MASK_NO_UNSAFE_DELAY);
#endif
microblaze_no_unsafe_delay = 0;
microblaze_pipe = MICROBLAZE_PIPE_3;
}
else if (ver == 0
|| (MICROBLAZE_VERSION_COMPARE (microblaze_select_cpu, "v4.00.b")
== 0))
{
#if 0
microblaze_select_flags |= (MICROBLAZE_MASK_NO_UNSAFE_DELAY);
#endif
microblaze_no_unsafe_delay = 1;
microblaze_pipe = MICROBLAZE_PIPE_3;
}
else
{
/* We agree to use 5 pipe-stage model even on area optimized 3
pipe-stage variants. */
#if 0
microblaze_select_flags &= ~(MICROBLAZE_MASK_NO_UNSAFE_DELAY);
#endif
microblaze_no_unsafe_delay = 0;
microblaze_pipe = MICROBLAZE_PIPE_5;
if (MICROBLAZE_VERSION_COMPARE (microblaze_select_cpu, "v5.00.a") == 0
|| MICROBLAZE_VERSION_COMPARE (microblaze_select_cpu,
"v5.00.b") == 0
|| MICROBLAZE_VERSION_COMPARE (microblaze_select_cpu,
"v5.00.c") == 0)
{
/* Pattern compares are to be turned on by default only when
compiling for MB v5.00.'z'. */
target_flags |= MASK_PATTERN_COMPARE;
}
}
ver = MICROBLAZE_VERSION_COMPARE (microblaze_select_cpu, "v6.00.a");
if (ver < 0)
{
if (TARGET_MULTIPLY_HIGH)
warning (0,
"%<-mxl-multiply-high%> can be used only with "
"%<-mcpu=v6.00.a%> or greater");
}
ver = MICROBLAZE_VERSION_COMPARE (microblaze_select_cpu, "v8.10.a");
microblaze_has_clz = 1;
if (ver < 0)
{
/* MicroBlaze prior to 8.10.a didn't have clz. */
microblaze_has_clz = 0;
}
/* TARGET_REORDER defaults to 2 if -mxl-reorder not specified. */
ver = MICROBLAZE_VERSION_COMPARE (microblaze_select_cpu, "v8.30.a");
if (ver < 0)
{
if (TARGET_REORDER == 1)
warning (0, "%<-mxl-reorder%> can be used only with "
"%<-mcpu=v8.30.a%> or greater");
TARGET_REORDER = 0;
}
else if ((ver == 0) && !TARGET_PATTERN_COMPARE)
{
if (TARGET_REORDER == 1)
warning (0, "%<-mxl-reorder%> requires %<-mxl-pattern-compare%> for "
"%<-mcpu=v8.30.a%>");
TARGET_REORDER = 0;
}
if (TARGET_MULTIPLY_HIGH && TARGET_SOFT_MUL)
error ("%<-mxl-multiply-high%> requires %<-mno-xl-soft-mul%>");
/* Always use DFA scheduler. */
microblaze_sched_use_dfa = 1;
#if 0
microblaze_abicalls = MICROBLAZE_ABICALLS_NO;
#endif
/* Initialize the high, low values for legit floating point constants. */
real_maxval (&dfhigh, 0, DFmode);
real_maxval (&dflow, 1, DFmode);
real_maxval (&sfhigh, 0, SFmode);
real_maxval (&sflow, 1, SFmode);
microblaze_print_operand_punct['?'] = 1;
microblaze_print_operand_punct['#'] = 1;
microblaze_print_operand_punct['&'] = 1;
microblaze_print_operand_punct['!'] = 1;
microblaze_print_operand_punct['*'] = 1;
microblaze_print_operand_punct['@'] = 1;
microblaze_print_operand_punct['.'] = 1;
microblaze_print_operand_punct['('] = 1;
microblaze_print_operand_punct[')'] = 1;
microblaze_print_operand_punct['['] = 1;
microblaze_print_operand_punct[']'] = 1;
microblaze_print_operand_punct['<'] = 1;
microblaze_print_operand_punct['>'] = 1;
microblaze_print_operand_punct['{'] = 1;
microblaze_print_operand_punct['}'] = 1;
microblaze_print_operand_punct['^'] = 1;
microblaze_print_operand_punct['$'] = 1;
microblaze_print_operand_punct['+'] = 1;
/* Set up array to map GCC register number to debug register number.
Ignore the special purpose register numbers. */
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
microblaze_dbx_regno[i] = -1;
start = GP_DBX_FIRST - GP_REG_FIRST;
for (i = GP_REG_FIRST; i <= GP_REG_LAST; i++)
microblaze_dbx_regno[i] = i + start;
/* Set up array giving whether a given register can hold a given mode. */
for (mode = VOIDmode;
mode != MAX_MACHINE_MODE; mode = (machine_mode) ((int) mode + 1))
{
int size = GET_MODE_SIZE (mode);
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
{
int ok;
if (mode == CCmode)
{
ok = (ST_REG_P (regno) || GP_REG_P (regno));
}
else if (GP_REG_P (regno))
ok = ((regno & 1) == 0 || size <= UNITS_PER_WORD);
else
ok = 0;
microblaze_hard_regno_mode_ok_p[(int) mode][regno] = ok;
}
}
}
/* Implement TARGET_HARD_REGNO_MODE_OK. In 32 bit mode, require that
DImode and DFmode be in even registers. For DImode, this makes some
of the insns easier to write, since you don't have to worry about a
DImode value in registers 3 & 4, producing a result in 4 & 5.
To make the code simpler, the hook now just references an
array built in override_options. */
static bool
microblaze_hard_regno_mode_ok (unsigned int regno, machine_mode mode)
{
return microblaze_hard_regno_mode_ok_p[mode][regno];
}
/* Implement TARGET_MODES_TIEABLE_P. */
static bool
microblaze_modes_tieable_p (machine_mode mode1, machine_mode mode2)
{
return ((GET_MODE_CLASS (mode1) == MODE_FLOAT
|| GET_MODE_CLASS (mode1) == MODE_COMPLEX_FLOAT)
== (GET_MODE_CLASS (mode2) == MODE_FLOAT
|| GET_MODE_CLASS (mode2) == MODE_COMPLEX_FLOAT));
}
/* Return true if FUNC is an interrupt function as specified
by the "interrupt_handler" attribute. */
static int
microblaze_interrupt_function_p (tree func)
{
tree a;
if (TREE_CODE (func) != FUNCTION_DECL)
return 0;
a = lookup_attribute ("interrupt_handler", DECL_ATTRIBUTES (func));
return a != NULL_TREE;
}
static int
microblaze_fast_interrupt_function_p (tree func)
{
tree a;
if (TREE_CODE (func) != FUNCTION_DECL)
return 0;
a = lookup_attribute ("fast_interrupt", DECL_ATTRIBUTES (func));
return a != NULL_TREE;
}
int
microblaze_break_function_p (tree func)
{
tree a;
if (!func)
return 0;
if (TREE_CODE (func) != FUNCTION_DECL)
return 0;
a = lookup_attribute ("break_handler", DECL_ATTRIBUTES (func));
return a != NULL_TREE;
}
/* Return true if FUNC is an interrupt function which uses
normal return, indicated by the "save_volatiles" attribute. */
static int
microblaze_save_volatiles (tree func)
{
tree a;
if (TREE_CODE (func) != FUNCTION_DECL)
return 0;
a = lookup_attribute ("save_volatiles", DECL_ATTRIBUTES (func));
return a != NULL_TREE;
}
/* Return whether function is tagged with 'interrupt_handler'
or 'fast_interrupt' attribute. Return true if function
should use return from interrupt rather than normal
function return. */
int
microblaze_is_interrupt_variant (void)
{
return (interrupt_handler || fast_interrupt);
}
int
microblaze_is_break_handler (void)
{
return break_handler;
}
/* Determine of register must be saved/restored in call. */
static int
microblaze_must_save_register (int regno)
{
if (pic_offset_table_rtx &&
(regno == MB_ABI_PIC_ADDR_REGNUM) && df_regs_ever_live_p (regno))
return 1;
if (df_regs_ever_live_p (regno) && !call_used_or_fixed_reg_p (regno))
return 1;
if (frame_pointer_needed && (regno == HARD_FRAME_POINTER_REGNUM))
return 1;
if (crtl->calls_eh_return
&& regno == MB_ABI_SUB_RETURN_ADDR_REGNUM)
return 1;
if (!crtl->is_leaf)
{
if (regno == MB_ABI_SUB_RETURN_ADDR_REGNUM)
return 1;
if ((microblaze_is_interrupt_variant () || save_volatiles) &&
(regno >= 3 && regno <= 12))
return 1;
}
if (microblaze_is_interrupt_variant ())
{
if (df_regs_ever_live_p (regno)
|| regno == MB_ABI_MSR_SAVE_REG
|| ((interrupt_handler || fast_interrupt)
&& (regno == MB_ABI_ASM_TEMP_REGNUM
|| regno == MB_ABI_EXCEPTION_RETURN_ADDR_REGNUM)))
return 1;
}
if (save_volatiles)
{
if (df_regs_ever_live_p (regno)
|| regno == MB_ABI_ASM_TEMP_REGNUM
|| regno == MB_ABI_EXCEPTION_RETURN_ADDR_REGNUM)
return 1;
}
if (crtl->calls_eh_return
&& (regno == EH_RETURN_DATA_REGNO (0)
|| regno == EH_RETURN_DATA_REGNO (1)))
return 1;
return 0;
}
/* Return the bytes needed to compute the frame pointer from the current
stack pointer.
MicroBlaze stack frames look like:
Before call After call
+-----------------------+ +-----------------------+
high | | | |
mem. | local variables, | | local variables, |
| callee saved and | | callee saved and |
| temps | | temps |
+-----------------------+ +-----------------------+
| arguments for called | | arguments for called |
| subroutines | | subroutines |
| (optional) | | (optional) |
+-----------------------+ +-----------------------+
| Link register | | Link register |
SP->| | | |
+-----------------------+ +-----------------------+
| |
| local variables, |
| callee saved and |
| temps |
+-----------------------+
| MSR (optional if, |
| interrupt handler) |
+-----------------------+
| |
| alloca allocations |
| |
+-----------------------+
| |
| arguments for called |
| subroutines |
| (optional) |
| |
+-----------------------+
| Link register |
low FP,SP->| |
memory +-----------------------+
*/
static HOST_WIDE_INT
compute_frame_size (HOST_WIDE_INT size)
{
int regno;
HOST_WIDE_INT total_size; /* # bytes that the entire frame takes up. */
HOST_WIDE_INT var_size; /* # bytes that local variables take up. */
HOST_WIDE_INT args_size; /* # bytes that outgoing arguments take up. */
int link_debug_size; /* # bytes for link register. */
HOST_WIDE_INT gp_reg_size; /* # bytes needed to store calle-saved gp regs. */
long mask; /* mask of saved gp registers. */
interrupt_handler =
microblaze_interrupt_function_p (current_function_decl);
break_handler =
microblaze_break_function_p (current_function_decl);
fast_interrupt =
microblaze_fast_interrupt_function_p (current_function_decl);
save_volatiles = microblaze_save_volatiles (current_function_decl);
if (break_handler)
interrupt_handler = break_handler;
gp_reg_size = 0;
mask = 0;
var_size = size;
args_size = crtl->outgoing_args_size;
if ((args_size == 0) && cfun->calls_alloca)
args_size = NUM_OF_ARGS * UNITS_PER_WORD;
total_size = var_size + args_size;
if (flag_pic == 2 && !TARGET_PIC_DATA_TEXT_REL)
/* force setting GOT. */
df_set_regs_ever_live (MB_ABI_PIC_ADDR_REGNUM, true);
/* Calculate space needed for gp registers. */
for (regno = GP_REG_FIRST; regno <= GP_REG_LAST; regno++)
{
if (microblaze_must_save_register (regno))
{
if (regno != MB_ABI_SUB_RETURN_ADDR_REGNUM)
/* Don't account for link register. It is accounted specially below. */
gp_reg_size += GET_MODE_SIZE (SImode);
mask |= (1L << (regno - GP_REG_FIRST));
}
}
total_size += gp_reg_size;
/* Add 4 bytes for MSR. */
if (microblaze_is_interrupt_variant ())
total_size += 4;
/* No space to be allocated for link register in leaf functions with no other
stack requirements. */
if (total_size == 0 && crtl->is_leaf)
link_debug_size = 0;
else
link_debug_size = UNITS_PER_WORD;
total_size += link_debug_size;
/* Save other computed information. */
current_frame_info.total_size = total_size;
current_frame_info.var_size = var_size;
current_frame_info.args_size = args_size;
current_frame_info.gp_reg_size = gp_reg_size;
current_frame_info.mask = mask;
current_frame_info.initialized = reload_completed;
current_frame_info.num_gp = gp_reg_size / UNITS_PER_WORD;
current_frame_info.link_debug_size = link_debug_size;
if (mask)
/* Offset from which to callee-save GP regs. */
current_frame_info.gp_offset = (total_size - gp_reg_size);
else
current_frame_info.gp_offset = 0;
/* Ok, we're done. */
return total_size;
}
/* Make sure that we're not trying to eliminate to the wrong hard frame
pointer. */
static bool
microblaze_can_eliminate (const int from, const int to)
{
return ((from == RETURN_ADDRESS_POINTER_REGNUM && !leaf_function_p())
|| (to == MB_ABI_SUB_RETURN_ADDR_REGNUM && leaf_function_p())
|| (from != RETURN_ADDRESS_POINTER_REGNUM
&& (to == HARD_FRAME_POINTER_REGNUM
|| (to == STACK_POINTER_REGNUM && !frame_pointer_needed))));
}
/* Implement INITIAL_ELIMINATION_OFFSET. FROM is either the frame
pointer or argument pointer or the return address pointer. TO is either
the stack pointer or hard frame pointer. */
HOST_WIDE_INT
microblaze_initial_elimination_offset (int from, int to)
{
HOST_WIDE_INT offset;
switch (from)
{
case FRAME_POINTER_REGNUM:
offset = 0;
break;
case ARG_POINTER_REGNUM:
if (to == STACK_POINTER_REGNUM || to == HARD_FRAME_POINTER_REGNUM)
offset = compute_frame_size (get_frame_size ());
else
gcc_unreachable ();
break;
case RETURN_ADDRESS_POINTER_REGNUM:
if (crtl->is_leaf)
offset = 0;
else
offset = current_frame_info.gp_offset +
((UNITS_PER_WORD - (POINTER_SIZE / BITS_PER_UNIT)));
break;
default:
gcc_unreachable ();
}
return offset;
}
/* Print operands using format code.
The MicroBlaze specific codes are:
'X' X is CONST_INT, prints 32 bits in hexadecimal format = "0x%08x",
'x' X is CONST_INT, prints 16 bits in hexadecimal format = "0x%04x",
'F' op is CONST_DOUBLE, print 32 bits in hex,
'd' output integer constant in decimal,
'z' if the operand is 0, use $0 instead of normal operand.
'D' print second register of double-word register operand.
'L' print low-order register of double-word register operand.
'M' print high-order register of double-word register operand.
'C' print part of opcode for a branch condition.
'N' print part of opcode for a branch condition, inverted.
'S' X is CODE_LABEL, print with prefix of "LS" (for embedded switch).
'B' print 'z' for EQ, 'n' for NE
'b' print 'n' for EQ, 'z' for NE
'T' print 'f' for EQ, 't' for NE
't' print 't' for EQ, 'f' for NE
'm' Print 1<<operand.
'i' Print 'i' if MEM operand has immediate value
'y' Print 'y' if MEM operand is single register
'o' Print operand address+4
'?' Print 'd' if we use a branch with delay slot instead of normal branch.
'h' Print high word of const_double (int or float) value as hex
'j' Print low word of const_double (int or float) value as hex
's' Print -1 if operand is negative, 0 if positive (sign extend)
'@' Print the name of the temporary register (rMB_ABI_ASM_TEMP_REGNUM).
'#' Print nop if the delay slot of a branch is not filled.
*/
void
print_operand (FILE * file, rtx op, int letter)
{
enum rtx_code code;
if (PRINT_OPERAND_PUNCT_VALID_P (letter))
{
switch (letter)
{
case '?':
/* Conditionally add a 'd' to indicate filled delay slot. */
if (final_sequence != NULL)
fputs ("d", file);
break;
case '#':
/* Conditionally add a nop in unfilled delay slot. */
if (final_sequence == NULL)
fputs ("nop\t\t# Unfilled delay slot\n", file);
break;
case '@':
fputs (reg_names[GP_REG_FIRST + MB_ABI_ASM_TEMP_REGNUM], file);
break;
default:
output_operand_lossage ("unknown punctuation '%c'", letter);
break;
}
return;
}
if (!op)
{
output_operand_lossage ("null pointer");
return;
}
code = GET_CODE (op);
if (code == SIGN_EXTEND)
op = XEXP (op, 0), code = GET_CODE (op);
if (letter == 'C')
switch (code)
{
case EQ:
fputs ("eq", file);
break;
case NE:
fputs ("ne", file);
break;
case GT:
case GTU:
fputs ("gt", file);
break;
case GE:
case GEU:
fputs ("ge", file);
break;
case LT:
case LTU:
fputs ("lt", file);
break;
case LE:
case LEU:
fputs ("le", file);
break;
default:
fatal_insn ("PRINT_OPERAND, invalid insn for %%C", op);
}
else if (letter == 'N')
switch (code)
{
case EQ:
fputs ("ne", file);
break;
case NE:
fputs ("eq", file);
break;
case GT:
case GTU:
fputs ("le", file);
break;
case GE:
case GEU:
fputs ("lt", file);
break;
case LT:
case LTU:
fputs ("ge", file);
break;
case LE:
case LEU:
fputs ("gt", file);
break;
default:
fatal_insn ("PRINT_OPERAND, invalid insn for %%N", op);
}
else if (letter == 'S')
{
char buffer[100];
ASM_GENERATE_INTERNAL_LABEL (buffer, "LS", CODE_LABEL_NUMBER (op));
assemble_name (file, buffer);
}
/* Print 'i' for memory operands which have immediate values. */
else if (letter == 'i')
{
if (code == MEM)
{
struct microblaze_address_info info;
if (!microblaze_classify_address
(&info, XEXP (op, 0), GET_MODE (op), 1))
fatal_insn ("insn contains an invalid address !", op);
switch (info.type)
{
case ADDRESS_REG:
case ADDRESS_CONST_INT:
case ADDRESS_SYMBOLIC:
case ADDRESS_SYMBOLIC_TXT_REL:
case ADDRESS_GOTOFF:
case ADDRESS_TLS:
fputs ("i", file);
break;
case ADDRESS_REG_INDEX:
break;
case ADDRESS_INVALID:
case ADDRESS_PLT:
fatal_insn ("invalid address", op);
}
}
}
else if (code == REG || code == SUBREG)
{
int regnum;
if (code == REG)
regnum = REGNO (op);
else
regnum = true_regnum (op);
if ((letter == 'M' && !WORDS_BIG_ENDIAN)
|| (letter == 'L' && WORDS_BIG_ENDIAN) || letter == 'D')
regnum++;
fprintf (file, "%s", reg_names[regnum]);
}
else if (code == MEM)
if (letter == 'o')
{
rtx op4 = adjust_address (op, GET_MODE (op), 4);
output_address (GET_MODE (op), XEXP (op4, 0));
}
else if (letter == 'y')
{
rtx mem_reg = XEXP (op, 0);
if (GET_CODE (mem_reg) == REG)
{
int regnum = REGNO (mem_reg);
fprintf (file, "%s", reg_names[regnum]);
}
}
else
output_address (GET_MODE (op), XEXP (op, 0));
else if (letter == 'h' || letter == 'j')
{
long val[2];
if (code == CONST_DOUBLE)
{
if (GET_MODE (op) == DFmode)
REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (op), val);
else
{
val[0] = CONST_DOUBLE_HIGH (op);
val[1] = CONST_DOUBLE_LOW (op);
}
}
else if (code == CONST_INT)
{
val[0] = (INTVAL (op) & 0xffffffff00000000LL) >> 32;
val[1] = INTVAL (op) & 0x00000000ffffffffLL;
if (val[0] == 0 && val[1] < 0)
val[0] = -1;
}
fprintf (file, "0x%8.8lx", (letter == 'h') ? val[0] : val[1]);
}
else if (code == CONST_DOUBLE)
{
if (letter == 'F')
{
unsigned long value_long;
REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (op),
value_long);
fprintf (file, "0x%lx", value_long);
}
else
{
char s[60];
real_to_decimal (s, CONST_DOUBLE_REAL_VALUE (op), sizeof (s), 0, 1);
fputs (s, file);
}
}
else if (code == UNSPEC)
{
print_operand_address (file, op);
}
else if (letter == 'x' && GET_CODE (op) == CONST_INT)
fprintf (file, HOST_WIDE_INT_PRINT_HEX, 0xffff & INTVAL (op));
else if (letter == 'X' && GET_CODE (op) == CONST_INT)
fprintf (file, HOST_WIDE_INT_PRINT_HEX, INTVAL (op));
else if (letter == 'd' && GET_CODE (op) == CONST_INT)
fprintf (file, HOST_WIDE_INT_PRINT_DEC, (INTVAL (op)));
else if (letter == 'z' && GET_CODE (op) == CONST_INT && INTVAL (op) == 0)
fputs (reg_names[GP_REG_FIRST], file);
else if (letter == 's' && GET_CODE (op) == CONST_INT)
if (INTVAL (op) < 0)
fputs ("-1", file);
else
fputs ("0", file);
else if (letter == 'd' || letter == 'x' || letter == 'X' || letter == 's')
output_operand_lossage ("letter %c was found & insn was not CONST_INT", letter);
else if (letter == 'B')
fputs (code == EQ ? "z" : "n", file);
else if (letter == 'b')
fputs (code == EQ ? "n" : "z", file);
else if (letter == 'T')
fputs (code == EQ ? "f" : "t", file);
else if (letter == 't')
fputs (code == EQ ? "t" : "f", file);
else if (code == CONST
&& ((GET_CODE (XEXP (op, 0)) == REG)
|| (GET_CODE (XEXP (op, 0)) == UNSPEC)))
{
print_operand (file, XEXP (op, 0), letter);
}
else if (code == CONST
&& (GET_CODE (XEXP (op, 0)) == PLUS)
&& (GET_CODE (XEXP (XEXP (op, 0), 0)) == REG)
&& (GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST))
{
print_operand_address (file, XEXP (op, 0));
}
else if (letter == 'm')
fprintf (file, "%ld", (1L << INTVAL (op)));
else
output_addr_const (file, op);
}
/* A C compound statement to output to stdio stream STREAM the
assembler syntax for an instruction operand that is a memory
reference whose address is ADDR. ADDR is an RTL expression.
Possible address classifications and output formats are,
ADDRESS_REG "%0, r0"
ADDRESS_REG with non-zero "%0, <addr_const>"
offset
ADDRESS_REG_INDEX "rA, RB"
(if rA is r0, rA and rB are swapped)
ADDRESS_CONST_INT "r0, <addr_const>"
ADDRESS_SYMBOLIC "rBase, <addr_const>"
(rBase is a base register suitable for the
symbol's type)
*/
void
print_operand_address (FILE * file, rtx addr)
{
struct microblaze_address_info info;
enum microblaze_address_type type;
if (!microblaze_classify_address (&info, addr, GET_MODE (addr), 2))
fatal_insn ("insn contains an invalid address !", addr);
type = info.type;
switch (info.type)
{
case ADDRESS_REG:
fprintf (file, "%s,", reg_names[REGNO (info.regA)]);
output_addr_const (file, info.offset);
break;
case ADDRESS_REG_INDEX:
if (REGNO (info.regA) == 0)
/* Make rB == r0 instead of rA == r0. This helps reduce read port
congestion. */
fprintf (file, "%s,%s", reg_names[REGNO (info.regB)],
reg_names[REGNO (info.regA)]);
else if (REGNO (info.regB) != 0)
/* This is a silly swap to help Dhrystone. */
fprintf (file, "%s,%s", reg_names[REGNO (info.regB)],
reg_names[REGNO (info.regA)]);
break;
case ADDRESS_CONST_INT:
fprintf (file, "%s,", reg_names[REGNO (info.regA)]);
output_addr_const (file, info.offset);
break;
case ADDRESS_SYMBOLIC:
case ADDRESS_SYMBOLIC_TXT_REL:
case ADDRESS_GOTOFF:
case ADDRESS_PLT:
case ADDRESS_TLS:
if (info.regA)
fprintf (file, "%s,", reg_names[REGNO (info.regA)]);
output_addr_const (file, info.symbol);
if (type == ADDRESS_GOTOFF)
{
fputs ("@GOT", file);
}
else if (type == ADDRESS_PLT)
{
fputs ("@PLT", file);
}
else if (type == ADDRESS_SYMBOLIC_TXT_REL)
{
if (info.offset != NULL && CONST_INT_P (info.offset)
&& INTVAL (info.offset) > 0)
{
fprintf (file, "+");
output_addr_const (file, info.offset);
}
fputs ("@TXTREL", file);
}
else if (type == ADDRESS_TLS)
{
switch (info.tls_type)
{
case TLS_GD:
fputs ("@TLSGD", file);
break;
case TLS_LDM:
fputs ("@TLSLDM", file);
break;
case TLS_DTPREL:
fputs ("@TLSDTPREL", file);
break;
default :
abort();
break;
}
}
break;
case ADDRESS_INVALID:
fatal_insn ("invalid address", addr);
break;
}
}
/* Emit either a label, .comm, or .lcomm directive, and mark that the symbol
is used, so that we don't emit an .extern for it in
microblaze_asm_file_end. */
void
microblaze_declare_object (FILE * stream, const char *name,
const char *section, const char *fmt, int size)
{
fputs (section, stream);
assemble_name (stream, name);
fprintf (stream, fmt, size);
}
/* Common code to emit the insns (or to write the instructions to a file)
to save/restore registers.
Other parts of the code assume that MICROBLAZE_TEMP1_REGNUM (aka large_reg)
is not modified within save_restore_insns. */
#define BITSET_P(VALUE,BIT) (((VALUE) & (1L << (BIT))) != 0)
/* Save or restore instructions based on whether this is the prologue or
epilogue. prologue is 1 for the prologue. */
static void
save_restore_insns (int prologue)
{
rtx base_reg_rtx, reg_rtx, mem_rtx, /* msr_rtx, */ isr_reg_rtx =
0, isr_mem_rtx = 0;
rtx isr_msr_rtx = 0, insn;
long mask = current_frame_info.mask;
HOST_WIDE_INT gp_offset;
int regno;
if (frame_pointer_needed
&& !BITSET_P (mask, HARD_FRAME_POINTER_REGNUM - GP_REG_FIRST))
gcc_unreachable ();
if (mask == 0)
return;
/* Save registers starting from high to low. The debuggers prefer at least
the return register be stored at func+4, and also it allows us not to
need a nop in the epilog if at least one register is reloaded in
addition to return address. */
/* Pick which pointer to use as a base register. For small frames, just
use the stack pointer. Otherwise, use a temporary register. Save 2
cycles if the save area is near the end of a large frame, by reusing
the constant created in the prologue/epilogue to adjust the stack
frame. */
gp_offset = current_frame_info.gp_offset;
gcc_assert (gp_offset > 0);
base_reg_rtx = stack_pointer_rtx;
/* For interrupt_handlers, need to save/restore the MSR. */
if (microblaze_is_interrupt_variant ())
{
isr_mem_rtx = gen_rtx_MEM (SImode,
gen_rtx_PLUS (Pmode, base_reg_rtx,
GEN_INT (current_frame_info.
gp_offset -
UNITS_PER_WORD)));
/* Do not optimize in flow analysis. */
MEM_VOLATILE_P (isr_mem_rtx) = 1;
isr_reg_rtx = gen_rtx_REG (SImode, MB_ABI_MSR_SAVE_REG);
isr_msr_rtx = gen_rtx_REG (SImode, ST_REG);
}
if (microblaze_is_interrupt_variant () && !prologue)
{
emit_move_insn (isr_reg_rtx, isr_mem_rtx);
emit_move_insn (isr_msr_rtx, isr_reg_rtx);
/* Do not optimize in flow analysis. */
emit_insn (gen_rtx_USE (SImode, isr_reg_rtx));
emit_insn (gen_rtx_USE (SImode, isr_msr_rtx));
}
for (regno = GP_REG_FIRST; regno <= GP_REG_LAST; regno++)
{
if (BITSET_P (mask, regno - GP_REG_FIRST))
{
if (regno == MB_ABI_SUB_RETURN_ADDR_REGNUM)
/* Don't handle here. Already handled as the first register. */
continue;
reg_rtx = gen_rtx_REG (SImode, regno);
insn = gen_rtx_PLUS (Pmode, base_reg_rtx, GEN_INT (gp_offset));
mem_rtx = gen_rtx_MEM (SImode, insn);
if (microblaze_is_interrupt_variant () || save_volatiles)
/* Do not optimize in flow analysis. */
MEM_VOLATILE_P (mem_rtx) = 1;
if (prologue)
{
insn = emit_move_insn (mem_rtx, reg_rtx);
RTX_FRAME_RELATED_P (insn) = 1;
}
else
{
insn = emit_move_insn (reg_rtx, mem_rtx);
}
gp_offset += GET_MODE_SIZE (SImode);
}
}
if (microblaze_is_interrupt_variant () && prologue)
{
emit_move_insn (isr_reg_rtx, isr_msr_rtx);
emit_move_insn (isr_mem_rtx, isr_reg_rtx);
/* Do not optimize in flow analysis. */
emit_insn (gen_rtx_USE (SImode, isr_reg_rtx));
emit_insn (gen_rtx_USE (SImode, isr_msr_rtx));
}
/* Done saving and restoring */
}
/* Set up the stack and frame (if desired) for the function. */
static void
microblaze_function_prologue (FILE * file)
{
const char *fnname;
long fsiz = current_frame_info.total_size;
/* Get the function name the same way that toplev.c does before calling
assemble_start_function. This is needed so that the name used here
exactly matches the name used in ASM_DECLARE_FUNCTION_NAME. */
fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
if (!flag_inhibit_size_directive)
{
fputs ("\t.ent\t", file);
if (interrupt_handler && strcmp (INTERRUPT_HANDLER_NAME, fnname))
fputs ("_interrupt_handler", file);
else if (break_handler && strcmp (BREAK_HANDLER_NAME, fnname))
fputs ("_break_handler", file);
else if (fast_interrupt && strcmp (FAST_INTERRUPT_NAME, fnname))
fputs ("_fast_interrupt", file);
else
assemble_name (file, fnname);
fputs ("\n", file);
if (!microblaze_is_interrupt_variant ())
ASM_OUTPUT_TYPE_DIRECTIVE (file, fnname, "function");
}
assemble_name (file, fnname);
fputs (":\n", file);
if (interrupt_handler && strcmp (INTERRUPT_HANDLER_NAME, fnname))
fputs ("_interrupt_handler:\n", file);
if (break_handler && strcmp (BREAK_HANDLER_NAME, fnname))
fputs ("_break_handler:\n", file);
if (!flag_inhibit_size_directive)
{
/* .frame FRAMEREG, FRAMESIZE, RETREG. */
fprintf (file,
"\t.frame\t%s,%ld,%s\t\t# vars= %ld, regs= %d, args= %d\n",
(reg_names[(frame_pointer_needed)
? HARD_FRAME_POINTER_REGNUM :
STACK_POINTER_REGNUM]), fsiz,
reg_names[MB_ABI_SUB_RETURN_ADDR_REGNUM + GP_REG_FIRST],
current_frame_info.var_size, current_frame_info.num_gp,
(int) crtl->outgoing_args_size);
fprintf (file, "\t.mask\t0x%08lx\n", current_frame_info.mask);
}
}
/* Output extra assembler code at the end of a prologue. */
static void
microblaze_function_end_prologue (FILE * file)
{
if (TARGET_STACK_CHECK)
{
fprintf (file, "\t# Stack Check Stub -- Start.\n\t");
fprintf (file, "ori\tr18,r0,_stack_end\n\t");
fprintf (file, "cmpu\tr18,r1,r18\n\t");
fprintf (file, "bgei\tr18,_stack_overflow_exit\n\t");
fprintf (file, "# Stack Check Stub -- End.\n");
}
}
static void
microblaze_elf_asm_cdtor (rtx symbol, int priority, bool is_ctor)
{
section *s;
if (priority != DEFAULT_INIT_PRIORITY)
{
char buf[18];
sprintf (buf, "%s.%.5u",
is_ctor ? ".ctors" : ".dtors",
MAX_INIT_PRIORITY - priority);
s = get_section (buf, SECTION_WRITE, NULL_TREE);
}
else if (is_ctor)
s = ctors_section;
else
s = dtors_section;
switch_to_section (s);
assemble_align (POINTER_SIZE);
fputs ("\t.word\t", asm_out_file);
output_addr_const (asm_out_file, symbol);
fputs ("\n", asm_out_file);
}
/* Add a function to the list of static constructors. */
static void
microblaze_elf_asm_constructor (rtx symbol, int priority)
{
microblaze_elf_asm_cdtor (symbol, priority, /*is_ctor=*/true);
}
/* Add a function to the list of static destructors. */
static void
microblaze_elf_asm_destructor (rtx symbol, int priority)
{
microblaze_elf_asm_cdtor (symbol, priority, /*is_ctor=*/false);
}
/* Expand the prologue into a bunch of separate insns. */
void
microblaze_expand_prologue (void)
{
int regno;
HOST_WIDE_INT fsiz;
const char *arg_name = 0;
tree fndecl = current_function_decl;
tree fntype = TREE_TYPE (fndecl);
tree fnargs = DECL_ARGUMENTS (fndecl);
rtx next_arg_reg;