X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fas3%2Fcode.c;h=9fce3a8f91e132d356905fe00b0cd3eeb6518889;hb=35b692b1792f584c2b8d69cbbefa7794e3619f86;hp=4a18c5289a098b1b3f21cba01b8419f0e86d238d;hpb=8b94e3aae7e61b3e1e5459addac62aaa7ea5c5bd;p=swftools.git diff --git a/lib/as3/code.c b/lib/as3/code.c index 4a18c52..9fce3a8 100644 --- a/lib/as3/code.c +++ b/lib/as3/code.c @@ -37,6 +37,7 @@ #define OP_LOOKUPSWITCH 512 #define OP_NEED_ACTIVATION 1024 #define OP_STACK_ARGS2 2048 +#define OP_INTERNAL 32768 /* 2 = u30 index into multiname m = u30 index into method @@ -152,9 +153,7 @@ opcode_t opcodes[]={ {0x57, "newactivation", "", 0, 1, 0, OP_NEED_ACTIVATION}, {0x56, "newarray", "n", 0, 1, 0, OP_STACK_ARGS}, {0x5a, "newcatch", "u", 0, 1, 0, 0}, //u = index into exception_info -#define OP_NEWCLASS 0x58 {0x58, "newclass", "c", -1, 1, 0, 0}, //c = index into class_info -#define OP_NEWFUNCTION 0x40 {0x40, "newfunction", "m", 0, 1, 0, 0}, //i = index into method_info {0x55, "newobject", "n", 0, 1, 0, OP_STACK_ARGS2}, {0x1e, "nextname", "", -2, 1, 0, 0}, @@ -197,8 +196,13 @@ opcode_t opcodes[]={ {0x95, "typeof", "", -1, 1, 0, 0}, {0xa7, "urshift", "", -2, 1, 0, 0}, -/* dummy instruction. Warning: this one are not actually supported by flash */ -{0xff, "__break__", "", 0, 0, 0, OP_RETURN}, +/* opcodes not documented, but seen in the wild */ +//0x53: seen in builtin.abc +{0x53, "applytype", "n", -1, 1, 0, OP_STACK_ARGS}, + +/* dummy instruction. Warning: this one is not actually supported by flash */ +{0xfe, "__continue__", "s", 0, 0, 0, OP_RETURN|OP_INTERNAL}, +{0xff, "__break__", "s", 0, 0, 0, OP_RETURN|OP_INTERNAL}, }; static U8 op2index[256] = {254}; @@ -274,7 +278,7 @@ code_t*code_parse(TAG*tag, int len, abc_file_t*file, pool_t*pool, codelookup_t** opcode_t*op = opcode_get(opcode); if(!op) { fprintf(stderr, "Can't parse opcode %02x\n", opcode); - return head; + continue; } //printf("%s\n", op->name);fflush(stdout); NEW(code_t,c); @@ -323,7 +327,8 @@ code_t*code_parse(TAG*tag, int len, abc_file_t*file, pool_t*pool, codelookup_t** int j = swf_GetS24(tag); data = (void*)(ptroff_t)j; } else if(*p == 's') { // string - data = strdup((char*)pool_lookup_string(pool, swf_GetU30(tag))); + string_t s = pool_lookup_string2(pool, swf_GetU30(tag)); + data = string_dup3(&s); } else if(*p == 'D') { // debug /*type, usually 1*/ U8 type = swf_GetU8(tag); @@ -455,6 +460,15 @@ static int opcode_write(TAG*tag, code_t*c, pool_t*pool, abc_file_t*file, int len swf_SetU8(tag, c->opcode); len++; + if(op->flags & OP_INTERNAL) { + if(c->opcode == OPCODE___BREAK__ || + c->opcode == OPCODE___CONTINUE__) { + fprintf(stderr, "Unresolved %s\n", op->name); + } else { + fprintf(stderr, "Error: writing undefined internal opcode %s", op->name); + } + } + while(*p) { void*data = c->data[pos++]; assert(pos<=2); @@ -492,7 +506,7 @@ static int opcode_write(TAG*tag, code_t*c, pool_t*pool, abc_file_t*file, int len skip = (c->branch->pos) - c->pos - 4; len += swf_SetS24(tag, skip); } else if(*p == 's') { // string - int index = pool_register_string(pool, data); + int index = pool_register_string2(pool, (string_t*)data); len += swf_SetU30(tag, index); } else if(*p == 'D') { // debug statement if(tag) @@ -679,12 +693,12 @@ static char callcode(currentstats_t*stats, int pos, int stack, int scope) if(op->flags & OP_NEED_ACTIVATION) stats->flags |= FLAGS_ACTIVATION; - if(c->opcode == OP_NEWCLASS) { + if(c->opcode == OPCODE_NEWCLASS) { abc_class_t*cls = (abc_class_t*)(c->data[0]); if(scope > cls->init_scope_depth) cls->init_scope_depth = scope; } - if(c->opcode == OP_NEWFUNCTION) { + if(c->opcode == OPCODE_NEWFUNCTION) { abc_method_t*m = (abc_method_t*)(c->data[0]); if(m->body && scope > m->body->init_scope_depth) m->body->init_scope_depth = scope; @@ -770,7 +784,7 @@ static char callcode(currentstats_t*stats, int pos, int stack, int scope) return 1; } -static currentstats_t* code_get_stats(code_t*code, exception_list_t*exceptions) +static currentstats_t* code_get_stats(code_t*code, abc_exception_list_t*exceptions) { code = code_find_start(code); int num = 0; @@ -819,10 +833,10 @@ static currentstats_t* code_get_stats(code_t*code, exception_list_t*exceptions) free(current); return 0; } - exception_list_t*e = exceptions; + abc_exception_list_t*e = exceptions; while(e) { - if(e->exception->target) - callcode(current, e->exception->target->pos, 1, 0); + if(e->abc_exception->target) + callcode(current, e->abc_exception->target->pos, 1, 0); e = e->next; } @@ -837,9 +851,9 @@ void stats_free(currentstats_t*stats) } } -int code_dump(code_t*c, exception_list_t*exceptions, abc_file_t*file, char*prefix, FILE*fo) +int code_dump(code_t*c, abc_exception_list_t*exceptions, abc_file_t*file, char*prefix, FILE*fo) { - exception_list_t*e = exceptions; + abc_exception_list_t*e = exceptions; c = code_find_start(c); currentstats_t*stats = code_get_stats(c, exceptions); @@ -851,11 +865,11 @@ int code_dump(code_t*c, exception_list_t*exceptions, abc_file_t*file, char*prefi e = exceptions; while(e) { - if(c==e->exception->from) + if(c==e->abc_exception->from) fprintf(fo, "%s TRY {\n", prefix); - if(c==e->exception->target) { - char*s1 = multiname_tostring(e->exception->exc_type); - char*s2 = multiname_tostring(e->exception->var_name); + if(c==e->abc_exception->target) { + char*s1 = multiname_tostring(e->abc_exception->exc_type); + char*s2 = multiname_tostring(e->abc_exception->var_name); fprintf(fo, "%s CATCH(%s %s)\n", prefix, s1, s2); free(s1); free(s2); @@ -897,7 +911,7 @@ int code_dump(code_t*c, exception_list_t*exceptions, abc_file_t*file, char*prefi free(m); } else if(*p == 'm') { abc_method_t*m = (abc_method_t*)data; - fprintf(fo, "[method %s]", m->name); + fprintf(fo, "[method %08x %s]", m, m->name); } else if(*p == 'c') { abc_class_t*cls = (abc_class_t*)data; char*classname = multiname_tostring(cls->classname); @@ -924,7 +938,9 @@ int code_dump(code_t*c, exception_list_t*exceptions, abc_file_t*file, char*prefi else fprintf(fo, "%08x", c->branch); } else if(*p == 's') { - fprintf(fo, "\"%s\"", data); + char*s = string_escape((string_t*)data); + fprintf(fo, "\"%s\"", s); + free(s); } else if(*p == 'D') { fprintf(fo, "[register %02x=%s]", (ptroff_t)c->data[1], (char*)c->data[0]); } else if(*p == 'S') { @@ -956,9 +972,9 @@ int code_dump(code_t*c, exception_list_t*exceptions, abc_file_t*file, char*prefi e = exceptions; while(e) { - if(c==e->exception->to) { - if(e->exception->target) - fprintf(fo, "%s } // END TRY (HANDLER: %d)\n", prefix, e->exception->target->pos); + if(c==e->abc_exception->to) { + if(e->abc_exception->target) + fprintf(fo, "%s } // END TRY (HANDLER: %d)\n", prefix, e->abc_exception->target->pos); else fprintf(fo, "%s } // END TRY (HANDLER: 00000000)\n", prefix); } @@ -972,7 +988,7 @@ int code_dump(code_t*c, exception_list_t*exceptions, abc_file_t*file, char*prefi return 1; } -codestats_t* code_get_statistics(code_t*code, exception_list_t*exceptions) +codestats_t* code_get_statistics(code_t*code, abc_exception_list_t*exceptions) { currentstats_t*current = code_get_stats(code, exceptions); if(!current) @@ -1043,3 +1059,111 @@ code_t* code_append(code_t*code, code_t*toappend) return code_end(toappend); } +lookupswitch_t*lookupswitch_dup(lookupswitch_t*l) +{ + lookupswitch_t*n = malloc(sizeof(lookupswitch_t)); + fprintf(stderr, "Error: lookupswitch dupping not supported yet\n"); + n->targets = list_clone(l->targets); + return 0; +} + +code_t*code_dup(code_t*c) +{ + if(!c) return 0; + + while(c->prev) c = c->prev; + + code_t*last = 0; + while(c) { + NEW(code_t, n); + memcpy(n, c, sizeof(code_t)); + + opcode_t*op = opcode_get(c->opcode); + if(c->branch) { + fprintf(stderr, "Error: Can't duplicate branching code\n"); + return 0; + } + char*p = op?op->params:""; + int pos=0; + while(*p) { + if(*p == '2') { //multiname + c->data[pos] = multiname_clone(c->data[pos]); + } else if(*p == 's') { + c->data[pos] = string_dup3(c->data[pos]); + } else if(*p == 'D') { + c->data[pos] = strdup(c->data[pos]); + } else if(*p == 'f') { + double old = *(double*)c->data[pos]; + c->data[pos] = malloc(sizeof(double)); + *(double*)c->data[pos] = old; + } else if(strchr("S", *p)) { + c->data[pos] = lookupswitch_dup(c->data[pos]); + } + p++;pos++; + } + + n->prev = last; + if(last) { + last->next = n; + } + last = n; + c = c->next; + } + return last; +} + +code_t*code_cutlast(code_t*c) +{ + if(!c) return c; + assert(!c->next); + code_t*prev = c->prev; + c->prev = 0; + if(prev) + prev->next=0; + code_free(c); + return prev; +} + +code_t* cut_last_push(code_t*c) +{ + while(c) { + if(!c) break; + opcode_t*op = opcode_get(c->opcode); + /* cut conversion type operations */ + if(op->stack_minus == -1 && op->stack_plus == 1 && !(op->flags)) { + c = code_cutlast(c); + continue; + } + /* cut any type of push */ + else if(op->stack_minus == 0 && op->stack_plus == 1 && !(op->flags)) { + return code_cutlast(c); + } + /* cut register lookups */ + else if(c->opcode == OPCODE_GETLOCAL || + c->opcode == OPCODE_GETLOCAL_0 || + c->opcode == OPCODE_GETLOCAL_1 || + c->opcode == OPCODE_GETLOCAL_2 || + c->opcode == OPCODE_GETLOCAL_3) { + return code_cutlast(c); + } + /* discard function call values */ + else if(c->opcode == OPCODE_CALLPROPERTY) { + c->opcode = OPCODE_CALLPROPVOID; + return c; + } else if(c->opcode == OPCODE_CALLSUPER) { + c->opcode = OPCODE_CALLSUPERVOID; + return c; + } else if(c->opcode == OPCODE_NEWOBJECT || + c->opcode == OPCODE_NEWARRAY) { + // we can discard these if they're not eating up stack parameters + if(!c->data[0]) + return code_cutlast(c); + } + else + break; + } + c = abc_pop(c); + return c; +} + +