OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

*** empty log message *** 

From-SVN: r961
This commit is contained in:
Richard Kenner 1992-05-11 22:51:59 -04:00
parent 3351cb0051
commit bfa30b22c7
5 changed files with 125 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
gcc/cccp.c
View File

@ -333,9 +333,6 @@ static enum {dump_none, dump_only, dump_names, dump_definitions}
where they are defined. */
static int debug_output = 0;
/* Holds local startup time. */
static struct tm *timebuf = NULL;
/* Nonzero indicates special processing used by the pcp program. The
special effects of this mode are:
@ -3433,6 +3430,17 @@ handle_directive (ip, op)
return 0;
}
static struct tm *
timestamp ()
{
static struct tm *timebuf;
if (!timebuf) {
time_t t = time (0);
timebuf = localtime (&t);
}
return timebuf;
}
static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
};
@ -3451,6 +3459,7 @@ special_symbol (hp, op)
int i, len;
int true_indepth;
FILE_BUF *ip = NULL;
struct tm *timebuf;
int paren = 0; /* For special `defined' keyword */
@ -3536,6 +3545,7 @@ special_symbol (hp, op)
case T_DATE:
case T_TIME:
buf = (char *) alloca (20);
timebuf = timestamp ();
if (hp->type == T_DATE)
sprintf (buf, "\"%s %2d %4d\"", monthnames[timebuf->tm_mon],
timebuf->tm_mday, timebuf->tm_year + 1900);
@ -8055,11 +8065,6 @@ initialize_builtins (inp, outp)
FILE_BUF *inp;
FILE_BUF *outp;
{
time_t t;
t = time (0);
timebuf = localtime (&t);
install ("__LINE__", -1, T_SPECLINE, 0, -1);
install ("__DATE__", -1, T_DATE, 0, -1);
install ("__FILE__", -1, T_FILE, 0, -1);
@ -8082,6 +8087,7 @@ initialize_builtins (inp, outp)
{
char directive[2048];
register struct directive *dp = &directive_table[0];
struct tm *timebuf = timestamp ();
sprintf (directive, " __BASE_FILE__ \"%s\"\n",
instack[0].nominal_fname);

3
gcc/integrate.c
View File

@ -1040,7 +1040,7 @@ rtx *global_const_equiv_map;
/* Integrate the procedure defined by FNDECL. Note that this function
may wind up calling itself. Since the static variables are not
reentrant, we do not assign them until after the possibility
or recursion is eliminated.
of recursion is eliminated.
If IGNORE is nonzero, do not produce a value.
Otherwise store the value in TARGET if it is nonzero and that is convenient.
@ -1557,6 +1557,7 @@ expand_inline_function (fndecl, parms, target, ignore, type, structure_value_add
case CODE_LABEL:
copy = emit_label (map->label_map[CODE_LABEL_NUMBER (insn)]);
LABEL_NAME (copy) = LABEL_NAME (insn);
map->const_age++;
break;

96
gcc/reload.c
View File

@ -547,7 +547,7 @@ push_reload (in, out, inloc, outloc, class,
/* If IN appears in OUT, we can't share any input-only reload for IN. */
if (in != 0 && out != 0 && GET_CODE (out) == MEM
&& (GET_CODE (in) == REG || GET_CODE (in) == MEM)
&& reg_overlap_mentioned_p (in, XEXP (out, 0)))
&& reg_overlap_mentioned_for_reload_p (in, XEXP (out, 0)))
dont_share = 1;
/* Narrow down the class of register wanted if that is
@ -1104,8 +1104,8 @@ combine_reloads ()
/* Args reversed because the first arg seems to be
the one that we imagine being modified
while the second is the one that might be affected. */
|| (! reg_overlap_mentioned_p (reload_out[output_reload],
reload_in[i])
|| (! reg_overlap_mentioned_for_reload_p (reload_out[output_reload],
reload_in[i])
/* However, if the input is a register that appears inside
the output, then we also can't share.
Imagine (set (mem (reg 69)) (plus (reg 69) ...)).
@ -1113,8 +1113,8 @@ combine_reloads ()
result to be stored in memory, then that result
will clobber the address of the memory ref. */
&& ! (GET_CODE (reload_in[i]) == REG
&& reg_overlap_mentioned_p (reload_in[i],
reload_out[output_reload])))))
&& reg_overlap_mentioned_for_reload_p (reload_in[i],
reload_out[output_reload])))))
{
int j;
@ -1162,8 +1162,8 @@ combine_reloads ()
for (note = REG_NOTES (this_insn); note; note = XEXP (note, 1))
if (REG_NOTE_KIND (note) == REG_DEAD
&& GET_CODE (XEXP (note, 0)) == REG
&& ! reg_overlap_mentioned_p (XEXP (note, 0),
reload_out[output_reload])
&& ! reg_overlap_mentioned_for_reload_p (XEXP (note, 0),
reload_out[output_reload])
&& REGNO (XEXP (note, 0)) < FIRST_PSEUDO_REGISTER
&& HARD_REGNO_MODE_OK (REGNO (XEXP (note, 0)), reload_outmode[output_reload])
&& TEST_HARD_REG_BIT (reg_class_contents[(int) reload_reg_class[output_reload]],
@ -4343,6 +4343,70 @@ refers_to_regno_for_reload_p (regno, endregno, x, loc)
}
return 0;
}
/* Nonzero if modifying X will affect IN. If X is a register or a SUBREG,
we check if any register number in X conflicts with the relevant register
numbers. If X is a constant, return 0. If X is a MEM, return 1 iff IN
contains a MEM (we don't bother checking for memory addresses that can't
conflict because we expect this to be a rare case.
This function is similar to reg_overlap_mention_p in rtlanal.c except
that we look at equivalences for pseudos that didn't get hard registers. */
int
reg_overlap_mentioned_for_reload_p (x, in)
rtx x, in;
{
int regno, endregno;
if (GET_CODE (x) == SUBREG)
{
regno = REGNO (SUBREG_REG (x));
if (regno < FIRST_PSEUDO_REGISTER)
regno += SUBREG_WORD (x);
}
else if (GET_CODE (x) == REG)
{
regno = REGNO (x);
if (regno >= FIRST_PSEUDO_REGISTER && reg_renumber[regno] == -1
&& ((reg_equiv_address[regno]
&& reg_overlap_mentioned_for_reload_p (reg_equiv_address[regno],
in))
|| (reg_equiv_mem[regno]
&& reg_overlap_mentioned_for_reload_p (reg_equiv_mem[regno],
in))))
return 1;
}
else if (CONSTANT_P (x))
return 0;
else if (GET_CODE (x) == MEM)
{
char *fmt;
int i;
if (GET_CODE (in) == MEM)
return 1;
fmt = GET_RTX_FORMAT (GET_CODE (in));
for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
if (fmt[i] == 'e' && reg_overlap_mentioned_for_reload_p (x,
XEXP (in, i)))
return 1;
return 0;
}
else if (GET_CODE (x) == SCRATCH || GET_CODE (x) == PC
|| GET_CODE (x) == CC0)
return reg_mentioned_p (x, in);
else
abort ();
endregno = regno + (regno < FIRST_PSEUDO_REGISTER
? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
return refers_to_regno_for_reload_p (regno, endregno, in, 0);
}
#if 0
@ -4584,7 +4648,8 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
/* If we propose to get the value from the stack pointer or if GOAL is
a MEM based on the stack pointer, we need a stable SP. */
if (valueno == STACK_POINTER_REGNUM
|| (goal_mem && reg_overlap_mentioned_p (stack_pointer_rtx, goal)))
|| (goal_mem && reg_overlap_mentioned_for_reload_p (stack_pointer_rtx,
goal)))
need_stable_sp = 1;
/* Reject VALUE if the copy-insn moved the wrong sort of datum. */
@ -4595,9 +4660,10 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
and is also a register that appears in the address of GOAL. */
if (goal_mem && value == SET_DEST (PATTERN (where))
&& refers_to_regno_p (valueno,
valueno + HARD_REGNO_NREGS (valueno, mode),
goal, 0))
&& refers_to_regno_for_reload_p (valueno,
(valueno
+ HARD_REGNO_NREGS (valueno, mode)),
goal, 0))
return 0;
/* Reject registers that overlap GOAL. */
@ -4710,7 +4776,7 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
&& xregno + xnregs > valueno)
return 0;
if (goal_mem_addr_varies
&& reg_overlap_mentioned_p (dest, goal))
&& reg_overlap_mentioned_for_reload_p (dest, goal))
return 0;
}
else if (goal_mem && GET_CODE (dest) == MEM
@ -4748,7 +4814,8 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
&& xregno + xnregs > valueno)
return 0;
if (goal_mem_addr_varies
&& reg_overlap_mentioned_p (dest, goal))
&& reg_overlap_mentioned_for_reload_p (dest,
goal))
return 0;
}
else if (goal_mem && GET_CODE (dest) == MEM
@ -4779,7 +4846,8 @@ find_equiv_reg (goal, insn, class, other, reload_reg_p, goalreg, mode)
if (incno < valueno + valuenregs && incno >= valueno)
return 0;
if (goal_mem_addr_varies
&& reg_overlap_mentioned_p (XEXP (link, 0), goal))
&& reg_overlap_mentioned_for_reload_p (XEXP (link, 0),
goal))
return 0;
}
}

26
gcc/reload1.c
View File

@ -4272,7 +4272,8 @@ choose_reload_regs (insn, avoid_return_reg)
if (equiv != 0)
for (i = 0; i < n_earlyclobbers; i++)
if (reg_overlap_mentioned_p (equiv, reload_earlyclobbers[i]))
if (reg_overlap_mentioned_for_reload_p (equiv,
reload_earlyclobbers[i]))
{
reload_override_in[r] = equiv;
equiv = 0;
@ -4600,7 +4601,8 @@ emit_reload_insns (insn)
int k;
for (k = 0; k < n_reloads; k++)
if (reload_reg_rtx[k] != 0 && k != j
&& reg_overlap_mentioned_p (reload_reg_rtx[k], oldequiv))
&& reg_overlap_mentioned_for_reload_p (reload_reg_rtx[k],
oldequiv))
{
oldequiv = 0;
break;
@ -4879,8 +4881,8 @@ emit_reload_insns (insn)
prev != PREV_INSN (this_reload_insn);
prev = PREV_INSN (prev))
if (GET_RTX_CLASS (GET_CODE (prev) == 'i')
&& reg_overlap_mentioned_p (second_reload_reg,
PATTERN (prev)))
&& reg_overlap_mentioned_for_reload_p (second_reload_reg,
PATTERN (prev)))
{
REG_NOTES (prev) = gen_rtx (EXPR_LIST, REG_DEAD,
second_reload_reg,
@ -5008,8 +5010,8 @@ emit_reload_insns (insn)
for (prev1 = this_reload_insn;
prev1; prev1 = PREV_INSN (prev1))
if (GET_RTX_CLASS (GET_CODE (prev1) == 'i')
&& reg_overlap_mentioned_p (oldequiv_reg,
PATTERN (prev1)))
&& reg_overlap_mentioned_for_reload_p (oldequiv_reg,
PATTERN (prev1)))
{
REG_NOTES (prev1) = gen_rtx (EXPR_LIST, REG_DEAD,
oldequiv_reg,
@ -5190,7 +5192,8 @@ emit_reload_insns (insn)
for (p = PREV_INSN (first_output_reload_insn);
p != prev_insn; p = PREV_INSN (p))
if (GET_RTX_CLASS (GET_CODE (p)) == 'i'
&& reg_overlap_mentioned_p (reloadreg, PATTERN (p)))
&& reg_overlap_mentioned_for_reload_p (reloadreg,
PATTERN (p)))
REG_NOTES (p) = gen_rtx (EXPR_LIST, REG_DEAD,
reloadreg, REG_NOTES (p));
@ -5200,7 +5203,8 @@ emit_reload_insns (insn)
for (p = PREV_INSN (first_output_reload_insn);
p != prev_insn; p = PREV_INSN (p))
if (GET_RTX_CLASS (GET_CODE (p)) == 'i'
&& reg_overlap_mentioned_p (second_reloadreg, PATTERN (p)))
&& reg_overlap_mentioned_for_reload_p (second_reloadreg,
PATTERN (p)))
REG_NOTES (p) = gen_rtx (EXPR_LIST, REG_DEAD,
second_reloadreg, REG_NOTES (p));
#endif
@ -5253,8 +5257,10 @@ emit_reload_insns (insn)
if (REG_NOTE_KIND (reg_notes) == REG_DEAD
&& GET_CODE (XEXP (reg_notes, 0)) == REG
&& ((GET_CODE (dest) != REG
&& reg_overlap_mentioned_p (XEXP (reg_notes, 0), dest))
|| reg_overlap_mentioned_p (XEXP (reg_notes, 0), source)))
&& reg_overlap_mentioned_for_reload_p (XEXP (reg_notes, 0),
dest))
|| reg_overlap_mentioned_for_reload_p (XEXP (reg_notes, 0),
source)))
{
*prev_reg_note = next_reg_notes;
XEXP (reg_notes, 1) = REG_NOTES (insn1);

22
gcc/tree.c
View File

@ -3104,22 +3104,22 @@ int_fits_type_p (c, type)
&& !INT_CST_LT (c, TYPE_MIN_VALUE (type)));
}
/* Return the innermost context enclosing FNDECL that is
/* Return the innermost context enclosing DECL that is
a FUNCTION_DECL, or zero if none. */
tree
decl_function_context (fndecl)
tree fndecl;
decl_function_context (decl)
tree decl;
{
tree context;
if (TREE_CODE (fndecl) == ERROR_MARK)
if (TREE_CODE (decl) == ERROR_MARK)
return 0;
if (TREE_CODE (fndecl) == SAVE_EXPR)
context = SAVE_EXPR_CONTEXT (fndecl);
if (TREE_CODE (decl) == SAVE_EXPR)
context = SAVE_EXPR_CONTEXT (decl);
else
context = DECL_CONTEXT (fndecl);
context = DECL_CONTEXT (decl);
while (context && TREE_CODE (context) != FUNCTION_DECL)
{
@ -3138,15 +3138,15 @@ decl_function_context (fndecl)
return context;
}
/* Return the innermost context enclosing FNDECL that is
/* Return the innermost context enclosing DECL that is
a RECORD_TYPE or UNION_TYPE, or zero if none.
TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
tree
decl_type_context (fndecl)
tree fndecl;
decl_type_context (decl)
tree decl;
{
tree context = DECL_CONTEXT (fndecl);
tree context = DECL_CONTEXT (decl);
while (context)
{