jcov_util.c

来自「This is a resource based on j2me embedde」· C语言 代码 · 共 647 行 · 第 1/2 页

        case JVM_CONSTANT_Class:
            cp_buf->u.Class.name_index = read2bytes(buf, len, err_code);
            break;
        case JVM_CONSTANT_Methodref:
            cp_buf->u.Methodref.class_index = read2bytes(buf, len, err_code);
            if (*err_code) break;
            cp_buf->u.Methodref.name_and_type_index = read2bytes(buf, len, err_code);
            break;
        case JVM_CONSTANT_InterfaceMethodref:
            cp_buf->u.InterfaceMethodref.class_index = read2bytes(buf, len, err_code);
            if (*err_code) break;
            cp_buf->u.InterfaceMethodref.name_and_type_index = read2bytes(buf, len, err_code);
            break;
        case JVM_CONSTANT_NameAndType:
            cp_buf->u.NameAndType.name_index = read2bytes(buf, len, err_code);
            if (*err_code) break;
            cp_buf->u.NameAndType.type_index = read2bytes(buf, len, err_code);
            break;
        case JVM_CONSTANT_Integer:
        case JVM_CONSTANT_Float:
            /* we're not interested in the rest of tags */
#ifndef DEBUG
            read4bytes(buf, len, err_code);
#else
            cp_buf->u.Integer.val = read4bytes(buf, len, err_code);
#endif
            break;
        case JVM_CONSTANT_Long:
        case JVM_CONSTANT_Double:
#ifndef DEBUG
            read4bytes(buf, len, err_code);
            if (*err_code) break;
            read4bytes(buf, len, err_code);
#else
            cp_buf->u.Long.hi = read4bytes(buf, len, err_code);
            if (*err_code) break;
            cp_buf->u.Long.lo = read4bytes(buf, len, err_code);
#endif
            break;
        case JVM_CONSTANT_String:
#ifndef DEBUG
            read2bytes(buf, len, err_code);
#else
            cp_buf->u.String.cp_index = read2bytes(buf, len, err_code);
#endif
            break;
        case JVM_CONSTANT_Fieldref:
#ifndef DEBUG
            read4bytes(buf, len, err_code);
#else
            cp_buf->u.Field.class_index = read2bytes(buf, len, err_code);
            if (*err_code) break;
            cp_buf->u.Field.name_and_type_index = read2bytes(buf, len, err_code);
#endif
            break;
        default:
            jcov_error("unrecognized constant pool entry encountered");
            *err_code = 1;
        }
    }
    if (*err_code) {
        jcov_free_cp_entry(cp_buf);
        cp_buf = NULL;
    }
    return cp_buf;
}

void jcov_free_cp_entry(cp_entry_t *cp_entry) {
    if (cp_entry != NULL) {
	if (cp_entry->tag == JVM_CONSTANT_Utf8) {
	    jcov_free(cp_entry->u.Utf8.bytes);
	}
        jcov_free(cp_entry);
    }
}

void jcov_free_constant_pool(cp_entry_t **cp, int cp_count) {
    int i;
    if (cp == NULL) return;
    for (i = 1; i < cp_count; i++) {
        jcov_free_cp_entry(cp[i]);
    }
    jcov_free(cp);
}

void jcov_free_method(jcov_method_t *meth) {
    if (meth == NULL) return;
    jcov_free(meth->name);
    jcov_free(meth->signature);
    jcov_free(meth->covtable);
    jcov_free(meth->pc_cache);
    jcov_free(meth);
}

void jcov_free_hooked_class(jcov_hooked_class_t *c) {
    int i;
    if (c == NULL)
        return;
    jcov_free(c->src_name);
    jcov_free(c->name);
    if (c->method_cache != NULL) {
        for (i = 0; i < c->methods_total; i++) {
            jcov_free_method(c->method_cache[i]);
        }
        jcov_free(c->method_cache);
    }
    jcov_free(c);
}


static void *f(void *c, void *arg) {
    jcov_free_hooked_class((jcov_hooked_class_t*)c);
    return NULL;
}

void jcov_conserve_thread(jcov_thread_t *thread) {
    void *dummy = NULL;
    jcov_hash_iterate(thread->hooked_class_table, f, dummy);
}

char *jcov_strdup(const char *str) {
    char *res = jcov_calloc(strlen(str)+1);
    strcpy(res, str);
    return res;
}

int get_instr_size(UINT16 pc, UINT8 *code) {
    UINT8 opcode = code[pc] & 0xFF;
    UINT16 cur_pc, instr_size;
    switch (opcode) {
    case opc_wide:
        return ((code[pc + 1] & 0xFF) == opc_iinc ? 6 : 4);
    case opc_lookupswitch:
        cur_pc = (pc + 4) & (~3);
        instr_size = cur_pc - pc /* padding bytes */ + 8 /* default offset and npairs */;
        cur_pc += 4;
        return INT32_AT(code, cur_pc) * 8 + instr_size;
    case opc_tableswitch:
        cur_pc = (pc + 4) & (~3);
        instr_size = cur_pc - pc /* padding bytes */ + 12 /* default offset, low and high */;
        cur_pc += 4;
        return (INT32_AT(code, cur_pc + 4) - INT32_AT(code, cur_pc) + 1) * 4 + instr_size;
    case opc_xxxunusedxxx:
        return 1;
    default:
        return opc_lengths[opcode];
    }
}

static int bit_flags[12];
static int lengths[12];
static char *string_flags[12];

void decode_modifiers(char *buf, int access_flags) {
    char *ptr = buf;
    int i = 0;
    for (i = 0; i < 12; i++) {
	if (access_flags & bit_flags[i]) {
	    memcpy(ptr, string_flags[i], lengths[i]);
	    ptr += lengths[i];
	    *ptr = ' ';
	    ptr++;
	}
    }
    if (ptr == buf) {
	ptr++;
    }
    *(ptr-1) = '\0';
}

char *dummy_src_name(char *class_name) {
    char *res;
    int len = strlen(class_name) + strlen(DUMMY_SRC_PREF) + strlen(DUMMY_SRC_SUFF) + 1;
    res = (char*)jcov_calloc(len);
    sprintf(res, "%s%s%s", DUMMY_SRC_PREF, class_name, DUMMY_SRC_SUFF);
    res[len - 1] = '\0';
    return res;
}

static int my_strcmp(const void *s1, const void *s2) {
	return strcmp(*(char**)s1, *(char**)s2);
}

static int starts_with(const void *str1, const void *str2) {
    return strncmp(*(char**)str1, *(char**)str2, strlen(*(char**)str2));
}

jcov_filter_t *jcov_filter_new() {
    jcov_filter_t *res = (jcov_filter_t*)jcov_calloc(sizeof(jcov_filter_t));
    res->incl = (char**)jcov_calloc(sizeof(char*) * MAX_FILTER_SIZE);
    res->excl = (char**)jcov_calloc(sizeof(char*) * MAX_FILTER_SIZE);
    return res;
}

void filter_add_incl(jcov_filter_t *filter, char *str) {
    if (filter->incl_size >= MAX_FILTER_SIZE)
        jcov_error_stop("too many filters");
    filter->incl[filter->incl_size++] = jcov_strdup(str);
}

void filter_add_excl(jcov_filter_t *filter, char *str) {
    if (filter->excl_size >= MAX_FILTER_SIZE)
        jcov_error_stop("too many filters");
    filter->excl[filter->excl_size++] = jcov_strdup(str);
}

void filter_finalize(jcov_filter_t *filter) {
    if (filter == NULL)
        return;
    qsort(filter->incl, filter->incl_size, sizeof(char*), my_strcmp);
    qsort(filter->excl, filter->excl_size, sizeof(char*), my_strcmp);
}

int string_suits_filter(jcov_filter_t *filter, char *str) {
    if (filter == NULL)
        return 1;
    if (bsearch(&str, filter->excl, filter->excl_size, sizeof(char*), starts_with) != NULL)
        return 0;
    if (filter->incl_size == 0)
        return 1;
    if (bsearch(&str, filter->incl, filter->incl_size, sizeof(char*), starts_with) != NULL)
        return 1;
    return 0;
}

void jcov_close(FILE **f) {
    if (*f == NULL)
        return;
    if (fclose(*f) != 0) {
        jcov_error("cannot close file");
    }
    *f = NULL;
}

void jcov_remove(const char *filename) {
    char buf[MAX_PATH_LEN];

    if (remove(filename) == -1) {
        sprintf(buf,"cannot remove file : %s\n", filename);
        jcov_error(buf);
    }
}

void free_list(jcov_list_t **l, void (*free_elem_f)(void *)) {
    jcov_list_t *list;
    if (l == NULL || *l == NULL)
        return;
    list = *l;
    while (list != NULL) {
        jcov_list_t *next = list->next;
        void *tmp = list->elem;
        list->elem = NULL;
        if (free_elem_f != NULL) {
            free_elem_f(tmp);
        }
        jcov_free(list);
        list = next;
    }
    *l = NULL;
}

void add_to_list(jcov_list_t **l, void *elem) {
    jcov_list_t *new_entry = (jcov_list_t*)jcov_calloc(sizeof(jcov_list_t));
    new_entry->elem = elem;
    new_entry->next = *l;
    *l = new_entry;
}

void add_to_list_end(jcov_list_t **l, void *elem) {
    jcov_list_t *cur = *l;
    jcov_list_t *new_entry = (jcov_list_t*)jcov_calloc(sizeof(jcov_list_t));
    new_entry->elem = elem;
    new_entry->next = NULL;
    if (cur == NULL) {
        *l = new_entry;
        return;
    }
    for (; cur->next != NULL; cur = cur->next);
    cur->next = new_entry;
}

int list_size(jcov_list_t *l) {
    int res = 0;
    for (; l != NULL; l = l->next, res++);
    return res;
}

void jcov_util_init(void) {
    int i;
    bit_flags[0] = JVM_ACC_PUBLIC;
    bit_flags[1] = JVM_ACC_PRIVATE;
    bit_flags[2] = JVM_ACC_PROTECTED;
    bit_flags[3] = JVM_ACC_STATIC;
    bit_flags[4] = JVM_ACC_FINAL;
    bit_flags[5] = JVM_ACC_SYNCHRONIZED;
    bit_flags[6] = JVM_ACC_VOLATILE;
    bit_flags[7] = JVM_ACC_TRANSIENT;
    bit_flags[8] = JVM_ACC_NATIVE;
    bit_flags[9] = JVM_ACC_INTERFACE;
    bit_flags[10] = JVM_ACC_ABSTRACT;
    bit_flags[11] = JVM_ACC_STRICT;
	
    string_flags[0] = "public";
    string_flags[1] = "private";
    string_flags[2] = "protected";
    string_flags[3] = "static";
    string_flags[4] = "final";
    string_flags[5] = "synchronized";
    string_flags[6] = "volatile";
    string_flags[7] = "transient";
    string_flags[8] = "native";
    string_flags[9] = "interface";
    string_flags[10] = "abstract";
    string_flags[11] = "strictfp";

    for (i = 0; i < 12; i++){
	lengths[i] = strlen(string_flags[i]);
    }

    DUMMY_SRC_PREF = "<UNKNOWN_SOURCE/";
    DUMMY_SRC_SUFF = ".java>";
}