github
/
libjit
mirror of https://github.com/ademakov/libjit
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

do not use copy propagation for addressable and volatile values

cache-refactoring
Aleksey Demakov 18 years ago
parent
d7554e78e2
commit
7021d41fe3
2 changed files with 95 additions and 9 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 5
      ChangeLog
  2. 99
      jit/jit-live.c

5
ChangeLog
View File

@ -1,3 +1,8 @@
2007-05-28 Aleksey Demakov <ademakov@gmail.com>
* jit/jit-live.c (forward_propagation, backward_propagation): do not
optimize addressable and volatile values.
2007-05-28 Aleksey Demakov <ademakov@gmail.com>
* jit/jit-live.c (_jit_function_compute_liveness)

99
jit/jit-live.c
View File

@ -19,6 +19,7 @@
*/
#include "jit-internal.h"
#include <jit/jit-dump.h>
#define USE_FORWARD_PROPAGATION 1
#define USE_BACKWARD_PROPAGATION 1
@ -134,6 +135,11 @@ compute_liveness_for_block(jit_block_t block)
/* There is no next use of this value and it is not
live on exit from the block. So we can discard
the entire instruction as it will have no effect */
#ifdef _JIT_COMPILE_DEBUG
printf("liveness analysis: optimize away instruction '");
jit_dump_insn(stdout, block->func, insn);
printf("'\n");
#endif
insn->opcode = (short)JIT_OP_NOP;
continue;
}
@ -163,7 +169,7 @@ compute_liveness_for_block(jit_block_t block)
}
}
#if USE_FORWARD_PROPAGATION || USE_BACKWARD_PROPAGATION
#if defined(USE_FORWARD_PROPAGATION) || defined(USE_BACKWARD_PROPAGATION)
static int
is_copy_opcode(int opcode)
{
@ -237,26 +243,43 @@ forward_propagation(jit_block_t block)
continue;
}
/* Copy to itself could be safely discarded */
/* Discard copy to itself */
if(dest == value)
{
#ifdef _JIT_COMPILE_DEBUG
printf("forward copy propagation: optimize away copy to itself in '");
jit_dump_insn(stdout, block->func, insn);
printf("'\n");
#endif
insn->opcode = (short)JIT_OP_NOP;
optimized = 1;
continue;
}
/* Not smart enough to tell when it is safe to optimize copying
to a value used in other basic block. So just give up. */
to a value that is used in other basic blocks or may be
aliased. */
if(!dest->is_temporary)
{
continue;
}
if(dest->is_addressable || dest->is_volatile)
{
continue;
}
iter2 = iter;
while((insn2 = jit_insn_iter_next(&iter2)) != 0)
{
flags2 = insn2->flags;
/* Skip NOP instructions, which may have arguments left
over from when the instruction was replaced, but which
are not relevant to our analysis */
if(insn->opcode == JIT_OP_NOP)
{
continue;
}
flags2 = insn2->flags;
if((flags2 & JIT_INSN_DEST_OTHER_FLAGS) == 0)
{
if((flags2 & JIT_INSN_DEST_IS_VALUE) == 0)
@ -268,6 +291,15 @@ forward_propagation(jit_block_t block)
}
else if(insn2->dest == dest)
{
#ifdef _JIT_COMPILE_DEBUG
printf("forward copy propagation: in '");
jit_dump_insn(stdout, block->func, insn2);
printf("' replace ");
jit_dump_value(stdout, block->func, insn2->dest, 0);
printf(" with ");
jit_dump_value(stdout, block->func, value, 0);
printf("'\n");
#endif
insn2->dest = value;
optimized = 1;
}
@ -276,6 +308,15 @@ forward_propagation(jit_block_t block)
{
if(insn2->value1 == dest)
{
#ifdef _JIT_COMPILE_DEBUG
printf("forward copy propagation: in '");
jit_dump_insn(stdout, block->func, insn2);
printf("' replace ");
jit_dump_value(stdout, block->func, insn2->value1, 0);
printf(" with ");
jit_dump_value(stdout, block->func, value, 0);
printf("'\n");
#endif
insn2->value1 = value;
optimized = 1;
}
@ -284,6 +325,15 @@ forward_propagation(jit_block_t block)
{
if(insn2->value2 == dest)
{
#ifdef _JIT_COMPILE_DEBUG
printf("forward copy propagation: in '");
jit_dump_insn(stdout, block->func, insn2);
printf("' replace ");
jit_dump_value(stdout, block->func, insn2->value2, 0);
printf(" with ");
jit_dump_value(stdout, block->func, value, 0);
printf("'\n");
#endif
insn2->value2 = value;
optimized = 1;
}
@ -295,7 +345,7 @@ forward_propagation(jit_block_t block)
}
#endif
#if USE_BACKWARD_PROPAGATION
#ifdef USE_BACKWARD_PROPAGATION
/*
* Perform simple copy propagation within basic block for the case when a
* temporary value is stored to another value. This replaces instructions
@ -338,16 +388,29 @@ backward_propagation(jit_block_t block)
{
continue;
}
if(dest->is_addressable || dest->is_volatile)
{
continue;
}
value = insn->value1;
if(value == 0)
{
continue;
}
if(value->is_addressable || value->is_volatile)
{
continue;
}
/* Copy to itself could be safely discarded */
/* Discard copy to itself */
if(dest == value)
{
#ifdef _JIT_COMPILE_DEBUG
printf("backward copy propagation: optimize away copy to itself in '");
jit_dump_insn(stdout, block->func, insn);
printf("'\n");
#endif
insn->opcode = (short)JIT_OP_NOP;
optimized = 1;
continue;
@ -362,8 +425,15 @@ backward_propagation(jit_block_t block)
iter2 = iter;
while((insn2 = jit_insn_iter_previous(&iter2)) != 0)
{
flags2 = insn2->flags;
/* Skip NOP instructions, which may have arguments left
over from when the instruction was replaced, but which
are not relevant to our analysis */
if(insn->opcode == JIT_OP_NOP)
{
continue;
}
flags2 = insn2->flags;
if((flags2 & JIT_INSN_DEST_OTHER_FLAGS) == 0)
{
if(insn2->dest == dest)
@ -374,6 +444,17 @@ backward_propagation(jit_block_t block)
{
if((flags2 & JIT_INSN_DEST_IS_VALUE) == 0)
{
#ifdef _JIT_COMPILE_DEBUG
printf("backward copy propagation: in '");
jit_dump_insn(stdout, block->func, insn2);
printf("' replace ");
jit_dump_value(stdout, block->func, insn2->dest, 0);
printf(" with ");
jit_dump_value(stdout, block->func, dest, 0);
printf(" and optimize away '");
jit_dump_insn(stdout, block->func, insn);
printf("'\n");
#endif
insn->opcode = (short)JIT_OP_NOP;
insn2->dest = dest;
optimized = 1;
@ -470,7 +551,7 @@ void _jit_function_compute_liveness(jit_function_t func)
/* Perform peephole optimization on branches to branches */
_jit_block_peephole_branch(block);
#if USE_FORWARD_PROPAGATION
#ifdef USE_FORWARD_PROPAGATION
/* Perform forward copy propagation for the block */
forward_propagation(block);
#endif
@ -481,7 +562,7 @@ void _jit_function_compute_liveness(jit_function_t func)
/* Compute the liveness flags for the block */
compute_liveness_for_block(block);
#if USE_BACKWARD_PROPAGATION
#ifdef USE_BACKWARD_PROPAGATION
/* Perform backward copy propagation for the block */
if(backward_propagation(block))
{

Write Preview
Loading…
Cancel
Save