e576bb | 2002-10-11 | Martin Nilsson | |
|
1b10db | 2002-10-08 | Martin Nilsson | |
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | #include "global.h"
#include "stralloc.h"
#include "dynamic_buffer.h"
#include "program.h"
#include "las.h"
#include "docode.h"
|
1a26b2 | 2004-12-30 | Henrik Grubbström (Grubba) | | #include "pike_embed.h"
|
b2d3e4 | 2000-12-01 | Fredrik Hübinette (Hubbe) | | #include "pike_error.h"
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | #include "lex.h"
|
9aa6fa | 1997-05-19 | Fredrik Hübinette (Hubbe) | | #include "pike_memory.h"
|
66d51c | 1997-03-04 | Fredrik Hübinette (Hubbe) | | #include "peep.h"
|
731001 | 1998-05-01 | Henrik Grubbström (Grubba) | | #include "stuff.h"
|
327b99 | 1999-10-25 | Fredrik Hübinette (Hubbe) | | #include "bignum.h"
|
f76b4c | 2000-05-11 | Henrik Grubbström (Grubba) | | #include "opcodes.h"
|
d9a93b | 2001-07-01 | Fredrik Hübinette (Hubbe) | | #include "builtin_functions.h"
#include "constants.h"
|
6a2170 | 2001-07-17 | Fredrik Hübinette (Hubbe) | | #include "interpret.h"
|
dd6bca | 2001-07-20 | Henrik Grubbström (Grubba) | | #include "pikecode.h"
|
9b4ac3 | 2014-11-26 | Henrik Grubbström (Grubba) | | #include "pike_compiler.h"
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | |
|
9ca13e | 2003-06-12 | Martin Nilsson | | #ifdef PIKE_DEBUG
|
2d1234 | 1997-03-10 | Fredrik Hübinette (Hubbe) | | static int hasarg(int opcode)
{
return instrs[opcode-F_OFFSET].flags & I_HASARG;
}
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | |
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | | static int hasarg2(int opcode)
{
return instrs[opcode-F_OFFSET].flags & I_HASARG2;
}
static void dump_instr(p_instr *p)
{
if(!p) return;
fprintf(stderr,"%s",get_token_name(p->opcode));
if(hasarg(p->opcode))
{
fprintf(stderr,"(%d",p->arg);
if(hasarg2(p->opcode))
fprintf(stderr,",%d",p->arg2);
fprintf(stderr,")");
}
}
#endif
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | static int asm_opt(void);
dynamic_buffer instrbuf;
long num_instrs = 0;
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | |
|
be478c | 1997-08-30 | Henrik Grubbström (Grubba) | | void init_bytecode(void)
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | {
|
041256 | 2002-10-04 | Marcus Comstedt | | initialize_buf(&instrbuf);
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | num_instrs = 0;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | }
|
be478c | 1997-08-30 | Henrik Grubbström (Grubba) | | void exit_bytecode(void)
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | {
|
7a35a4 | 2000-08-14 | Henrik Grubbström (Grubba) | | ptrdiff_t e, length;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | p_instr *c;
c=(p_instr *)instrbuf.s.str;
length=instrbuf.s.len / sizeof(p_instr);
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | | for(e=0;e<length;e++) {
free_string(dmalloc_touch_named(struct pike_string *, c[e].file,
"exit_bytecode"));
#ifdef PIKE_DEBUG
c[e].file = (void *)(ptrdiff_t)~0;
#endif
}
|
13670c | 2015-05-25 | Martin Nilsson | |
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | toss_buffer(&instrbuf);
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | }
ptrdiff_t insert_opcode(p_instr *opcode)
{
p_instr *p = (p_instr *)low_make_buf_space(sizeof(p_instr), &instrbuf);
if (!p) Pike_fatal("Out of memory in peep.\n");
*p = *opcode;
num_instrs++;
return p - (p_instr *)instrbuf.s.str;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | }
|
7a35a4 | 2000-08-14 | Henrik Grubbström (Grubba) | | ptrdiff_t insert_opcode2(unsigned int f,
INT32 b,
INT32 c,
|
ef24a8 | 2012-01-12 | Henrik Grubbström (Grubba) | | INT_TYPE current_line,
|
7a35a4 | 2000-08-14 | Henrik Grubbström (Grubba) | | struct pike_string *current_file)
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | {
p_instr *p;
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | | if(!hasarg2(f) && c)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("hasarg2(%d) is wrong!\n",f);
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | #endif
p=(p_instr *)low_make_buf_space(sizeof(p_instr), &instrbuf);
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | if(!instrbuf.s.len)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Low make buf space failed!!!!!!\n");
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | #endif
p->opcode=f;
p->line=current_line;
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | | copy_shared_string(p->file, dmalloc_touch_named(struct pike_string *,
current_file,
"insert_opcode"));
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | p->arg=b;
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | | p->arg2=c;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | |
return p - (p_instr *)instrbuf.s.str;
}
|
7a35a4 | 2000-08-14 | Henrik Grubbström (Grubba) | | ptrdiff_t insert_opcode1(unsigned int f,
INT32 b,
|
ef24a8 | 2012-01-12 | Henrik Grubbström (Grubba) | | INT_TYPE current_line,
|
7a35a4 | 2000-08-14 | Henrik Grubbström (Grubba) | | struct pike_string *current_file)
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | | {
#ifdef PIKE_DEBUG
if(!hasarg(f) && b)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("hasarg(%d) is wrong!\n",f);
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | | #endif
return insert_opcode2(f,b,0,current_line,current_file);
}
|
ef24a8 | 2012-01-12 | Henrik Grubbström (Grubba) | | ptrdiff_t insert_opcode0(int f, INT_TYPE current_line,
struct pike_string *current_file)
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | {
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | if(hasarg(f))
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("hasarg(%d) is wrong!\n",f);
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | #endif
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | | return insert_opcode1(f,0,current_line, current_file);
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | }
|
419fab | 1997-03-09 | Fredrik Hübinette (Hubbe) | |
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | void update_arg(int instr,INT32 arg)
{
p_instr *p;
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
645e26 | 1996-04-23 | Fredrik Hübinette (Hubbe) | | if(instr > (long)instrbuf.s.len / (long)sizeof(p_instr) || instr < 0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("update_arg outside known space.\n");
|
13670c | 2015-05-25 | Martin Nilsson | | #endif
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | p=(p_instr *)instrbuf.s.str;
p[instr].arg=arg;
}
|
80fe61 | 2001-07-21 | Fredrik Hübinette (Hubbe) | | #ifndef FLUSH_CODE_GENERATOR_STATE
#define FLUSH_CODE_GENERATOR_STATE()
#endif
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | |
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | INT32 assemble(int store_linenumbers)
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | {
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | INT32 entry_point;
|
bedc66 | 2003-09-26 | Henrik Grubbström (Grubba) | | INT32 max_label=-1,tmp;
|
cbeb9b | 2006-02-27 | Martin Stjernholm | | INT32 *labels, *jumps, *uses, *aliases;
|
7a35a4 | 2000-08-14 | Henrik Grubbström (Grubba) | | ptrdiff_t e, length;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | p_instr *c;
|
b5575f | 2003-11-24 | Henrik Grubbström (Grubba) | | struct pike_string *tripples = NULL;
|
85f4f5 | 2001-01-31 | Martin Stjernholm | | #ifdef PIKE_DEBUG
|
bedc66 | 2003-09-26 | Henrik Grubbström (Grubba) | | INT32 max_pointer=-1;
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | int synch_depth = 0;
|
4974fa | 2002-11-07 | Henrik Grubbström (Grubba) | | size_t fun_start = Pike_compiler->new_program->num_program;
|
85f4f5 | 2001-01-31 | Martin Stjernholm | | #endif
|
b9ca5f | 2004-08-25 | Henrik Grubbström (Grubba) | | int relabel;
int reoptimize = relabel = !(debug_options & NO_PEEP_OPTIMIZING);
|
9b4ac3 | 2014-11-26 | Henrik Grubbström (Grubba) | | struct lex *lex;
CHECK_COMPILER();
lex = &THIS_COMPILATION->lex;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | |
c=(p_instr *)instrbuf.s.str;
length=instrbuf.s.len / sizeof(p_instr);
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | #ifdef PIKE_DEBUG
|
bedc66 | 2003-09-26 | Henrik Grubbström (Grubba) | | if((a_flag > 1 && store_linenumbers) || a_flag > 2)
{
for (e = 0; e < length; e++) {
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | if (c[e].opcode == F_POP_SYNCH_MARK) synch_depth--;
|
ef24a8 | 2012-01-12 | Henrik Grubbström (Grubba) | | fprintf(stderr, "~~~%4ld %4lx %*s", (long)c[e].line,
|
bd6739 | 2015-10-14 | Martin Nilsson | | (unsigned long)e, synch_depth, "");
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | dump_instr(c+e);
fprintf(stderr,"\n");
if (c[e].opcode == F_SYNCH_MARK) synch_depth++;
}
|
bedc66 | 2003-09-26 | Henrik Grubbström (Grubba) | | if (synch_depth) {
Pike_fatal("Unbalanced sync_mark/pop_sync_mark: %d\n", synch_depth);
}
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | }
#endif
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | |
if (store_linenumbers) {
|
b5575f | 2003-11-24 | Henrik Grubbström (Grubba) | | p_wchar2 *current_tripple;
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | struct pike_string *previous_file = NULL;
|
ef24a8 | 2012-01-12 | Henrik Grubbström (Grubba) | | INT_TYPE previous_line = 0;
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | ptrdiff_t num_linedirectives = 0;
|
fcbe1f | 2003-11-19 | Henrik Grubbström (Grubba) | |
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | for (e=0; e < length; e++) {
if (c[e].file != previous_file) {
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | | previous_file = dmalloc_touch_named(struct pike_string *,
c[e].file, "prev_file");
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | num_linedirectives++;
}
if (c[e].line != previous_line) {
previous_line = c[e].line;
num_linedirectives++;
}
}
|
fcbe1f | 2003-11-19 | Henrik Grubbström (Grubba) | |
|
13670c | 2015-05-25 | Martin Nilsson | |
|
b5575f | 2003-11-24 | Henrik Grubbström (Grubba) | | if (!(tripples = begin_wide_shared_string(3*(length+num_linedirectives),
2))) {
Pike_fatal("Failed to allocate wide string of length %d 3*(%d + %d).\n",
3*(length+num_linedirectives), length, num_linedirectives);
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | }
previous_file = NULL;
previous_line = 0;
|
b5575f | 2003-11-24 | Henrik Grubbström (Grubba) | | current_tripple = STR2(tripples);
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | for (e = 0; e < length; e++) {
if (c[e].file != previous_file) {
|
b5575f | 2003-11-24 | Henrik Grubbström (Grubba) | | current_tripple[0] = F_FILENAME;
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | | current_tripple[1] =
store_prog_string(dmalloc_touch_named(struct pike_string *,
c[e].file,
"store_prog_string"));
|
b5575f | 2003-11-24 | Henrik Grubbström (Grubba) | | current_tripple[2] = 0;
current_tripple += 3;
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | | previous_file = dmalloc_touch_named(struct pike_string *,
c[e].file, "prev_file");
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | }
if (c[e].line != previous_line) {
|
b5575f | 2003-11-24 | Henrik Grubbström (Grubba) | | current_tripple[0] = F_LINE;
current_tripple[1] = c[e].line;
|
0695b4 | 2014-11-05 | Martin Nilsson | | #if SIZEOF_INT_TYPE > 4
|
ef24a8 | 2012-01-12 | Henrik Grubbström (Grubba) | | current_tripple[2] = c[e].line>>32;
|
0695b4 | 2014-11-05 | Martin Nilsson | | #else
current_tripple[2] = 0;
#endif
|
b5575f | 2003-11-24 | Henrik Grubbström (Grubba) | | current_tripple += 3;
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | previous_line = c[e].line;
}
|
b5575f | 2003-11-24 | Henrik Grubbström (Grubba) | | current_tripple[0] = c[e].opcode;
current_tripple[1] = c[e].arg;
current_tripple[2] = c[e].arg2;
current_tripple += 3;
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | }
#ifdef PIKE_DEBUG
|
b5575f | 2003-11-24 | Henrik Grubbström (Grubba) | | if (current_tripple != STR2(tripples) + 3*(length + num_linedirectives)) {
Pike_fatal("Tripple length mismatch %d != %d 3*(%d + %d)\n",
current_tripple - STR2(tripples),
3*(length + num_linedirectives),
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | length, num_linedirectives);
}
#endif /* PIKE_DEBUG */
|
b5575f | 2003-11-24 | Henrik Grubbström (Grubba) | | tripples = end_shared_string(tripples);
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | }
|
13670c | 2015-05-25 | Martin Nilsson | |
|
bedc66 | 2003-09-26 | Henrik Grubbström (Grubba) | | for(e=0;e<length;e++,c++) {
if(c->opcode == F_LABEL) {
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | if(c->arg > max_label)
max_label = c->arg;
|
bedc66 | 2003-09-26 | Henrik Grubbström (Grubba) | | }
#ifdef PIKE_DEBUG
else if (instrs[c->opcode - F_OFFSET].flags & I_POINTER) {
if (c->arg > max_pointer)
max_pointer = c->arg;
}
#endif /* PIKE_DEBUG */
}
#ifdef PIKE_DEBUG
if (max_pointer > max_label) {
fprintf(stderr,
"Reference to undefined label %d > %d\n"
"Bad instructions are marked with '***':\n",
max_pointer, max_label);
c=(p_instr *)instrbuf.s.str;
for(e=0;e<length;e++,c++) {
if (c->opcode == F_POP_SYNCH_MARK) synch_depth--;
|
ef24a8 | 2012-01-12 | Henrik Grubbström (Grubba) | | fprintf(stderr, " * %4ld %4lx ",
|
bd6739 | 2015-10-14 | Martin Nilsson | | (long)c->line, (unsigned long)e);
|
bedc66 | 2003-09-26 | Henrik Grubbström (Grubba) | | dump_instr(c);
if ((instrs[c->opcode - F_OFFSET].flags & I_POINTER) &&
(c->arg > max_label)) {
fprintf(stderr, " ***\n");
} else {
fprintf(stderr, "\n");
}
if (c->opcode == F_SYNCH_MARK) synch_depth++;
}
|
13670c | 2015-05-25 | Martin Nilsson | |
|
bedc66 | 2003-09-26 | Henrik Grubbström (Grubba) | | Pike_fatal("Reference to undefined label %d > %d\n",
max_pointer, max_label);
}
#endif /* PIKE_DEBUG */
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | |
|
cbeb9b | 2006-02-27 | Martin Stjernholm | | #ifndef INS_ENTRY
for (c = (p_instr *) instrbuf.s.str, e = 0; e < length; e++, c++)
if (c->opcode == F_ENTRY) c->opcode = F_NOP;
#endif
|
dc8d02 | 2014-04-27 | Martin Nilsson | | labels=xalloc(sizeof(INT32) * 4 * (max_label+2));
|
998842 | 2003-10-10 | Martin Stjernholm | | jumps = labels + max_label + 2;
|
42ddc6 | 2016-03-24 | Henrik Grubbström (Grubba) | | aliases = jumps + max_label + 2;
uses = aliases + max_label + 2;
|
b6334d | 2004-08-25 | Henrik Grubbström (Grubba) | | while(relabel)
|
66d51c | 1997-03-04 | Fredrik Hübinette (Hubbe) | | {
|
b6334d | 2004-08-25 | Henrik Grubbström (Grubba) | |
|
42ddc6 | 2016-03-24 | Henrik Grubbström (Grubba) | |
memset(labels, 0xff, ((max_label + 2) * 3) * sizeof(INT32));
memset(uses, 0x00, (max_label + 2) * sizeof(INT32));
|
13670c | 2015-05-25 | Martin Nilsson | |
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | c=(p_instr *)instrbuf.s.str;
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | length=instrbuf.s.len / sizeof(p_instr);
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | for(e=0;e<length;e++)
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | if(c[e].opcode == F_LABEL && c[e].arg>=0) {
|
cbeb9b | 2006-02-27 | Martin Stjernholm | | INT32 l = c[e].arg;
|
bd6739 | 2015-10-14 | Martin Nilsson | | labels[l]=(INT32)e;
|
cbeb9b | 2006-02-27 | Martin Stjernholm | | while (e+1 < length &&
c[e+1].opcode == F_LABEL && c[e+1].arg >= 0) {
e++;
|
bd6739 | 2015-10-14 | Martin Nilsson | | labels[c[e].arg] = (INT32)e;
|
cbeb9b | 2006-02-27 | Martin Stjernholm | | aliases[c[e].arg] = l;
}
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | }
|
13670c | 2015-05-25 | Martin Nilsson | |
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | for(e=0;e<length;e++)
|
66d51c | 1997-03-04 | Fredrik Hübinette (Hubbe) | | {
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | if(instrs[c[e].opcode-F_OFFSET].flags & I_POINTER)
|
66d51c | 1997-03-04 | Fredrik Hübinette (Hubbe) | | {
|
cbeb9b | 2006-02-27 | Martin Stjernholm | | if (aliases[c[e].arg] >= 0) c[e].arg = aliases[c[e].arg];
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | while(1)
|
419fab | 1997-03-09 | Fredrik Hübinette (Hubbe) | | {
|
1f88bf | 2001-09-24 | Henrik Grubbström (Grubba) | | int tmp;
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | tmp=labels[c[e].arg];
|
13670c | 2015-05-25 | Martin Nilsson | |
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | while(tmp<length &&
(c[tmp].opcode == F_LABEL ||
c[tmp].opcode == F_NOP)) tmp++;
|
13670c | 2015-05-25 | Martin Nilsson | |
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | if(tmp>=length) break;
|
13670c | 2015-05-25 | Martin Nilsson | |
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | if(c[tmp].opcode==F_BRANCH)
{
c[e].arg=c[tmp].arg;
continue;
}
|
13670c | 2015-05-25 | Martin Nilsson | |
|
419fab | 1997-03-09 | Fredrik Hübinette (Hubbe) | | #define TWOO(X,Y) (((X)<<8)+(Y))
|
13670c | 2015-05-25 | Martin Nilsson | |
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | switch(TWOO(c[e].opcode,c[tmp].opcode))
{
case TWOO(F_LOR,F_BRANCH_WHEN_NON_ZERO):
c[e].opcode=F_BRANCH_WHEN_NON_ZERO;
|
a22fe1 | 2015-04-23 | Henrik Grubbström (Grubba) | |
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | case TWOO(F_LOR,F_LOR):
c[e].arg=c[tmp].arg;
continue;
|
13670c | 2015-05-25 | Martin Nilsson | |
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | case TWOO(F_LAND,F_BRANCH_WHEN_ZERO):
c[e].opcode=F_BRANCH_WHEN_ZERO;
|
a22fe1 | 2015-04-23 | Henrik Grubbström (Grubba) | |
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | case TWOO(F_LAND,F_LAND):
c[e].arg=c[tmp].arg;
continue;
|
13670c | 2015-05-25 | Martin Nilsson | |
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | case TWOO(F_LOR, F_RETURN):
c[e].opcode=F_RETURN_IF_TRUE;
|
281455 | 2003-10-10 | Martin Stjernholm | | goto pointer_opcode_done;
|
13670c | 2015-05-25 | Martin Nilsson | |
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | case TWOO(F_BRANCH, F_RETURN):
case TWOO(F_BRANCH, F_RETURN_0):
case TWOO(F_BRANCH, F_RETURN_1):
case TWOO(F_BRANCH, F_RETURN_LOCAL):
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | | if(c[e].file) {
free_string(dmalloc_touch_named(struct pike_string *,
c[e].file, "branch_opt 1"));
}
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | c[e]=c[tmp];
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | | if(c[e].file) {
add_ref(dmalloc_touch_named(struct pike_string *,
c[e].file, "branch_opt 2"));
}
|
281455 | 2003-10-10 | Martin Stjernholm | | goto pointer_opcode_done;
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | }
|
71c5b9 | 2000-11-27 | Fredrik Hübinette (Hubbe) | | break;
|
419fab | 1997-03-09 | Fredrik Hübinette (Hubbe) | | }
|
281455 | 2003-10-10 | Martin Stjernholm | | #ifdef PIKE_DEBUG
if (c[e].arg < 0 || c[e].arg > max_label)
Pike_fatal ("Invalid index into uses: %d\n", c[e].arg);
#endif
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | uses[c[e].arg]++;
|
66d51c | 1997-03-04 | Fredrik Hübinette (Hubbe) | | }
|
281455 | 2003-10-10 | Martin Stjernholm | | pointer_opcode_done:;
|
66d51c | 1997-03-04 | Fredrik Hübinette (Hubbe) | | }
|
13670c | 2015-05-25 | Martin Nilsson | |
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | for(e=0;e<=max_label;e++)
{
if(!uses[e] && labels[e]>=0)
{
c[labels[e]].opcode=F_NOP;
|
b6334d | 2004-08-25 | Henrik Grubbström (Grubba) | | reoptimize = 1;
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | }
}
|
b6334d | 2004-08-25 | Henrik Grubbström (Grubba) | |
|
cbeb9b | 2006-02-27 | Martin Stjernholm | | if(!reoptimize) {
#ifdef PIKE_DEBUG
if (a_flag > 3) fprintf (stderr, "Optimizer done after relabel.\n");
#endif
break;
}
|
b6334d | 2004-08-25 | Henrik Grubbström (Grubba) | |
|
b9ca5f | 2004-08-25 | Henrik Grubbström (Grubba) | | relabel = asm_opt();
|
b6334d | 2004-08-25 | Henrik Grubbström (Grubba) | |
reoptimize = 0;
|
cbeb9b | 2006-02-27 | Martin Stjernholm | | if (!relabel) {
#ifdef PIKE_DEBUG
if (a_flag > 3) fprintf (stderr, "Optimizer done after asm_opt.\n");
#endif
break;
}
|
b6334d | 2004-08-25 | Henrik Grubbström (Grubba) | |
|
3bc7a6 | 2002-09-24 | Henrik Grubbström (Grubba) | | #if 1
|
281455 | 2003-10-10 | Martin Stjernholm | | #ifdef PIKE_DEBUG
if (a_flag > 3)
fprintf(stderr, "Rerunning optimizer.\n");
#endif
|
3bc7a6 | 2002-09-24 | Henrik Grubbström (Grubba) | | #else /* !1 */
|
b6334d | 2004-08-25 | Henrik Grubbström (Grubba) | | relabel = 0;
|
3bc7a6 | 2002-09-24 | Henrik Grubbström (Grubba) | | #endif /* 1 */
|
66d51c | 1997-03-04 | Fredrik Hübinette (Hubbe) | | }
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | |
|
66d51c | 1997-03-04 | Fredrik Hübinette (Hubbe) | | c=(p_instr *)instrbuf.s.str;
length=instrbuf.s.len / sizeof(p_instr);
for(e=0;e<=max_label;e++) labels[e]=jumps[e]=-1;
|
387ad3 | 2012-07-18 | Henrik Grubbström (Grubba) | |
#ifdef START_NEW_FUNCTION
START_NEW_FUNCTION(store_linenumbers);
#endif
#ifdef ALIGN_PIKE_FUNCTION_BEGINNINGS
while( ( (((INT32) PIKE_PC)+4) & (ALIGN_PIKE_JUMPS-1)))
ins_byte(0);
#endif
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | if (store_linenumbers) {
|
b5575f | 2003-11-24 | Henrik Grubbström (Grubba) | | ins_data(store_prog_string(tripples));
free_string(tripples);
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | } else {
|
cad18a | 2004-08-27 | Martin Nilsson | | ins_data(0);
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | }
|
a852ac | 2012-07-16 | Per Hedbor | |
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | entry_point = PIKE_PC;
|
85f4f5 | 2001-01-31 | Martin Stjernholm | | #ifdef PIKE_DEBUG
synch_depth = 0;
#endif
|
80fe61 | 2001-07-21 | Fredrik Hübinette (Hubbe) | | FLUSH_CODE_GENERATOR_STATE();
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | for(e=0;e<length;e++)
{
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | if (c != (((p_instr *)instrbuf.s.str)+e)) {
|
2d76f2 | 2005-05-20 | Martin Stjernholm | | Pike_fatal("Instruction loop deviates. "
"0x%04"PRINTPTRDIFFT"x != 0x%04"PRINTPTRDIFFT"x\n",
e, c - ((p_instr *)instrbuf.s.str));
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | }
|
9b4ac3 | 2014-11-26 | Henrik Grubbström (Grubba) | | if(((a_flag > 2) && store_linenumbers) ||
(a_flag > 3) ||
(lex->pragmas & ID_DISASSEMBLE))
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | {
|
85f4f5 | 2001-01-31 | Martin Stjernholm | | if (c->opcode == F_POP_SYNCH_MARK) synch_depth--;
|
ef24a8 | 2012-01-12 | Henrik Grubbström (Grubba) | | fprintf(stderr, "===%4ld %4lx %*s", (long)c->line,
|
bd6739 | 2015-10-14 | Martin Nilsson | | (unsigned long)PIKE_PC, synch_depth, "");
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | | dump_instr(c);
fprintf(stderr,"\n");
|
85f4f5 | 2001-01-31 | Martin Stjernholm | | if (c->opcode == F_SYNCH_MARK) synch_depth++;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | }
#endif
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | if(store_linenumbers) {
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | | store_linenumber(c->line, dmalloc_touch_named(struct pike_string *,
c->file,
"store_line"));
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | | #ifdef PIKE_DEBUG
if (c->opcode < F_MAX_OPCODE)
ADD_COMPILED(c->opcode);
#endif /* PIKE_DEBUG */
}
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | |
switch(c->opcode)
{
|
873ceb | 2000-04-30 | Fredrik Hübinette (Hubbe) | | case F_NOP:
|
928f95 | 2000-11-30 | Fredrik Hübinette (Hubbe) | | case F_NOTREACHED:
|
873ceb | 2000-04-30 | Fredrik Hübinette (Hubbe) | | case F_START_FUNCTION:
break;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | case F_ALIGN:
|
dd6bca | 2001-07-20 | Henrik Grubbström (Grubba) | | ins_align(c->arg);
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | break;
|
873ceb | 2000-04-30 | Fredrik Hübinette (Hubbe) | | case F_BYTE:
|
dd6bca | 2001-07-20 | Henrik Grubbström (Grubba) | | ins_byte((unsigned char)(c->arg));
|
873ceb | 2000-04-30 | Fredrik Hübinette (Hubbe) | | break;
|
9b08a2 | 1998-03-31 | Fredrik Hübinette (Hubbe) | | case F_DATA:
|
dd6bca | 2001-07-20 | Henrik Grubbström (Grubba) | | ins_data(c->arg);
|
9b08a2 | 1998-03-31 | Fredrik Hübinette (Hubbe) | | break;
|
a468a0 | 2001-07-24 | Henrik Grubbström (Grubba) | | case F_ENTRY:
#ifdef INS_ENTRY
INS_ENTRY();
|
cbeb9b | 2006-02-27 | Martin Stjernholm | | #else
Pike_fatal ("F_ENTRY is supposed to be gone here.\n");
#endif
|
a468a0 | 2001-07-24 | Henrik Grubbström (Grubba) | | break;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | case F_LABEL:
|
cbeb9b | 2006-02-27 | Martin Stjernholm | | if(c->arg == -1) {
#ifdef PIKE_DEBUG
if (!(debug_options & NO_PEEP_OPTIMIZING))
Pike_fatal ("Failed to optimize away an unused label.\n");
#endif
break;
}
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | if(c->arg > max_label || c->arg < 0)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("max_label calculation failed!\n");
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | |
if(labels[c->arg] != -1)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Duplicate label!\n");
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | #endif
|
80fe61 | 2001-07-21 | Fredrik Hübinette (Hubbe) | | FLUSH_CODE_GENERATOR_STATE();
|
bd6739 | 2015-10-14 | Martin Nilsson | | labels[c->arg] = (INT32)PIKE_PC;
|
9be560 | 2002-11-12 | Henrik Grubbström (Grubba) | | if ((e+1 < length) &&
(c[1].opcode != F_LABEL) &&
(c[1].opcode != F_BYTE) &&
|
45dda9 | 2012-06-10 | Henrik Grubbström (Grubba) | | (c[1].opcode != F_ENTRY) &&
|
9be560 | 2002-11-12 | Henrik Grubbström (Grubba) | | (c[1].opcode != F_DATA)) {
UPDATE_PC();
}
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | break;
|
395899 | 2001-06-23 | Fredrik Hübinette (Hubbe) | | case F_VOLATILE_RETURN:
ins_f_byte(F_RETURN);
break;
|
042070 | 2002-11-02 | Henrik Grubbström (Grubba) | | case F_POINTER:
#ifdef PIKE_DEBUG
if(c->arg > max_label || c->arg < 0)
Pike_fatal("Jump to unknown label?\n");
#endif
|
bd6739 | 2015-10-14 | Martin Nilsson | | tmp = (INT32)PIKE_PC;
|
042070 | 2002-11-02 | Henrik Grubbström (Grubba) | | ins_pointer(jumps[c->arg]);
jumps[c->arg]=tmp;
break;
|
2d1234 | 1997-03-10 | Fredrik Hübinette (Hubbe) | | default:
|
5bb0f1 | 2002-05-11 | Martin Stjernholm | | switch(instrs[c->opcode - F_OFFSET].flags & I_IS_MASK)
|
2d1234 | 1997-03-10 | Fredrik Hübinette (Hubbe) | | {
|
f14284 | 2003-08-06 | Martin Stjernholm | | case I_ISPTRJUMP:
|
852c15 | 2001-07-23 | Fredrik Hübinette (Hubbe) | | #ifdef INS_F_JUMP
|
142b00 | 2003-11-25 | Martin Stjernholm | | tmp=INS_F_JUMP(c->opcode, (labels[c->arg] != -1));
|
852c15 | 2001-07-23 | Fredrik Hübinette (Hubbe) | | if(tmp != -1)
{
|
2dea8f | 2001-08-16 | Marcus Comstedt | | UPDATE_F_JUMP(tmp, jumps[c->arg]);
|
852c15 | 2001-07-23 | Fredrik Hübinette (Hubbe) | | jumps[c->arg]=~tmp;
break;
}
#endif
|
2d1234 | 1997-03-10 | Fredrik Hübinette (Hubbe) | | ins_f_byte(c->opcode);
|
795194 | 2000-04-20 | Fredrik Hübinette (Hubbe) | |
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
042070 | 2002-11-02 | Henrik Grubbström (Grubba) | | if(c->arg > max_label || c->arg < 0)
Pike_fatal("Jump to unknown label?\n");
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | #endif
|
bd6739 | 2015-10-14 | Martin Nilsson | | tmp = (INT32)PIKE_PC;
|
dd6bca | 2001-07-20 | Henrik Grubbström (Grubba) | | ins_pointer(jumps[c->arg]);
|
2d1234 | 1997-03-10 | Fredrik Hübinette (Hubbe) | | jumps[c->arg]=tmp;
break;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | |
|
f14284 | 2003-08-06 | Martin Stjernholm | | case I_ISPTRJUMPARGS:
|
b40153 | 2002-11-02 | Henrik Grubbström (Grubba) | | #ifdef INS_F_JUMP_WITH_TWO_ARGS
|
142b00 | 2003-11-25 | Martin Stjernholm | | tmp = INS_F_JUMP_WITH_TWO_ARGS(c->opcode, c->arg, c->arg2,
|
46b1bf | 2003-11-26 | Henrik Grubbström (Grubba) | | (labels[c[1].arg] != -1));
|
b40153 | 2002-11-02 | Henrik Grubbström (Grubba) | | if(tmp != -1)
{
#ifdef PIKE_DEBUG
if (c[1].opcode != F_POINTER) {
Pike_fatal("Expected opcode %s to be followed by a pointer\n",
instrs[c->opcode - F_OFFSET].name);
}
#endif /* PIKE_DEBUG */
c++;
e++;
UPDATE_F_JUMP(tmp, jumps[c->arg]);
jumps[c->arg]=~tmp;
break;
}
#endif /* INS_F_JUMP_WITH_TWO_ARGS */
|
dd6bca | 2001-07-20 | Henrik Grubbström (Grubba) | | case I_TWO_ARGS:
|
f14284 | 2003-08-06 | Martin Stjernholm | | case I_ISJUMPARGS:
|
dd6bca | 2001-07-20 | Henrik Grubbström (Grubba) | | ins_f_byte_with_2_args(c->opcode, c->arg, c->arg2);
break;
|
042070 | 2002-11-02 | Henrik Grubbström (Grubba) | |
|
f14284 | 2003-08-06 | Martin Stjernholm | | case I_ISPTRJUMPARG:
|
b40153 | 2002-11-02 | Henrik Grubbström (Grubba) | | #ifdef INS_F_JUMP_WITH_ARG
|
46b1bf | 2003-11-26 | Henrik Grubbström (Grubba) | | tmp = INS_F_JUMP_WITH_ARG(c->opcode, c->arg, (labels[c[1].arg] != -1));
|
b40153 | 2002-11-02 | Henrik Grubbström (Grubba) | | if(tmp != -1)
{
#ifdef PIKE_DEBUG
if (c[1].opcode != F_POINTER) {
Pike_fatal("Expected opcode %s to be followed by a pointer\n",
instrs[c->opcode - F_OFFSET].name);
}
#endif /* PIKE_DEBUG */
c++;
e++;
UPDATE_F_JUMP(tmp, jumps[c->arg]);
jumps[c->arg]=~tmp;
break;
}
#endif /* INS_F_JUMP_WITH_ARG */
|
dd6bca | 2001-07-20 | Henrik Grubbström (Grubba) | | case I_HASARG:
|
f14284 | 2003-08-06 | Martin Stjernholm | | case I_ISJUMPARG:
|
dd6bca | 2001-07-20 | Henrik Grubbström (Grubba) | | ins_f_byte_with_arg(c->opcode, c->arg);
break;
|
2d1234 | 1997-03-10 | Fredrik Hübinette (Hubbe) | |
case 0:
|
f14284 | 2003-08-06 | Martin Stjernholm | | case I_ISJUMP:
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | ins_f_byte(c->opcode);
|
2d1234 | 1997-03-10 | Fredrik Hübinette (Hubbe) | | break;
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
2d1234 | 1997-03-10 | Fredrik Hübinette (Hubbe) | | default:
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("Unknown instruction type.\n");
|
2d1234 | 1997-03-10 | Fredrik Hübinette (Hubbe) | | #endif
}
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | }
|
852c15 | 2001-07-23 | Fredrik Hübinette (Hubbe) | |
|
042070 | 2002-11-02 | Henrik Grubbström (Grubba) | | #ifdef PIKE_DEBUG
if (instrs[c->opcode - F_OFFSET].flags & I_HASPOINTER) {
|
dabab3 | 2002-11-04 | Henrik Grubbström (Grubba) | | if ((e+1 >= length) || (c[1].opcode != F_POINTER)) {
|
042070 | 2002-11-02 | Henrik Grubbström (Grubba) | | Pike_fatal("Expected instruction %s to be followed by a pointer.\n"
|
dabab3 | 2002-11-04 | Henrik Grubbström (Grubba) | | "Got %s (%d != %d)\n.",
|
042070 | 2002-11-02 | Henrik Grubbström (Grubba) | | instrs[c->opcode - F_OFFSET].name,
|
dabab3 | 2002-11-04 | Henrik Grubbström (Grubba) | | (e+1 < length)?instrs[c[1].opcode - F_OFFSET].name:"EOI",
(e+1 < length)?c[1].opcode:0, F_POINTER);
|
042070 | 2002-11-02 | Henrik Grubbström (Grubba) | | }
}
#endif /* PIKE_DEBUG */
|
852c15 | 2001-07-23 | Fredrik Hübinette (Hubbe) | | #ifdef ALIGN_PIKE_JUMPS
if(e+1 < length)
{
|
b40153 | 2002-11-02 | Henrik Grubbström (Grubba) | | |
f14284 | 2003-08-06 | Martin Stjernholm | | * I_ISPTRJUMPARG or I_ISPTRJUMPARGS, since c may already
|
b40153 | 2002-11-02 | Henrik Grubbström (Grubba) | | * have been advanced to the corresponding F_POINTER.
* With the current opcode set this is a non-issue, but...
* /grubba 2002-11-02
*/
|
852c15 | 2001-07-23 | Fredrik Hübinette (Hubbe) | | switch(c->opcode)
{
case F_RETURN:
case F_VOLATILE_RETURN:
case F_BRANCH:
case F_RETURN_0:
case F_RETURN_1:
case F_RETURN_LOCAL:
|
13670c | 2015-05-25 | Martin Nilsson | |
|
852c15 | 2001-07-23 | Fredrik Hübinette (Hubbe) | | #define CALLS(X) \
case PIKE_CONCAT3(F_,X,_AND_RETURN): \
case PIKE_CONCAT3(F_MARK_,X,_AND_RETURN):
|
13670c | 2015-05-25 | Martin Nilsson | |
|
852c15 | 2001-07-23 | Fredrik Hübinette (Hubbe) | | CALLS(APPLY)
CALLS(CALL_FUNCTION)
CALLS(CALL_LFUN)
CALLS(CALL_BUILTIN)
|
1302b1 | 2001-08-14 | Martin Stjernholm | | while( ((INT32) PIKE_PC & (ALIGN_PIKE_JUMPS-1) ) )
|
852c15 | 2001-07-23 | Fredrik Hübinette (Hubbe) | | ins_byte(0);
}
}
#endif
|
13670c | 2015-05-25 | Martin Nilsson | |
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | c++;
}
for(e=0;e<=max_label;e++)
{
|
c69624 | 2001-07-18 | Henrik Grubbström (Grubba) | | INT32 tmp2=labels[e];
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | |
while(jumps[e]!=-1)
{
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | if(labels[e]==-1)
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | Pike_fatal("Hyperspace error: unknown jump point %ld(%ld) at %d (pc=%x).\n",
|
6da27e | 2016-02-12 | Martin Nilsson | | (long)e, (long)max_label, labels[e], jumps[e]);
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | #endif
|
852c15 | 2001-07-23 | Fredrik Hübinette (Hubbe) | | #ifdef INS_F_JUMP
if(jumps[e] < 0)
{
|
2dea8f | 2001-08-16 | Marcus Comstedt | | tmp = READ_F_JUMP(~jumps[e]);
|
852c15 | 2001-07-23 | Fredrik Hübinette (Hubbe) | | UPDATE_F_JUMP(~jumps[e], tmp2);
jumps[e]=tmp;
continue;
}
#endif
|
dd6bca | 2001-07-20 | Henrik Grubbström (Grubba) | | tmp = read_pointer(jumps[e]);
upd_pointer(jumps[e], tmp2 - jumps[e]);
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | jumps[e]=tmp;
}
}
|
0ec752 | 2014-04-27 | Martin Nilsson | | free(labels);
|
66d51c | 1997-03-04 | Fredrik Hübinette (Hubbe) | |
|
a852ac | 2012-07-16 | Per Hedbor | | #ifdef END_FUNCTION
END_FUNCTION(store_linenumbers);
#endif
|
4974fa | 2002-11-07 | Henrik Grubbström (Grubba) | | #ifdef PIKE_DEBUG
if (a_flag > 6) {
size_t len = (Pike_compiler->new_program->num_program - fun_start)*
sizeof(PIKE_OPCODE_T);
|
2d76f2 | 2005-05-20 | Martin Stjernholm | | fprintf(stderr, "Code at offset %"PRINTSIZET"d through %"PRINTSIZET"d:\n",
|
2abf52 | 2002-11-07 | Henrik Grubbström (Grubba) | | fun_start, Pike_compiler->new_program->num_program-1);
|
4974fa | 2002-11-07 | Henrik Grubbström (Grubba) | | #ifdef DISASSEMBLE_CODE
DISASSEMBLE_CODE(Pike_compiler->new_program->program + fun_start, len);
#else /* !DISASSEMBLE_CODE */
{
}
#endif /* DISASSEMBLE_CODE */
}
#endif /* PIKE_DEBUG */
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | |
exit_bytecode();
|
ee6a78 | 2003-11-19 | Henrik Grubbström (Grubba) | |
return entry_point;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | }
|
332772 | 2006-09-17 | Henrik Grubbström (Grubba) | | static void do_optimization(int topop, int topush, ...);
|
01b921 | 2016-01-12 | Per Hedbor | | static inline int opcode(int offset);
static inline int argument(int offset);
static inline int argument2(int offset);
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | |
#include "peep_engine.c"
|
332772 | 2006-09-17 | Henrik Grubbström (Grubba) | | #ifndef PEEP_STACK_SIZE
#define PEEP_STACK_SIZE 256
#endif
static long stack_depth = 0;
static p_instr instrstack[PEEP_STACK_SIZE];
|
a7538d | 1998-05-12 | Fredrik Hübinette (Hubbe) | | int remove_clear_locals=0x7fffffff;
|
7a35a4 | 2000-08-14 | Henrik Grubbström (Grubba) | | static ptrdiff_t eye, len;
|
06983f | 1996-09-22 | Fredrik Hübinette (Hubbe) | | static p_instr *instructions;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | |
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | |
|
01b921 | 2016-01-12 | Per Hedbor | | static inline p_instr *insopt2(int f, INT32 a, INT32 b,
|
ef24a8 | 2012-01-12 | Henrik Grubbström (Grubba) | | INT_TYPE cl, struct pike_string *cf)
|
419fab | 1997-03-09 | Fredrik Hübinette (Hubbe) | | {
p_instr *p;
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | | if(!hasarg2(f) && b)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("hasarg2(%d /*%s */) is wrong!\n",f,get_f_name(f));
|
419fab | 1997-03-09 | Fredrik Hübinette (Hubbe) | | #endif
|
332772 | 2006-09-17 | Henrik Grubbström (Grubba) | | p = instrstack + stack_depth++;
|
419fab | 1997-03-09 | Fredrik Hübinette (Hubbe) | |
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
332772 | 2006-09-17 | Henrik Grubbström (Grubba) | | if(stack_depth > PEEP_STACK_SIZE)
Pike_fatal("Instructions stacked too high!!!!!!\n");
|
419fab | 1997-03-09 | Fredrik Hübinette (Hubbe) | | #endif
p->opcode=f;
|
e7df5b | 1997-03-17 | Fredrik Hübinette (Hubbe) | | p->line=cl;
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | | copy_shared_string(p->file, dmalloc_touch_named(struct pike_string *,
cf, "insopt2"));
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | | p->arg=a;
p->arg2=b;
|
419fab | 1997-03-09 | Fredrik Hübinette (Hubbe) | |
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | return p;
|
419fab | 1997-03-09 | Fredrik Hübinette (Hubbe) | | }
|
01b921 | 2016-01-12 | Per Hedbor | | static inline p_instr *insopt1(int f, INT32 a, INT_TYPE cl,
|
ef24a8 | 2012-01-12 | Henrik Grubbström (Grubba) | | struct pike_string *cf)
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | | {
#ifdef PIKE_DEBUG
if(!hasarg(f) && a)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("hasarg(%d /* %s */) is wrong!\n",f,get_f_name(f));
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | | #endif
return insopt2(f,a,0,cl, cf);
}
|
01b921 | 2016-01-12 | Per Hedbor | | static inline p_instr *insopt0(int f, INT_TYPE cl, struct pike_string *cf)
|
419fab | 1997-03-09 | Fredrik Hübinette (Hubbe) | | {
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
419fab | 1997-03-09 | Fredrik Hübinette (Hubbe) | | if(hasarg(f))
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("hasarg(%d /* %s */) is wrong!\n",f,get_f_name(f));
|
419fab | 1997-03-09 | Fredrik Hübinette (Hubbe) | | #endif
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | | return insopt2(f,0,0,cl, cf);
|
419fab | 1997-03-09 | Fredrik Hübinette (Hubbe) | | }
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | #ifdef PIKE_DEBUG
|
be478c | 1997-08-30 | Henrik Grubbström (Grubba) | | static void debug(void)
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | {
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | if (num_instrs != (long)instrbuf.s.len / (long)sizeof(p_instr)) {
Pike_fatal("PEEP: instrbuf lost count (%d != %d)\n",
num_instrs, (long)instrbuf.s.len / (long)sizeof(p_instr));
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | | }
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | if(instrbuf.s.len)
{
|
66d51c | 1997-03-04 | Fredrik Hübinette (Hubbe) | | p_instr *p;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | p=(p_instr *)low_make_buf_space(0, &instrbuf);
if(!p[-1].file)
|
5aad93 | 2002-08-15 | Marcus Comstedt | | Pike_fatal("No file name on last instruction!\n");
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | }
|
66d51c | 1997-03-04 | Fredrik Hübinette (Hubbe) | | }
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | #else
#define debug()
#endif
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | |
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | |
|
01b921 | 2016-01-12 | Per Hedbor | | static inline p_instr *instr(int offset)
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | {
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | if (offset >= num_instrs) return NULL;
return ((p_instr *)low_make_buf_space(0, &instrbuf)) - (offset + 1);
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | }
|
01b921 | 2016-01-12 | Per Hedbor | | static inline int opcode(int offset)
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | {
p_instr *a;
a=instr(offset);
if(a) return a->opcode;
return -1;
}
|
01b921 | 2016-01-12 | Per Hedbor | | static inline int argument(int offset)
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | {
p_instr *a;
a=instr(offset);
if(a) return a->arg;
return -1;
}
|
01b921 | 2016-01-12 | Per Hedbor | | static inline int argument2(int offset)
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | | {
p_instr *a;
a=instr(offset);
if(a) return a->arg2;
return -1;
}
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | static int advance(void)
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | {
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | p_instr *p;
if(stack_depth)
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | {
|
332772 | 2006-09-17 | Henrik Grubbström (Grubba) | | p = instrstack + --stack_depth;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | }else{
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | if (eye >= len) return 0;
p = instructions + eye;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | eye++;
}
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | insert_opcode(p);
|
332772 | 2006-09-17 | Henrik Grubbström (Grubba) | | debug_malloc_touch_named(p->file, "advance");
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | debug();
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | return 1;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | }
static void pop_n_opcodes(int n)
{
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | int e;
|
cffe88 | 2007-04-19 | Martin Stjernholm | | p_instr *p;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | |
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | if (n > num_instrs)
Pike_fatal("Popping out of instructions.\n");
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | #endif
|
66d51c | 1997-03-04 | Fredrik Hübinette (Hubbe) | |
|
cffe88 | 2007-04-19 | Martin Stjernholm | | p = ((p_instr *)low_make_buf_space(0, &instrbuf)) - n;
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | for (e = 0; e < n; e++) {
free_string(dmalloc_touch_named(struct pike_string *, p[e].file,
"pop_n_opcodes"));
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | }
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | num_instrs -= n;
low_make_buf_space(-((INT32)sizeof(p_instr))*n, &instrbuf);
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | }
|
b95670 | 2000-11-25 | Henrik Grubbström (Grubba) | |
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | |
|
332772 | 2006-09-17 | Henrik Grubbström (Grubba) | | static void do_optimization(int topop, int topush, ...)
|
8ebb6a | 1998-04-27 | Fredrik Hübinette (Hubbe) | | {
va_list arglist;
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | int q=0;
int oplen;
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | | struct pike_string *cf;
|
ef24a8 | 2012-01-12 | Henrik Grubbström (Grubba) | | INT_TYPE cl=instr(0)->line;
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | |
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | | #ifdef PIKE_DEBUG
if(a_flag>5)
{
int e;
|
ef24a8 | 2012-01-12 | Henrik Grubbström (Grubba) | | fprintf(stderr, "PEEP at %ld:", cl);
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | for(e = topop; e--;)
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | | {
fprintf(stderr," ");
dump_instr(instr(e));
}
fprintf(stderr," => ");
}
#endif
|
332772 | 2006-09-17 | Henrik Grubbström (Grubba) | | if (stack_depth + topush > PEEP_STACK_SIZE) {
#ifdef PIKE_DEBUG
if (a_flag) {
fprintf(stderr, "PEEP stack full.\n");
}
#endif
return;
}
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | | copy_shared_string(cf,dmalloc_touch_named(struct pike_string *,
instr(0)->file,
"do_optimization"));
pop_n_opcodes(topop);
|
b95670 | 2000-11-25 | Henrik Grubbström (Grubba) | |
|
332772 | 2006-09-17 | Henrik Grubbström (Grubba) | | va_start(arglist, topush);
|
13670c | 2015-05-25 | Martin Nilsson | |
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | while((oplen = va_arg(arglist, int)))
|
8ebb6a | 1998-04-27 | Fredrik Hübinette (Hubbe) | | {
q++;
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | switch(oplen)
|
8ebb6a | 1998-04-27 | Fredrik Hübinette (Hubbe) | | {
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | #ifdef PIKE_DEBUG
default:
Pike_fatal("Unsupported argument number: %d\n", oplen);
|
8ebb6a | 1998-04-27 | Fredrik Hübinette (Hubbe) | | break;
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | #endif /* PIKE_DEBUG */
|
8ebb6a | 1998-04-27 | Fredrik Hübinette (Hubbe) | | case 1:
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | {
int i=va_arg(arglist, int);
insopt0(i,cl,cf);
}
break;
|
8ebb6a | 1998-04-27 | Fredrik Hübinette (Hubbe) | | case 2:
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | {
int i=va_arg(arglist, int);
int j=va_arg(arglist, int);
insopt1(i,j,cl,cf);
}
break;
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | | case 3:
|
c6c623 | 2002-08-30 | Henrik Grubbström (Grubba) | | {
int i=va_arg(arglist, int);
int j=va_arg(arglist, int);
int k=va_arg(arglist, int);
insopt2(i,j,k,cl,cf);
}
break;
|
8ebb6a | 1998-04-27 | Fredrik Hübinette (Hubbe) | | }
}
va_end(arglist);
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | |
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | |
free_string(dmalloc_touch_named(struct pike_string *, cf,
"do_optimization"));
debug();
#ifdef PIKE_DEBUG
if(a_flag>5)
{
|
332772 | 2006-09-17 | Henrik Grubbström (Grubba) | | p_instr *p = instrstack + stack_depth;
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | | int e;
for(e=0;e<q;e++)
{
fprintf(stderr," ");
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | dump_instr(p-(e+1));
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | | }
fprintf(stderr,"\n");
}
|
332772 | 2006-09-17 | Henrik Grubbström (Grubba) | | if (q != topush) {
Pike_fatal("PEEP: Lost track of instructions to push (%d != %d)\n",
q, topush);
}
|
65ca2f | 2006-09-05 | Henrik Grubbström (Grubba) | | #endif
|
8ebb6a | 1998-04-27 | Fredrik Hübinette (Hubbe) | | }
|
b9ca5f | 2004-08-25 | Henrik Grubbström (Grubba) | | static int asm_opt(void)
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | {
|
b9ca5f | 2004-08-25 | Henrik Grubbström (Grubba) | | int relabel = 0;
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | if(a_flag > 3)
{
p_instr *c;
|
7a35a4 | 2000-08-14 | Henrik Grubbström (Grubba) | | ptrdiff_t e, length;
|
85f4f5 | 2001-01-31 | Martin Stjernholm | | int synch_depth = 0;
|
7a35a4 | 2000-08-14 | Henrik Grubbström (Grubba) | |
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | c=(p_instr *)instrbuf.s.str;
length=instrbuf.s.len / sizeof(p_instr);
|
281455 | 2003-10-10 | Martin Stjernholm | | fprintf(stderr,"Before peep optimization:\n");
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | for(e=0;e<length;e++,c++)
{
|
85f4f5 | 2001-01-31 | Martin Stjernholm | | if (c->opcode == F_POP_SYNCH_MARK) synch_depth--;
|
ef24a8 | 2012-01-12 | Henrik Grubbström (Grubba) | | fprintf(stderr,"<<<%4ld: %*s",(long)c->line,synch_depth,"");
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | | dump_instr(c);
fprintf(stderr,"\n");
|
85f4f5 | 2001-01-31 | Martin Stjernholm | | if (c->opcode == F_SYNCH_MARK) synch_depth++;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | }
}
#endif
|
0c2457 | 2003-10-17 | Martin Nilsson | | len=instrbuf.s.len/sizeof(p_instr);
instructions=(p_instr *)instrbuf.s.str;
instrbuf.s.str=0;
init_bytecode();
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | for(eye = 0; advance();)
|
0c2457 | 2003-10-17 | Martin Nilsson | | {
#ifdef PIKE_DEBUG
if(a_flag>6) {
int e;
|
bd6739 | 2015-10-14 | Martin Nilsson | | fprintf(stderr, "#%ld,%ld:", (long)eye, stack_depth);
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | | for(e = 4;e--;) {
|
0c2457 | 2003-10-17 | Martin Nilsson | | fprintf(stderr," ");
dump_instr(instr(e));
}
|
238311 | 2006-09-16 | Henrik Grubbström (Grubba) | |
|
0c2457 | 2003-10-17 | Martin Nilsson | | fprintf(stderr,"\n");
}
#endif
|
b9ca5f | 2004-08-25 | Henrik Grubbström (Grubba) | | relabel |= low_asm_opt();
|
0c2457 | 2003-10-17 | Martin Nilsson | | }
|
0ec752 | 2014-04-27 | Martin Nilsson | | free(instructions);
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | |
|
71f3a2 | 1998-11-22 | Fredrik Hübinette (Hubbe) | | #ifdef PIKE_DEBUG
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | if(a_flag > 4)
{
p_instr *c;
|
7a35a4 | 2000-08-14 | Henrik Grubbström (Grubba) | | ptrdiff_t e, length;
|
281455 | 2003-10-10 | Martin Stjernholm | | int synch_depth = 0;
|
7a35a4 | 2000-08-14 | Henrik Grubbström (Grubba) | |
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | c=(p_instr *)instrbuf.s.str;
length=instrbuf.s.len / sizeof(p_instr);
|
281455 | 2003-10-10 | Martin Stjernholm | | fprintf(stderr,"After peep optimization:\n");
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | for(e=0;e<length;e++,c++)
{
|
281455 | 2003-10-10 | Martin Stjernholm | | if (c->opcode == F_POP_SYNCH_MARK) synch_depth--;
|
ef24a8 | 2012-01-12 | Henrik Grubbström (Grubba) | | fprintf(stderr,">>>%4ld: %*s",(long)c->line,synch_depth,"");
|
a96ce9 | 2000-04-19 | Fredrik Hübinette (Hubbe) | | dump_instr(c);
fprintf(stderr,"\n");
|
281455 | 2003-10-10 | Martin Stjernholm | | if (c->opcode == F_SYNCH_MARK) synch_depth++;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | }
}
#endif
|
b9ca5f | 2004-08-25 | Henrik Grubbström (Grubba) | |
return relabel;
|
2199ed | 1996-04-13 | Fredrik Hübinette (Hubbe) | | }
|