1998-03-29 12:14:27 +04:00
|
|
|
|
/* Subroutines for insn-output.c for Clipper
|
|
|
|
|
Copyright (C) 1987, 1988, 1991, 1997 Free Software Foundation, Inc.
|
|
|
|
|
Contributed by Holger Teutsch (holger@hotbso.rhein-main.de)
|
|
|
|
|
|
|
|
|
|
This file is part of GNU CC.
|
|
|
|
|
|
|
|
|
|
GNU CC is free software; you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
|
|
|
any later version.
|
|
|
|
|
|
|
|
|
|
GNU CC is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with GNU CC; see the file COPYING. If not, write to
|
|
|
|
|
the Free Software Foundation, 59 Temple Place - Suite 330,
|
|
|
|
|
Boston, MA 02111-1307, USA. */
|
|
|
|
|
|
|
|
|
|
#include "config.h"
|
1998-08-16 21:35:45 +04:00
|
|
|
|
#include <stdio.h>
|
1998-03-29 12:14:27 +04:00
|
|
|
|
#include "rtl.h"
|
|
|
|
|
#include "regs.h"
|
|
|
|
|
#include "hard-reg-set.h"
|
|
|
|
|
#include "real.h"
|
|
|
|
|
#include "insn-config.h"
|
|
|
|
|
#include "conditions.h"
|
|
|
|
|
#include "insn-flags.h"
|
|
|
|
|
#include "output.h"
|
|
|
|
|
#include "insn-attr.h"
|
|
|
|
|
#include "tree.h"
|
|
|
|
|
#include "c-tree.h"
|
|
|
|
|
#include "expr.h"
|
|
|
|
|
#include "flags.h"
|
|
|
|
|
#include "machmode.h"
|
|
|
|
|
|
|
|
|
|
extern char regs_ever_live[];
|
|
|
|
|
|
|
|
|
|
extern int frame_pointer_needed;
|
|
|
|
|
|
|
|
|
|
static int frame_size;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* compute size of a clipper stack frame where 'lsize' is the required
|
|
|
|
|
* space for local variables.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
clipper_frame_size (lsize)
|
|
|
|
|
int lsize;
|
|
|
|
|
{
|
|
|
|
|
int i,size; /* total size of frame */
|
|
|
|
|
int save_size;
|
|
|
|
|
save_size = 0; /* compute size for reg saves */
|
|
|
|
|
|
|
|
|
|
for (i = 16; i < 32; i++)
|
|
|
|
|
if (regs_ever_live[i] && !call_used_regs[i])
|
|
|
|
|
save_size += 8;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 16; i++)
|
|
|
|
|
if (regs_ever_live[i] && !call_used_regs[i])
|
|
|
|
|
save_size += 4;
|
|
|
|
|
|
|
|
|
|
size = lsize + save_size;
|
|
|
|
|
|
|
|
|
|
size = (size + 7) & ~7; /* align to 64 Bit */
|
|
|
|
|
return size;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* prologue and epilogue output
|
|
|
|
|
* function is entered with pc pushed, i.e. stack is 32 bit aligned
|
|
|
|
|
*
|
|
|
|
|
* current_function_args_size == 0 means that the current function's args
|
|
|
|
|
* are passed totally in registers i.e fp is not used as ap.
|
|
|
|
|
* If frame_size is also 0 the current function does not push anything and
|
|
|
|
|
* can run with misaligned stack -> subq $4,sp / add $4,sp on entry and exit
|
|
|
|
|
* can be omitted.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
output_function_prologue (file, lsize)
|
|
|
|
|
FILE *file;
|
|
|
|
|
int lsize; /* size for locals */
|
|
|
|
|
{
|
|
|
|
|
int i, offset;
|
|
|
|
|
int size;
|
|
|
|
|
|
|
|
|
|
frame_size = size = clipper_frame_size (lsize);
|
|
|
|
|
|
|
|
|
|
if (frame_pointer_needed)
|
|
|
|
|
{
|
|
|
|
|
fputs ("\tpushw fp,sp\n", file);
|
|
|
|
|
fputs ("\tmovw sp,fp\n", file);
|
|
|
|
|
}
|
|
|
|
|
else if (size != 0 || current_function_args_size != 0)
|
|
|
|
|
{
|
|
|
|
|
size += 4; /* keep stack aligned */
|
|
|
|
|
frame_size = size; /* must push data or access args */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (size)
|
|
|
|
|
{
|
|
|
|
|
if (size < 16)
|
|
|
|
|
fprintf (file, "\tsubq $%d,sp\n", size);
|
|
|
|
|
else
|
|
|
|
|
fprintf (file, "\tsubi $%d,sp\n", size);
|
|
|
|
|
|
|
|
|
|
/* register save slots are relative to sp, because we have small positive
|
|
|
|
|
displacements and this works whether we have a frame pointer or not */
|
|
|
|
|
|
|
|
|
|
offset = 0;
|
|
|
|
|
for (i = 16; i < 32; i++)
|
|
|
|
|
if (regs_ever_live[i] && !call_used_regs[i])
|
|
|
|
|
{
|
|
|
|
|
if (offset == 0)
|
|
|
|
|
fprintf (file, "\tstord f%d,(sp)\n", i-16);
|
|
|
|
|
else
|
|
|
|
|
fprintf (file, "\tstord f%d,%d(sp)\n", i-16, offset);
|
|
|
|
|
offset += 8;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 16; i++)
|
|
|
|
|
if (regs_ever_live[i] && !call_used_regs[i])
|
|
|
|
|
{
|
|
|
|
|
if (offset == 0)
|
|
|
|
|
fprintf (file, "\tstorw r%d,(sp)\n", i);
|
|
|
|
|
else
|
|
|
|
|
fprintf (file, "\tstorw r%d,%d(sp)\n", i, offset);
|
|
|
|
|
offset += 4;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
output_function_epilogue (file, size)
|
|
|
|
|
FILE *file;
|
|
|
|
|
int size; /* ignored */
|
|
|
|
|
{
|
|
|
|
|
int i, offset;
|
|
|
|
|
|
|
|
|
|
if (frame_pointer_needed)
|
|
|
|
|
{
|
|
|
|
|
offset = -frame_size;
|
|
|
|
|
|
|
|
|
|
for (i = 16; i < 32; i++)
|
|
|
|
|
if (regs_ever_live[i] && !call_used_regs[i])
|
|
|
|
|
{
|
|
|
|
|
fprintf (file, "\tloadd %d(fp),f%d\n", offset, i-16);
|
|
|
|
|
offset += 8;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 16; i++)
|
|
|
|
|
if (regs_ever_live[i] && !call_used_regs[i])
|
|
|
|
|
{
|
|
|
|
|
fprintf (file, "\tloadw %d(fp),r%d\n", offset, i);
|
|
|
|
|
offset += 4;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fputs ("\tmovw fp,sp\n\tpopw sp,fp\n\tret sp\n",
|
|
|
|
|
file);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
else /* no frame pointer */
|
|
|
|
|
{
|
|
|
|
|
offset = 0;
|
|
|
|
|
|
|
|
|
|
for (i = 16; i < 32; i++)
|
|
|
|
|
if (regs_ever_live[i] && !call_used_regs[i])
|
|
|
|
|
{
|
|
|
|
|
if (offset == 0)
|
|
|
|
|
fprintf (file, "\tloadd (sp),f%d\n", i-16);
|
|
|
|
|
else
|
|
|
|
|
fprintf (file, "\tloadd %d(sp),f%d\n", offset, i-16);
|
|
|
|
|
offset += 8;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < 16; i++)
|
|
|
|
|
if (regs_ever_live[i] && !call_used_regs[i])
|
|
|
|
|
{
|
|
|
|
|
if (offset == 0)
|
|
|
|
|
fprintf (file, "\tloadw (sp),r%d\n", i);
|
|
|
|
|
else
|
|
|
|
|
fprintf (file, "\tloadw %d(sp),r%d\n", offset, i);
|
|
|
|
|
offset += 4;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (frame_size > 0)
|
|
|
|
|
{
|
|
|
|
|
if (frame_size < 16)
|
|
|
|
|
fprintf (file, "\taddq $%d,sp\n", frame_size);
|
|
|
|
|
else
|
|
|
|
|
fprintf (file, "\taddi $%d,sp\n", frame_size);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fputs ("\tret sp\n", file);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* blockmove
|
|
|
|
|
*
|
|
|
|
|
* clipper_movstr ()
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
clipper_movstr (operands)
|
|
|
|
|
rtx *operands;
|
|
|
|
|
{
|
|
|
|
|
rtx dst,src,cnt,tmp,top,bottom,xops[3];
|
|
|
|
|
int align;
|
|
|
|
|
int fixed;
|
|
|
|
|
|
|
|
|
|
extern FILE *asm_out_file;
|
|
|
|
|
|
|
|
|
|
dst = operands[0];
|
|
|
|
|
src = operands[1];
|
|
|
|
|
/* don't change this operands[2]; gcc 2.3.3 doesn't honor clobber note */
|
|
|
|
|
align = INTVAL (operands[3]);
|
|
|
|
|
tmp = operands[4];
|
|
|
|
|
cnt = operands[5];
|
|
|
|
|
|
|
|
|
|
if (GET_CODE (operands[2]) == CONST_INT) /* fixed size move */
|
|
|
|
|
{
|
|
|
|
|
if ((fixed = INTVAL (operands[2])) <= 0)
|
|
|
|
|
abort ();
|
|
|
|
|
|
|
|
|
|
if (fixed <16)
|
|
|
|
|
output_asm_insn ("loadq %2,%5", operands);
|
|
|
|
|
else
|
|
|
|
|
output_asm_insn ("loadi %2,%5", operands);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
fixed = 0;
|
|
|
|
|
bottom = (rtx)gen_label_rtx (); /* need a bottom label */
|
|
|
|
|
xops[0] = cnt; xops[1] = bottom;
|
|
|
|
|
output_asm_insn ("movw %2,%5", operands); /* count is scratch reg 5 */
|
|
|
|
|
output_asm_insn ("brle %l1", xops);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
top = (rtx)gen_label_rtx (); /* top of loop label */
|
|
|
|
|
ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (top));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
xops[0] = src; xops[1] = tmp; xops[2] = dst;
|
|
|
|
|
|
|
|
|
|
if (fixed && (align & 0x3) == 0) /* word aligned move with known size */
|
|
|
|
|
{
|
|
|
|
|
if (fixed >= 4)
|
|
|
|
|
{
|
|
|
|
|
rtx xops1[2];
|
|
|
|
|
output_asm_insn(
|
|
|
|
|
"loadw %a0,%1\n\taddq $4,%0\n\tstorw %1,%a2\n\taddq $4,%2",
|
|
|
|
|
xops);
|
|
|
|
|
|
|
|
|
|
xops1[0] = cnt; xops1[1] = top;
|
|
|
|
|
output_asm_insn ("subq $4,%0\n\tbrgt %l1", xops1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (fixed & 0x2)
|
|
|
|
|
{
|
|
|
|
|
output_asm_insn ("loadh %a0,%1\n\tstorh %1,%a2", xops);
|
|
|
|
|
if (fixed & 0x1)
|
|
|
|
|
output_asm_insn ("loadb 2%a0,%1\n\tstorb %1,2%a2", xops);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
if (fixed & 0x1)
|
|
|
|
|
output_asm_insn ("loadb %a0,%1\n\tstorb %1,%a2", xops);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
output_asm_insn(
|
|
|
|
|
"loadb %a0,%1\n\taddq $1,%0\n\tstorb %1,%a2\n\taddq $1,%2",
|
|
|
|
|
xops);
|
|
|
|
|
|
|
|
|
|
xops[0] = cnt; xops[1] = top;
|
|
|
|
|
output_asm_insn ("subq $1,%0\n\tbrgt %l1", xops);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (fixed == 0)
|
|
|
|
|
ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (bottom));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
print_operand_address (file, addr)
|
|
|
|
|
FILE *file;
|
|
|
|
|
register rtx addr;
|
|
|
|
|
{
|
|
|
|
|
rtx op0,op1;
|
|
|
|
|
|
|
|
|
|
retry:
|
|
|
|
|
switch (GET_CODE (addr))
|
|
|
|
|
{
|
|
|
|
|
case REG:
|
|
|
|
|
fprintf (file, "(%s)", reg_names[REGNO (addr)]);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case PLUS:
|
|
|
|
|
/* can be 'symbol + reg' or 'reg + reg' */
|
|
|
|
|
|
|
|
|
|
op0 = XEXP (addr, 0);
|
|
|
|
|
op1 = XEXP (addr, 1);
|
|
|
|
|
|
|
|
|
|
if (GET_CODE (op0) == REG && GET_CODE (op1) == REG)
|
|
|
|
|
{
|
|
|
|
|
fprintf (file, "[%s](%s)",
|
|
|
|
|
reg_names[REGNO (op0)], reg_names[REGNO (op1)]);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (GET_CODE (op0) == REG && CONSTANT_ADDRESS_P (op1))
|
|
|
|
|
{
|
|
|
|
|
output_addr_const (file, op1);
|
|
|
|
|
fprintf (file, "(%s)", reg_names[REGNO (op0)]);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (GET_CODE (op1) == REG && CONSTANT_ADDRESS_P (op0))
|
|
|
|
|
{
|
|
|
|
|
output_addr_const (file, op0);
|
|
|
|
|
fprintf (file, "(%s)", reg_names[REGNO (op1)]);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
abort (); /* Oh no */
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
output_addr_const (file, addr);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
char *
|
|
|
|
|
rev_cond_name (op)
|
|
|
|
|
rtx op;
|
|
|
|
|
{
|
|
|
|
|
switch (GET_CODE (op))
|
|
|
|
|
{
|
|
|
|
|
case EQ:
|
|
|
|
|
return "ne";
|
|
|
|
|
case NE:
|
|
|
|
|
return "eq";
|
|
|
|
|
case LT:
|
|
|
|
|
return "ge";
|
|
|
|
|
case LE:
|
|
|
|
|
return "gt";
|
|
|
|
|
case GT:
|
|
|
|
|
return "le";
|
|
|
|
|
case GE:
|
|
|
|
|
return "lt";
|
|
|
|
|
case LTU:
|
|
|
|
|
return "geu";
|
|
|
|
|
case LEU:
|
|
|
|
|
return "gtu";
|
|
|
|
|
case GTU:
|
|
|
|
|
return "leu";
|
|
|
|
|
case GEU:
|
|
|
|
|
return "ltu";
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
abort ();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Do what is necessary for `va_start'. The argument is ignored;
|
|
|
|
|
We fill in an initial va_list. A pointer to this constructor
|
|
|
|
|
is returned. */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct rtx_def *
|
|
|
|
|
clipper_builtin_saveregs (arglist)
|
|
|
|
|
tree arglist;
|
|
|
|
|
{
|
|
|
|
|
extern int current_function_varargs;
|
|
|
|
|
rtx block, addr, argsize, scratch, r0_addr,r1_addr,f0_addr,f1_addr;
|
|
|
|
|
|
|
|
|
|
/* Allocate the va_list constructor + save area for r0,r1,f0,f1 */
|
|
|
|
|
|
|
|
|
|
block = assign_stack_local (BLKmode,
|
|
|
|
|
(6 + 6) * UNITS_PER_WORD, 2 * BITS_PER_WORD);
|
|
|
|
|
|
|
|
|
|
RTX_UNCHANGING_P (block) = 1;
|
|
|
|
|
RTX_UNCHANGING_P (XEXP (block, 0)) = 1;
|
|
|
|
|
|
|
|
|
|
addr = copy_to_reg (XEXP (block, 0));
|
|
|
|
|
|
1998-08-16 21:35:45 +04:00
|
|
|
|
f0_addr = gen_rtx (PLUS, Pmode, addr, GEN_INT (24));
|
|
|
|
|
f1_addr = gen_rtx (PLUS, Pmode, addr, GEN_INT (32));
|
|
|
|
|
r0_addr = gen_rtx (PLUS, Pmode, addr, GEN_INT (40));
|
|
|
|
|
r1_addr = gen_rtx (PLUS, Pmode, addr, GEN_INT (44));
|
1998-03-29 12:14:27 +04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Store float regs */
|
|
|
|
|
|
|
|
|
|
emit_move_insn (gen_rtx (MEM, DFmode, f0_addr), gen_rtx (REG, DFmode, 16));
|
|
|
|
|
emit_move_insn (gen_rtx (MEM, DFmode, f1_addr), gen_rtx (REG, DFmode, 17));
|
|
|
|
|
|
|
|
|
|
/* Store int regs */
|
|
|
|
|
|
|
|
|
|
emit_move_insn (gen_rtx (MEM, SImode, r0_addr), gen_rtx (REG, SImode, 0));
|
|
|
|
|
emit_move_insn (gen_rtx (MEM, SImode, r1_addr), gen_rtx (REG, SImode, 1));
|
|
|
|
|
|
|
|
|
|
/* Store the arg pointer in the __va_stk member. */
|
|
|
|
|
|
|
|
|
|
emit_move_insn (gen_rtx (MEM, SImode, addr),
|
|
|
|
|
copy_to_reg (virtual_incoming_args_rtx));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* now move addresses of the saved regs into the pointer array */
|
|
|
|
|
|
|
|
|
|
scratch = gen_reg_rtx (Pmode);
|
|
|
|
|
|
|
|
|
|
emit_move_insn (scratch, r0_addr);
|
|
|
|
|
emit_move_insn (gen_rtx (MEM, SImode,
|
|
|
|
|
gen_rtx (PLUS, Pmode, addr,
|
1998-08-16 21:35:45 +04:00
|
|
|
|
GEN_INT (4))),
|
1998-03-29 12:14:27 +04:00
|
|
|
|
scratch);
|
|
|
|
|
|
|
|
|
|
emit_move_insn (scratch, f0_addr);
|
|
|
|
|
emit_move_insn (gen_rtx (MEM, SImode,
|
|
|
|
|
gen_rtx (PLUS, Pmode, addr,
|
1998-08-16 21:35:45 +04:00
|
|
|
|
GEN_INT (8))),
|
1998-03-29 12:14:27 +04:00
|
|
|
|
scratch);
|
|
|
|
|
|
|
|
|
|
emit_move_insn (scratch, r1_addr);
|
|
|
|
|
emit_move_insn (gen_rtx (MEM, SImode,
|
|
|
|
|
gen_rtx (PLUS, Pmode, addr,
|
1998-08-16 21:35:45 +04:00
|
|
|
|
GEN_INT (12))),
|
1998-03-29 12:14:27 +04:00
|
|
|
|
scratch);
|
|
|
|
|
|
|
|
|
|
emit_move_insn (scratch, f1_addr);
|
|
|
|
|
emit_move_insn (gen_rtx (MEM, SImode,
|
|
|
|
|
gen_rtx (PLUS, Pmode, addr,
|
1998-08-16 21:35:45 +04:00
|
|
|
|
GEN_INT (16))),
|
1998-03-29 12:14:27 +04:00
|
|
|
|
scratch);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (flag_check_memory_usage)
|
|
|
|
|
{
|
1998-08-16 21:35:45 +04:00
|
|
|
|
emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
|
|
|
|
|
addr, ptr_mode,
|
|
|
|
|
GEN_INT (5 * GET_MODE_SIZE (SImode)),
|
|
|
|
|
TYPE_MODE (sizetype),
|
|
|
|
|
GEN_INT (MEMORY_USE_RW),
|
|
|
|
|
TYPE_MODE (integer_type_node));
|
|
|
|
|
|
|
|
|
|
emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
|
|
|
|
|
f0_addr, ptr_mode,
|
|
|
|
|
GEN_INT (GET_MODE_SIZE (DFmode)),
|
|
|
|
|
TYPE_MODE (sizetype),
|
|
|
|
|
GEN_INT (MEMORY_USE_RW),
|
|
|
|
|
TYPE_MODE (integer_type_node));
|
|
|
|
|
emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
|
|
|
|
|
f1_addr, ptr_mode,
|
|
|
|
|
GEN_INT (GET_MODE_SIZE (DFmode)),
|
|
|
|
|
TYPE_MODE (sizetype),
|
|
|
|
|
GEN_INT (MEMORY_USE_RW),
|
|
|
|
|
TYPE_MODE (integer_type_node));
|
|
|
|
|
emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
|
|
|
|
|
r0_addr, ptr_mode,
|
|
|
|
|
GEN_INT (GET_MODE_SIZE (SImode)),
|
|
|
|
|
TYPE_MODE (sizetype),
|
|
|
|
|
GEN_INT (MEMORY_USE_RW),
|
|
|
|
|
TYPE_MODE (integer_type_node));
|
|
|
|
|
emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
|
|
|
|
|
r1_addr, ptr_mode,
|
|
|
|
|
GEN_INT (GET_MODE_SIZE (SImode)),
|
1998-03-29 12:14:27 +04:00
|
|
|
|
TYPE_MODE (sizetype),
|
1998-08-16 21:35:45 +04:00
|
|
|
|
GEN_INT (MEMORY_USE_RW),
|
|
|
|
|
TYPE_MODE (integer_type_node));
|
1998-03-29 12:14:27 +04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return the address of the va_list constructor, but don't put it in a
|
|
|
|
|
register. This fails when not optimizing and produces worse code when
|
|
|
|
|
optimizing. */
|
|
|
|
|
return XEXP (block, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Return truth value of whether OP can be used as an word register
|
|
|
|
|
operand. Reject (SUBREG:SI (REG:SF )) */
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
int_reg_operand (op, mode)
|
|
|
|
|
rtx op;
|
|
|
|
|
enum machine_mode mode;
|
|
|
|
|
{
|
|
|
|
|
return (register_operand (op, mode) &&
|
|
|
|
|
(GET_CODE (op) != SUBREG ||
|
|
|
|
|
GET_MODE_CLASS (GET_MODE (SUBREG_REG (op))) == MODE_INT));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return truth value of whether OP can be used as a float register
|
|
|
|
|
operand. Reject (SUBREG:SF (REG:SI )) )) */
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
fp_reg_operand (op, mode)
|
|
|
|
|
rtx op;
|
|
|
|
|
enum machine_mode mode;
|
|
|
|
|
{
|
|
|
|
|
return (register_operand (op, mode) &&
|
|
|
|
|
(GET_CODE (op) != SUBREG ||
|
|
|
|
|
GET_MODE_CLASS (GET_MODE (SUBREG_REG (op))) == MODE_FLOAT));
|
|
|
|
|
}
|
|
|
|
|
|