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

cse.c: Update comments. 

* cse.c: Update comments.
        (cse_insn): When converting a conditional/computed jump into
        an unconditional jump, always make sure a BARRIER immediately
        follows the converted jump.  Do not delete unreachable code.
        (cse_basic_block): Do not delete unreachable code.
        * toplev.c (rest_of_compilation): Move call to
        delete_trivially_dead_insns after the conditional call to
        jump_optimize.

From-SVN: r29665
This commit is contained in:
Jeffrey A Law 1999-09-25 19:13:18 +00:00 committed by Jeff Law
parent 57151693bc
commit e48a7fbe7b
3 changed files with 28 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
gcc/ChangeLog
View File

@ -1,3 +1,14 @@
Sat Sep 25 13:11:07 1999 Jeffrey A Law (law@cygnus.com)
* cse.c: Update comments.
(cse_insn): When converting a conditional/computed jump into
an unconditional jump, always make sure a BARRIER immediately
follows the converted jump. Do not delete unreachable code.
(cse_basic_block): Do not delete unreachable code.
* toplev.c (rest_of_compilation): Move call to
delete_trivially_dead_insns after the conditional call to
jump_optimize.
Sat Sep 25 09:03:17 1999 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* collect2.c (make_temp_file): Don't prototype.

59
gcc/cse.c
View File

@ -45,12 +45,14 @@ Boston, MA 02111-1307, USA. */
expressions encountered with the cheapest equivalent expression.
It is too complicated to keep track of the different possibilities
when control paths merge; so, at each label, we forget all that is
known and start fresh. This can be described as processing each
basic block separately. Note, however, that these are not quite
the same as the basic blocks found by a later pass and used for
data flow analysis and register packing. We do not need to start fresh
after a conditional jump instruction if there is no label there.
when control paths merge in this code; so, at each label, we forget all
that is known and start fresh. This can be described as processing each
extended basic block separately. We have a separate pass to perform
global CSE.
Note CSE can turn a conditional or computed jump into a nop or
an unconditional jump. When this occurs we arrange to run the jump
optimizer after CSE to delete the unreachable code.
We use two data structures to record the equivalent expressions:
a hash table for most expressions, and several vectors together
@ -7417,7 +7419,6 @@ cse_insn (insn, libcall_insn)
rtx new = emit_jump_insn_before (gen_jump (XEXP (src, 0)), insn);
JUMP_LABEL (new) = XEXP (src, 0);
LABEL_NUSES (XEXP (src, 0))++;
delete_insn (insn);
insn = new;
}
else
@ -7428,44 +7429,13 @@ cse_insn (insn, libcall_insn)
Until the right place is found, might as well do this here. */
INSN_CODE (insn) = -1;
/* Now that we've converted this jump to an unconditional jump,
there is dead code after it. Delete the dead code until we
reach a BARRIER, the end of the function, or a label. Do
not delete NOTEs except for NOTE_INSN_DELETED since later
phases assume these notes are retained. */
never_reached_warning (insn);
p = insn;
while (NEXT_INSN (p) != 0
&& GET_CODE (NEXT_INSN (p)) != BARRIER
&& GET_CODE (NEXT_INSN (p)) != CODE_LABEL)
{
/* Note, we must update P with the return value from
delete_insn, otherwise we could get an infinite loop
if NEXT_INSN (p) had INSN_DELETED_P set. */
if (GET_CODE (NEXT_INSN (p)) != NOTE
|| NOTE_LINE_NUMBER (NEXT_INSN (p)) == NOTE_INSN_DELETED)
p = PREV_INSN (delete_insn (NEXT_INSN (p)));
else
p = NEXT_INSN (p);
}
/* If we don't have a BARRIER immediately after INSN, put one there.
Much code assumes that there are no NOTEs between a JUMP_INSN and
BARRIER. */
if (NEXT_INSN (insn) == 0
|| GET_CODE (NEXT_INSN (insn)) != BARRIER)
emit_barrier_before (NEXT_INSN (insn));
/* We might have two BARRIERs separated by notes. Delete the second
one if so. */
if (p != insn && NEXT_INSN (p) != 0
&& GET_CODE (NEXT_INSN (p)) == BARRIER)
delete_insn (NEXT_INSN (p));
/* Now emit a BARRIER after the unconditional jump. Do not bother
deleting any unreachable code, let jump/flow do that. */
if (NEXT_INSN (insn) != 0
&& GET_CODE (NEXT_INSN (insn)) != BARRIER)
emit_barrier_after (insn);
cse_jumps_altered = 1;
sets[i].rtl = 0;
@ -8968,9 +8938,6 @@ cse_basic_block (from, to, next_branch, around_loop)
insn = NEXT_INSN (to);
if (LABEL_NUSES (to) == 0)
insn = delete_insn (to);
/* If TO was the last insn in the function, we are done. */
if (insn == 0)
return 0;

6
gcc/toplev.c
View File

@ -3745,8 +3745,6 @@ rest_of_compilation (decl)
TIMEVAR (cse_time, tem = cse_main (insns, max_reg_num (),
0, rtl_dump_file));
TIMEVAR (cse_time, delete_trivially_dead_insns (insns, max_reg_num ()));
/* If we are not running the second CSE pass, then we are no longer
expecting CSE to be run. */
cse_not_expected = !flag_rerun_cse_after_loop;
@ -3756,6 +3754,10 @@ rest_of_compilation (decl)
!JUMP_NOOP_MOVES,
!JUMP_AFTER_REGSCAN));
/* Run this after jump optmizations remove all the unreachable code
so that unreachable code will not keep values live. */
TIMEVAR (cse_time, delete_trivially_dead_insns (insns, max_reg_num ()));
/* Try to identify useless null pointer tests and delete them. */
if (flag_delete_null_pointer_checks)
TIMEVAR (jump_time, delete_null_pointer_checks (get_insns ()));