This is out-mips.c in view mode; [Download] [Up]
/* Subroutines for insn-output.c for MIPS
Contributed by A. Lichnewsky, lich@inria.inria.fr.
Changes by Michael Meissner, meissner@osf.org.
Copyright (C) 1989, 1990 Free Software Foundation, Inc.
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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include <stdio.h>
#include <sys/types.h>
#include <sys/file.h>
#include "tree.h"
#include "flags.h"
#ifndef R_OK
#define R_OK 4
#define W_OK 2
#define X_OK 1
#endif
extern void debug_rtx ();
extern void abort_with_insn ();
extern FILE *asm_out_file;
extern tree current_function_decl;
/* Global variables for machine-dependent things. */
char *reg_numchar[] = REGISTER_NUMCHAR;
/* 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 mips_section_threshold = -1;
/* Count the number of .file directives, so that .loc is up to date. */
int num_source_filenames = 0;
/* Count the number of words that are pushed to pass arguments. */
int stack_args_pushed = 0;
/* # bytes for args preallocated by function_prolog. */
int stack_args_preallocated = 0;
/* Count of the number of functions created so far, in order to make
unique labels for omitting the frame pointer. */
int number_functions_processed = 0;
/* Count the number of sdb related labels are generated (to find block
start and end boundaries). */
int sdb_label_count = 0;
/* Next label # for each statment for Silicon Graphics IRIS systems. */
int sym_lineno = 0;
/* Non-zero if inside of a function, because the stupid MIPS asm can't
handle .files inside of functions. */
int inside_function = 0;
/* String to be used for the unique name given to the difference between
the stack pointer and frame pointer when the frame pointer is to be
omitted. */
char *sp_fp_difference = 0;
/* Files to separate the text and the data output, so that all of the data
can be emitted before the text, which will mean that the assembler will
generate smaller code, based on the global pointer. */
FILE *asm_out_data_file;
FILE *asm_out_text_file;
/* Linked list of all externals that are to be emitted when optimizing
for the global pointer if they haven't been declared by the end of
the program with an appropriate .comm or initialization. */
struct extern_list {
struct extern_list *next; /* next external */
char *name; /* name of the external */
int size; /* size in bytes */
} *extern_head = 0;
/* Name of the current function. */
char *current_function_name;
/* Size of the frame allocated for this function. */
int current_function_total_framesize;
/* Number of bytes used to hold saved registers. */
int current_function_saved_reg_size;
/* Return truth value of whether OP can be used as an operands
where a register or 16 bit unsigned integer is needed. */
int
uns_arith_operand (op, mode)
rtx op;
enum machine_mode mode;
{
return (register_operand (op, mode)
|| (GET_CODE (op) == CONST_INT && SMALL_INT_UNSIGNED (op)));
}
/* Return truth value of whether OP can be used as an operands
where a 16 bit integer is needed */
int
arith_operand (op, mode)
rtx op;
enum machine_mode mode;
{
return (register_operand (op, mode)
|| (GET_CODE (op) == CONST_INT && SMALL_INT (op)));
}
/* Return truth value of whether OP can be used as an operand in a two
address arithmetic insn (such as set 123456,%o4) of mode MODE. */
int
arith32_operand (op, mode)
rtx op;
enum machine_mode mode;
{
return (register_operand (op, mode) || GET_CODE (op) == CONST_INT);
}
/* Return truth value of whether OP is a integer which fits in 16 bits */
int
small_int (op, mode)
rtx op;
enum machine_mode mode;
{
return (GET_CODE (op) == CONST_INT && SMALL_INT (op));
}
/* Argument support functions. */
/* Initialize CUMULATIVE_ARGS for a function. */
void
init_cumulative_args (cum, fntype)
CUMULATIVE_ARGS cum; /* argument info to initialize */
tree fntype; /* tree ptr for function decl */
{
tree param, next_param;
if (TARGET_DEBUGE_MODE)
{
fprintf (stderr, "\ninit_cumulative_args\n");
if (fntype != (tree)0)
{
putc ('\n', stderr);
debug_tree (fntype);
putc ('\n', stderr);
}
}
cum->gp_reg_found = 0;
cum->arg_number = 0;
cum->arg_words = 0;
/* 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 MIPS calling sequence
passes all arguments in the general purpose registers in this
case. */
for (param = (fntype) ? TYPE_ARG_TYPES (fntype) : 0;
param != (tree)0;
param = next_param)
{
next_param = TREE_CHAIN (param);
if (next_param == (tree)0 && TREE_VALUE (param) != void_type_node)
cum->gp_reg_found = 1;
}
/* Determine if the function is returning a structure, if so,
advance by one argument. */
if (fntype
&& (TREE_CODE (fntype) == FUNCTION_TYPE || TREE_CODE (fntype) == METHOD_TYPE)
&& TREE_TYPE (fntype) != 0)
{
tree ret_type = TREE_TYPE (fntype);
enum tree_code ret_code = TREE_CODE (ret_type);
if (ret_code == RECORD_TYPE || ret_code == UNION_TYPE)
{
cum->gp_reg_found = 1;
cum->arg_number = 1;
cum->arg_words = 1;
}
}
}
/* Advance the argument to the next argument position. */
void
function_arg_advance (cum, mode, type, named)
CUMULATIVE_ARGS cum; /* current arg information */
enum machine_mode mode; /* current arg mode */
tree type; /* type of the argument or 0 if lib support */
{
if (TARGET_DEBUGE_MODE)
fprintf (stderr,
"function_adv( {gp reg found = %d, arg # = %2d, words = %2d}, %4s, 0x%.8x, %d )\n",
cum->gp_reg_found, cum->arg_number, cum->arg_words, GET_MODE_NAME (mode),
type, named);
cum->arg_number++;
switch (mode)
{
default:
error ("Illegal mode given to function_arg_advance");
break;
case VOIDmode:
break;
case BLKmode:
cum->gp_reg_found = 1;
cum->arg_words += (int_size_in_bytes (type) + 3) / 4;
break;
case SFmode:
cum->arg_words++;
break;
case DFmode:
cum->arg_words += 2;
break;
case DImode:
cum->gp_reg_found = 1;
cum->arg_words += 2;
break;
case QImode:
case HImode:
case SImode:
cum->gp_reg_found = 1;
cum->arg_words++;
break;
}
}
/* Return a RTL expression containing the register for the given mode,
or 0 if the argument is too be passed on the stack. */
struct rtx_def *
function_arg (cum, mode, type, named)
CUMULATIVE_ARGS cum; /* current arg information */
enum machine_mode mode; /* current arg mode */
tree type; /* type of the argument or 0 if lib support */
int named; /* != 0 for normal args, == 0 for ... args */
{
int regbase = -1;
int bias = 0;
if (TARGET_DEBUGE_MODE)
fprintf (stderr,
"function_arg( {gp reg found = %d, arg # = %2d, words = %2d}, %4s, 0x%.8x, %d ) = ",
cum->gp_reg_found, cum->arg_number, cum->arg_words, GET_MODE_NAME (mode),
type, named);
switch (mode)
{
default:
error ("Illegal mode given to function_arg");
break;
case SFmode:
if (cum->gp_reg_found || cum->arg_number >= 2)
regbase = GP_ARG_FIRST;
else {
regbase = FP_ARG_FIRST;
if (cum->arg_words == 1) /* first arg was float */
bias = 1; /* use correct reg */
}
break;
case DFmode:
cum->arg_words += (cum->arg_words & 1);
regbase = (cum->gp_reg_found) ? GP_ARG_FIRST : FP_ARG_FIRST;
break;
case VOIDmode:
case BLKmode:
case QImode:
case HImode:
case SImode:
case DImode:
regbase = GP_ARG_FIRST;
break;
}
if (cum->arg_words >= MAX_ARGS_IN_REGISTERS)
{
if (TARGET_DEBUGE_MODE)
fprintf (stderr, "<stack>\n");
return 0;
}
if (regbase == -1)
abort ();
if (TARGET_DEBUGE_MODE)
fprintf (stderr, "%s\n", reg_numchar[ regbase + cum->arg_number + bias ]);
return gen_rtx (REG, mode, regbase + cum->arg_words + bias);
}
int
function_arg_partial_nregs (cum, mode, type, named)
CUMULATIVE_ARGS cum; /* current arg information */
enum machine_mode mode; /* current arg mode */
tree type; /* type of the argument or 0 if lib support */
int named; /* != 0 for normal args, == 0 for ... args */
{
if (mode == BLKmode && cum->arg_words < MAX_ARGS_IN_REGISTERS)
{
int words = (int_size_in_bytes (type) + 3) / 4;
if (words + cum->arg_words < MAX_ARGS_IN_REGISTERS)
return 0; /* structure fits in registers */
if (TARGET_DEBUGE_MODE)
fprintf (stderr, "function_arg_partial_nregs = %d\n",
MAX_ARGS_IN_REGISTERS - cum->arg_words);
return MAX_ARGS_IN_REGISTERS - cum->arg_words;
}
else if (mode == DImode && cum->arg_words == MAX_ARGS_IN_REGISTERS-1)
{
if (TARGET_DEBUGE_MODE)
fprintf (stderr, "function_arg_partial_nregs = 1\n");
return 1;
}
return 0;
}
/* Routines to merge the compare and branch operators into a single entity. */
static rtx branch_cmp_op[2];
static enum machine_mode branch_cmp_mode;
/* Save the mode and operands on the current compare operator. */
void
compare_collect (mode, op0, op1)
enum machine_mode mode;
rtx op0;
rtx op1;
{
if (TARGET_DEBUGD_MODE)
{
fprintf (stderr, "compare_collect mode = %s, operands::",
GET_MODE_NAME (mode));
debug_rtx (op0);
debug_rtx (op1);
}
branch_cmp_op[0] = op0;
branch_cmp_op[1] = op1;
branch_cmp_mode = mode;
}
/* Return the mode and operands saved with compare_collect for use
in a branch operator. */
void
compare_restore (operands, mode, insn)
rtx *operands;
enum machine_mode *mode;
rtx insn;
{
if (!branch_cmp_op[0] || !branch_cmp_op[1])
abort_with_insn (insn, "Compare_restore did not follow compare_collect");
if (TARGET_DEBUGD_MODE)
{
fprintf (stderr,
"compare_restore returning mode = %s, operands:%X,%X:",
GET_MODE_NAME (branch_cmp_mode),
branch_cmp_op[0],
branch_cmp_op[1]);
debug_rtx (branch_cmp_op[0]);
debug_rtx (branch_cmp_op[1]);
}
operands[0] = branch_cmp_op[0];
operands[1] = branch_cmp_op[1];
*mode = branch_cmp_mode;
/* If the next insn is not a JUMP (after accounting for line numbers),
zero out the branch_cmp_array. Switch statements implemented as if's
tend to have multiple jumps. */
do
{
insn = NEXT_INSN (insn);
}
while (insn && GET_CODE (insn) == NOTE);
if (!insn || GET_CODE (insn) != JUMP_INSN)
{
branch_cmp_op[0] = NULL;
branch_cmp_op[1] = NULL;
branch_cmp_mode = VOIDmode;
}
}
/* Print the options used in the assembly file. */
static struct {char *name; int value;} target_switches []
= TARGET_SWITCHES;
void
print_options (out)
FILE *out;
{
int line_len;
int len;
int j;
char **p;
int mask = TARGET_DEFAULT;
extern char **save_argv;
extern char *version_string, *language_string;
#if 0
/* Allow assembly language comparisons with -mdebug eliminating the
compiler version number and switch lists. */
if (!TARGET_DEBUG_MODE)
{
fprintf (out, "\n # %s %s", language_string, version_string);
#ifdef TARGET_VERSION_INTERNAL
TARGET_VERSION_INTERNAL (out);
#endif
#ifdef __GNUC__
fprintf (out, " compiled by GNU C\n\n");
#else
fprintf (out, " compiled by CC\n\n");
#endif
fprintf (out, " # Cc1 defaults:");
line_len = 32767;
for (j = 0; j < sizeof target_switches / sizeof target_switches[0]; j++)
if (target_switches[j].name[0] != '\0'
&& target_switches[j].value > 0
&& (target_switches[j].value & mask) == target_switches[j].value)
{
len = strlen (target_switches[j].name) + 1;
if (len + line_len > 79)
{
line_len = 2;
fputs ("\n #", out);
}
fprintf (out, " -m%s", target_switches[j].name);
line_len += len;
}
fprintf (out, "\n\n # Cc1 arguments (-G value = %d):",
mips_section_threshold);
line_len = 32767;
for (p = &save_argv[1]; *p != (char *)0; p++)
if (**p == '-')
{
len = strlen (*p) + 1;
if (len + line_len > 79)
{
line_len = 2;
fputs ("\n #", out);
}
fprintf (out, " %s", *p);
line_len += len;
}
fputs ("\n\n", out);
}
#endif
}
/* Abort after printing out a specific insn. */
void
abort_with_insn (insn, reason)
rtx insn;
char *reason;
{
error (reason);
debug_rtx (insn);
abort ();
}
/* Write a message to stderr (for use in macros expanded in files that do not
include stdio.h). */
void
trace (s, s1, s2)
char *s, *s1, *s2;
{
fprintf (stderr, s, s1, s2);
}
/* Set up the threshold for data to go into the small data area, instead
of the normal data area, and detect any conflicts in the switches. */
void
overide_options ()
{
register int i;
i = TARGET_GVALUE;
if (i >= 6)
i += 3;
mips_section_threshold = (i != 0) ? 1 << i : 0;
}
/* Compute a string to use as a temporary file name. */
static FILE *
make_temp_file ()
{
char *temp_filename;
FILE *stream;
extern char *getenv ();
char *base = getenv ("TMPDIR");
int len;
if (base == (char *)0)
{
#ifdef P_tmpdir
if (access (P_tmpdir, R_OK | W_OK) == 0)
base = P_tmpdir;
else
#endif
if (access ("/usr/tmp", R_OK | W_OK) == 0)
base = "/usr/tmp/";
else
base = "/tmp/";
}
len = strlen (base);
temp_filename = (char *) alloca (len + sizeof("/ccXXXXXX"));
strcpy (temp_filename, base);
if (len > 0 && temp_filename[len-1] != '/')
temp_filename[len++] = '/';
strcpy (temp_filename + len, "ccXXXXXX");
mktemp (temp_filename);
stream = fopen (temp_filename, "w+");
if (!stream)
pfatal_with_name (temp_filename);
unlink (temp_filename);
return stream;
}
/* Output at beginning of assembler file.
If we are optimizing to use the global pointer, create a temporary
file to hold all of the text stuff, and write it out to the end.
This is needed because the MIPS assembler is evidently one pass,
and if it hasn't seen the relevant .comm/.lcomm/.extern/.sdata
declaration when the code is processed, it generates a two
instruction sequence. */
void
mips_asm_file_start (stream)
FILE *stream;
{
if (TARGET_NAME_REGS)
fprintf (stream, "#include <regdef.h>\n");
ASM_OUTPUT_SOURCE_FILENAME (stream, main_input_filename);
print_options (stream);
data_section (); /* put gcc_compiled. in data, not text*/
if (TARGET_GP_OPT)
{
asm_out_data_file = stream;
asm_out_text_file = make_temp_file ();
}
else
asm_out_data_file = asm_out_text_file = stream;
}
/* If optimizing for the global pointer, keep track of all of
the externs, so that at the end of the file, we can emit
the appropriate .extern declaration for them, before writing
out the text section. We assume that all names passed to
us are in the permanent obstack, so that they will be valid
at the end of the compilation.
If we have -G 0, or the extern size is unknown, don't bother
emitting the .externs. */
int
mips_output_external (file, decl, name)
FILE *file;
tree decl;
char *name;
{
extern char *permalloc ();
register struct extern_list *p;
int len;
if (TARGET_GP_OPT
&& mips_section_threshold != 0
&& ((TREE_CODE (decl)) != FUNCTION_DECL)
&& ((len = int_size_in_bytes (TREE_TYPE (decl))) > 0))
{
p = (struct extern_list *)permalloc ((long) sizeof (struct extern_list));
p->next = extern_head;
p->name = name;
p->size = len;
extern_head = p;
}
return 0;
}
/* If we are optimizing the global pointer, emit the text section now
and any small externs which did not have .comm, etc that are
needed. Also, give a warning if the data area is more than 32K and
-pic because 3 instructions are needed to reference the data
pointers. */
int
mips_asm_file_end (file)
FILE *file;
{
char buffer[8192];
tree name_tree;
struct extern_list *p;
int len;
extern tree lookup_name ();
if (TARGET_GP_OPT)
{
if (extern_head)
fputs ("\n", file);
for (p = extern_head; p != 0; p = p->next)
{
name_tree = get_identifier (p->name);
if (!TREE_ADDRESSABLE (name_tree))
{
TREE_ADDRESSABLE (name_tree) = 1;
fprintf (file, "\t.extern\t%s, %d\n", p->name, p->size);
}
}
fprintf (file, "\n\t.text\n");
rewind (asm_out_text_file);
if (ferror (asm_out_text_file))
fatal_io_error ("write of text assembly file in mips_asm_file_end");
while ((len = fread (buffer, 1, sizeof (buffer), asm_out_text_file)) > 0)
if (fwrite (buffer, 1, len, file) != len)
pfatal_with_name ("write of final assembly file in mips_asm_file_end");
if (len < 0)
pfatal_with_name ("read of text assembly file in mips_asm_file_end");
if (fclose (asm_out_text_file) != 0)
pfatal_with_name ("close of tempfile in mips_asm_file_end");
}
}
/* Fix references to the frame pointer to be off of the stack pointer. */
struct rtx_def *
mips_fix_frame_pointer (oldaddr, depth)
rtx oldaddr;
int depth;
{
rtx newaddr;
rtx sp_diff_rtx;
char temp[40];
int frame_offset = 0;
extern rtx eliminate_constant_term ();
newaddr = eliminate_constant_term (oldaddr, &frame_offset);
if (newaddr != frame_pointer_rtx)
return oldaddr;
if (sp_fp_difference == (char *)0)
{
sprintf (temp, "$Ls%d", number_functions_processed);
sp_fp_difference = IDENTIFIER_POINTER (get_identifier (temp));
}
sp_diff_rtx = gen_rtx (SYMBOL_REF, SImode, sp_fp_difference);
if (frame_offset + depth == 0)
newaddr = gen_rtx (PLUS, Pmode, stack_pointer_rtx, sp_diff_rtx);
else
newaddr = gen_rtx (PLUS, Pmode,
stack_pointer_rtx,
gen_rtx (CONST, Pmode,
gen_rtx (PLUS, Pmode,
sp_diff_rtx,
gen_rtx (CONST_INT, VOIDmode,
frame_offset + depth))));
if (TARGET_DEBUGC_MODE)
{
fprintf (stderr,
"\n==================== FIX_FRAME, depth = %d, sp prealloc = %d, offset = %d\n",
depth, stack_args_preallocated, frame_offset);
fprintf (stderr, "old INSN:");
debug_rtx (oldaddr);
fprintf (stderr, "\nnew INSN:");
debug_rtx (newaddr);
}
return newaddr;
}
/* Set up the stack and frame (if desired) for the function. */
void
function_prologue (file, size)
FILE *file;
int size;
{
extern char call_used_regs[];
extern char *reg_numchar[];
extern tree current_function_decl;
int regno;
int mask;
int fmask;
int push_loc;
int tsize;
int num_regs;
char **reg_name_ptr = (TARGET_NAME_REGS) ? reg_names : reg_numchar;
char *base_str;
char *sp_str = reg_name_ptr[STACK_POINTER_REGNUM];
char *fp_str = (!frame_pointer_needed)
? sp_str
: reg_name_ptr[FRAME_POINTER_REGNUM];
tree fndecl = current_function_decl; /* current... is tooo long */
tree fntype = TREE_TYPE (fndecl);
tree fnargs = (TREE_CODE (fntype) != METHOD_TYPE)
? DECL_ARGUMENTS (fndecl)
: 0;
tree next_arg;
tree cur_arg;
char *arg_name = (char *)0;
CUMULATIVE_ARGS args_so_far;
inside_function = 1;
if (write_symbols != NO_DEBUG)
ASM_OUTPUT_SOURCE_LINE (file,
DECL_SOURCE_LINE (current_function_decl));
fprintf (file, "\t.ent\t%s\n%s:\n", current_function_name,
current_function_name);
fprintf (file, " #PROLOGUE\n");
/* Determine the last argument, and get it's name. */
for (cur_arg = fnargs; cur_arg != (tree)0; cur_arg = next_arg)
{
next_arg = TREE_CHAIN (cur_arg);
if (next_arg == (tree)0)
{
if (DECL_NAME (cur_arg))
arg_name = IDENTIFIER_POINTER (DECL_NAME (cur_arg));
break;
}
}
/* If this function is a varargs function, store any registers that
would normally hold arguments ($4 - $7) on the stack. */
if ((TYPE_ARG_TYPES (fntype) != 0
&& (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype))) != void_type_node))
|| (arg_name
&& (strcmp (arg_name, "__builtin_va_alist") == 0
|| strcmp (arg_name, "va_alist") == 0)))
{
tree parm;
regno = 4;
INIT_CUMULATIVE_ARGS (args_so_far, fntype);
for (parm = fnargs; (parm && (regno <= 7)); parm = TREE_CHAIN (parm))
{
rtx entry_parm;
enum machine_mode passed_mode;
tree type;
type = DECL_ARG_TYPE (parm);
passed_mode = TYPE_MODE (type);
entry_parm = FUNCTION_ARG (args_so_far, passed_mode,
DECL_ARG_TYPE (parm), 1);
if (entry_parm)
{
int words;
/* passed in a register, so will get homed automatically */
if (GET_MODE (entry_parm) == BLKmode)
words = (int_size_in_bytes (type) + 3) / 4;
else
words = (GET_MODE_SIZE (GET_MODE (entry_parm)) + 3) / 4;
regno = REGNO (entry_parm) + words - 1;
}
else
{
regno = 8;
break;
}
FUNCTION_ARG_ADVANCE (args_so_far, passed_mode,
DECL_ARG_TYPE (parm), 1);
}
switch (regno)
{
case 4:
fprintf(file, "\tsd\t%s,0(%s)\t#varargs: home regs 4-5\n",
reg_name_ptr[4], sp_str);
fprintf(file, "\tsd\t%s,8(%s)\t#varargs: home regs 6-7\n",
reg_name_ptr[6], sp_str);
break;
case 5:
fprintf(file, "\tsw\t%s,4(%s)\t#varargs: home reg 5\n",
reg_name_ptr[5], sp_str);
fprintf(file, "\tsd\t%s,8(%s)\t#varargs: home regs 6-7\n",
reg_name_ptr[6], sp_str);
break;
case 6:
fprintf(file, "\tsd\t%s,8(%s)\t#varargs: home regs 6-7\n",
reg_name_ptr[6], sp_str);
break;
case 7:
fprintf(file, "\tsw\t%s,12(%s)\t#varargs: home reg 7\n",
reg_name_ptr[7], sp_str);
break;
default:
break;
}
}
mask = 0;
fmask = 0;
num_regs = 0;
push_loc = stack_args_preallocated;
tsize = AL_ADJUST_ALIGN (size) + stack_args_preallocated;
for (regno = GP_REG_FIRST; regno <= GP_REG_LAST; regno++)
if (MUST_SAVE_REGISTER (regno))
{
tsize += 4;
num_regs += 4;
mask |= 1 << (regno - GP_REG_FIRST);
}
tsize = AL_ADJUST_ALIGN (tsize);
num_regs = AL_ADJUST_ALIGN (num_regs);
for (regno = FP_REG_FIRST; regno <= FP_REG_LAST; regno += 2)
if (regs_ever_live[regno] && !call_used_regs[regno])
{
tsize += 8;
num_regs += 8;
fmask |= 1 << (regno - FP_REG_FIRST);
}
if (tsize)
tsize -= STARTING_FRAME_OFFSET;
if (!frame_pointer_needed && sp_fp_difference != (char *)0)
fprintf (file,"%s\t= %d\t\t\t#Difference between SP & FP\n\n",
sp_fp_difference, tsize);
current_function_total_framesize = tsize;
current_function_saved_reg_size = num_regs;
if (tsize > 0)
{
if (tsize <= 32767)
fprintf (file,
"\tsubu\t%s,%s,%d\t# temp= %d, regs= %d, args= %d, sfo= %d\n",
sp_str, sp_str, tsize, size, num_regs,
stack_args_preallocated, STARTING_FRAME_OFFSET);
else
fprintf (file,
"\tli\t%s,%d\n\tsubu\t%s,%s,%s\t# temp= %d, regs= %d, args= %d, sfo= %d\n",
reg_name_ptr[MIPS_TEMP1_REGNUM], tsize, sp_str, sp_str,
reg_name_ptr[MIPS_TEMP1_REGNUM], size, num_regs,
stack_args_preallocated, STARTING_FRAME_OFFSET);
}
fprintf (file, "\t.frame\t%s,%d,%s\n", fp_str,
(frame_pointer_needed) ? 0 : tsize,
reg_name_ptr[31]);
if (push_loc > 32767 && num_regs > 0)
{
if ((tsize - (push_loc + num_regs)) <= 32767)
{
base_str = reg_name_ptr[MIPS_TEMP1_REGNUM];
push_loc = tsize - push_loc;
}
else
{
base_str = reg_name_ptr[MIPS_TEMP2_REGNUM];
fprintf (file, "\tli\t%s,%d\n", base_str, push_loc);
push_loc = 0;
}
}
else
base_str = sp_str;
for (regno = GP_REG_FIRST; regno <= GP_REG_LAST; regno++)
if ((mask & (1 << (regno - GP_REG_FIRST))) != 0)
{
fprintf (file, "\tsw\t%s,%d(%s)\n", reg_name_ptr[regno], push_loc,
base_str);
push_loc += 4;
}
fprintf (file, "\t.mask\t0x%08x,%d\n", mask, push_loc - tsize - 4);
push_loc = AL_ADJUST_ALIGN (push_loc);
for (regno = FP_REG_FIRST; regno <= FP_REG_LAST; regno += 2)
if ((fmask & (1 << (regno - FP_REG_FIRST))) != 0)
{
fprintf (file, "\ts.d\t%s,%d(%s)\n", reg_name_ptr[regno], push_loc,
base_str);
push_loc += 8;
}
fprintf (file, "\t.fmask\t0x%08x,%d\n", fmask, push_loc - tsize - 4);
if (frame_pointer_needed)
{
if (tsize <= 32767)
fprintf (file, "\taddu\t%s,%s,%d\t# set up frame pointer\n", fp_str, sp_str, tsize);
else
fprintf (file, "\taddu\t%s,%s,%s\t# set up frame pointer\n", fp_str, sp_str,
reg_name_ptr[MIPS_TEMP1_REGNUM]);
}
fprintf (file," #END PROLOGUE\n");
}
/* Do any necessary cleanup after a function to restore stack, frame, and regs. */
void
function_epilogue (file, size)
FILE *file;
int size;
{
extern FILE *asm_out_data_file, *asm_out_file;
extern char call_used_regs[];
extern char *reg_numchar[];
extern char *current_function_name;
extern int frame_pointer_needed;
int regno;
int push_loc = stack_args_preallocated;
int tsize = current_function_total_framesize;
int num_regs = current_function_saved_reg_size;
char **reg_name_ptr = (TARGET_NAME_REGS) ? reg_names : reg_numchar;
char *sp_str = reg_name_ptr[STACK_POINTER_REGNUM];
char *t1_str = reg_name_ptr[MIPS_TEMP1_REGNUM];
char *base_str;
fprintf (file," #EPILOGUE\n");
if (tsize > 32767)
fprintf (file, "\tli\t%s,%d\n", t1_str, tsize);
if (frame_pointer_needed)
{
char *fp_str = reg_name_ptr[FRAME_POINTER_REGNUM];
if (tsize > 32767)
fprintf (file,"\tsubu\t%s,%s,%s\t# sp not trusted here\n",
sp_str, fp_str, t1_str);
else
fprintf (file,"\tsubu\t%s,%s,%d\t# sp not trusted here\n",
sp_str, fp_str, tsize);
}
if (push_loc > 32767 && num_regs > 0)
{
if ((tsize - (push_loc + num_regs)) <= 32767)
{
base_str = t1_str;
push_loc = tsize - push_loc;
}
else
{
base_str = reg_name_ptr[MIPS_TEMP2_REGNUM];
fprintf (file, "\tli\t%s,%d\n", base_str, push_loc);
push_loc = 0;
}
}
else
base_str = sp_str;
for (regno = GP_REG_FIRST; regno <= GP_REG_LAST; regno++)
if (MUST_SAVE_REGISTER (regno))
{
fprintf (file,"\tlw\t%s,%d(%s)\n", reg_name_ptr[regno], push_loc,
base_str);
push_loc += 4;
}
push_loc = AL_ADJUST_ALIGN (push_loc);
for (regno = FP_REG_FIRST; regno <= FP_REG_LAST; regno += 2)
if (regs_ever_live[regno] && !call_used_regs[regno])
{
fprintf (file, "\tl.d\t%s,%d(%s)\n", reg_name_ptr[regno], push_loc,
base_str);
push_loc += 8;
}
if (tsize > 32767)
fprintf (file, "\taddu\t%s,%s,%s\n", sp_str, sp_str, t1_str);
else if (tsize > 0)
fprintf (file, "\taddu\t%s,%s,%d\n", sp_str, sp_str, tsize);
fprintf (file,"\tj\t%s\n", reg_name_ptr[31]);
fprintf (file," #END EPILOGUE\n");
fprintf (file,"\t.end\t%s\n", current_function_name);
/* Reset state info for each function. */
stack_args_pushed = 0;
stack_args_preallocated = 0;
inside_function = 0;
sp_fp_difference = (char *)0;
number_functions_processed++;
/* Restore the output file if optimizing the GP (optimizing the GP causes
the text to be diverted to a tempfile, so that data decls come before
references to the data). */
if (TARGET_GP_OPT)
asm_out_file = asm_out_data_file;
}
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.