From 8256816a5153b59ecb0523a9b468e7c6516cd06c Mon Sep 17 00:00:00 2001 From: Cristovam Date: Fri, 1 Aug 2014 14:41:51 -0300 Subject: [PATCH 1/5] Removed unnecessary code --- src/jamvm/jamvm-1.5.4/src/class.c | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/src/jamvm/jamvm-1.5.4/src/class.c b/src/jamvm/jamvm-1.5.4/src/class.c index fdb25214..ca7a938a 100644 --- a/src/jamvm/jamvm-1.5.4/src/class.c +++ b/src/jamvm/jamvm-1.5.4/src/class.c @@ -599,24 +599,6 @@ Class *defineClass(char *classname, char *data, int offset, int len, classblock->state = CLASS_LOADED; - //Copy classblock to our mmaped file - - if (IS_PERSISTENT && (!strcoll(classname,"HelloWorld"))){ - unsigned int cb_fd,dummy; - char* cbMap; - - cb_fd = open ("HW_CB", O_RDWR | O_CREAT , S_IRUSR | S_IWUSR); - lseek (cb_fd, sizeof(ClassBlock), SEEK_SET); - dummy = write(cb_fd,"",1); - - cbMap = (char*) mmap(NULL, sizeof(ClassBlock), PROT_READ|PROT_WRITE, - MAP_SHARED, cb_fd, 0); - - memcpy (cbMap, classblock, sizeof(ClassBlock)); - - msync (cbMap, sizeof(ClassBlock), MS_SYNC); - } - if((found = addClassToHash(class, class_loader)) != class) { classblock->flags = CLASS_CLASH; if(class_loader != NULL) { From b3264f7c852bf35ad7fc26457077e1bfe5f3ae01 Mon Sep 17 00:00:00 2001 From: Pedro Monteiro Date: Tue, 5 Aug 2014 09:55:20 -0300 Subject: [PATCH 2/5] Persisting the classes hash table --- src/jamvm/jamvm-1.5.4/src/class.c | 74 ++++++++++++++++++++++++++++--- 1 file changed, 69 insertions(+), 5 deletions(-) diff --git a/src/jamvm/jamvm-1.5.4/src/class.c b/src/jamvm/jamvm-1.5.4/src/class.c index ca7a938a..04e04bf1 100644 --- a/src/jamvm/jamvm-1.5.4/src/class.c +++ b/src/jamvm/jamvm-1.5.4/src/class.c @@ -118,11 +118,17 @@ static char *NH_filename = "HW_CLASSES"; static char *sep = "\n"; static int IS_PERSISTENT = 0; int class_to_save; +char *FILENAME_CLASSES = "classes.ht"; +int PERSISTENT_HEAP_CLASSES = FALSE; +int TESTING_MODE_CLASSES = FALSE; +FILE *hash_file_classes; +int FILE_EXISTS_CLASSES = FALSE; static Class *addClassToHash(Class *class, Object *class_loader) { HashTable *table; Class *entry; + int count_hash_entries= 0; //Testing variable #define HASH(ptr) utf8Hash(CLASS_CB((Class *)ptr)->name) #define COMPARE(ptr1, ptr2, hash1, hash2) (hash1 == hash2) && \ @@ -143,11 +149,51 @@ static Class *addClassToHash(Class *class, Object *class_loader) { objectUnlock(class_loader); return NULL; } - table = sysMalloc(sizeof(HashTable)); initHashTable((*table), CLASS_INITSZE, TRUE); + //NVM MODIFICATION + //Initializing table from file if it exists + if(IS_PERSISTENT){ + if(access (FILENAME_CLASSES, F_OK) != -1) { + FILE_EXISTS_CLASSES = TRUE; + } + if(FILE_EXISTS_CLASSES == TRUE) { + hash_file_classes = fopen (FILENAME_CLASSES, "rb"); + if(hash_file_classes == NULL) { + printf("ERROR: error trying to open classes hash table file\n"); + exit(EXIT_FAILURE); + } + size_t len = 0; + Class *interned = NULL; + Class *to_add = (Class*)malloc(sizeof(Class*)); + len = fread(&to_add, sizeof(Class*), 1, hash_file_classes); + while (len == 1) { + do { + addHashEntry((*table), to_add, interned); + interned = NULL; + findHashEntry((*table), to_add, interned, FALSE, FALSE, TRUE); + }while(interned == NULL); + count_hash_entries++; + len = fread(&to_add, sizeof(Class*), 1, hash_file_classes); + } + } + } + //END OF MODIFICATION + + //UNIT TESTS + if(TESTING_MODE_CLASSES) { + log_test_results("initaliseClasses_fileExists", FILE_EXISTS_CLASSES); + if(count_hash_entries == table->hash_count){ + log_test_results("initaliseClasses_recoverCLASSES", TRUE); + } else { + log_test_results("initaliseClasses_recoverCLASSES", FALSE); + } + } + + + INST_DATA(vmdata, HashTable*, ldr_data_tbl_offset) = table; INST_DATA(class_loader, Object*, ldr_vmdata_offset) = vmdata; @@ -158,6 +204,22 @@ static Class *addClassToHash(Class *class, Object *class_loader) { table = INST_DATA(vmdata, HashTable*, ldr_data_tbl_offset); } + //NVM MODIFICATION + //Adding entry to file if needed + if(IS_PERSISTENT){ + if(class_loader != NULL){ + entry = NULL; + findOnlyHashEntry((*table), class, entry, TRUE); + if(entry == NULL){ + hash_file_classes = fopen (FILENAME_CLASSES, "a+b"); + fwrite(&class, sizeof(Class*), 1, hash_file_classes); + fclose(hash_file_classes); + } + } + } + //END OF MODIFICATION + + /* Add if absent, no scavenge, locked */ findHashEntry((*table), class, entry, TRUE, FALSE, TRUE); msync(table, HASHFILESIZE, MS_SYNC); @@ -1661,9 +1723,10 @@ Class *findClassFromClassLoader_persistent(char *classname, Object *loader) { } Class *findClassFromClassLoader(char *classname, Object *loader) { - if (IS_PERSISTENT) + //XXX uncomment for different approach + /*if (IS_PERSISTENT) return findClassFromClassLoader_persistent(classname, loader); - else{ + else{*/ if(*classname == '[') return findArrayClassFromClassLoader(classname, loader); @@ -1672,7 +1735,7 @@ Class *findClassFromClassLoader(char *classname, Object *loader) { return findNonArrayClassFromClassLoader(classname, loader); return findSystemClass0(classname); - } + //} } Object *getSystemClassLoader() { @@ -2133,7 +2196,8 @@ void initialiseClass(InitArgs *args) { Class *vm_loader_class; if(args->persistent_heap == TRUE){ - IS_PERSISTENT = 1; + IS_PERSISTENT = TRUE; + TESTING_MODE_CLASSES = TRUE; } if(!(bcp && parseBootClassPath(bcp))) { From a75fd1f7d71a5b889acc621ae1479f3821a298c4 Mon Sep 17 00:00:00 2001 From: Pedro Monteiro Date: Wed, 6 Aug 2014 16:02:26 -0300 Subject: [PATCH 3/5] Saving classes hash table context and reinitializing it when trying to find first class with a classloader --- src/jamvm/jamvm-1.5.4/src/class.c | 229 +++++++++++++++++++++--------- src/jamvm/jamvm-1.5.4/src/utf8.c | 26 ++-- 2 files changed, 175 insertions(+), 80 deletions(-) diff --git a/src/jamvm/jamvm-1.5.4/src/class.c b/src/jamvm/jamvm-1.5.4/src/class.c index 04e04bf1..4f0e7472 100644 --- a/src/jamvm/jamvm-1.5.4/src/class.c +++ b/src/jamvm/jamvm-1.5.4/src/class.c @@ -114,25 +114,27 @@ static Class *prim_classes[MAX_PRIM_CLASSES]; static char abstract_method[] = {OPC_ABSTRACT_METHOD_ERROR}; //My variables -static char *NH_filename = "HW_CLASSES"; -static char *sep = "\n"; -static int IS_PERSISTENT = 0; +static char *NH_FILENAME = "HW_CLASSES"; +static char *SEP = "\n"; +static int is_persistent_classes = FALSE; int class_to_save; -char *FILENAME_CLASSES = "classes.ht"; -int PERSISTENT_HEAP_CLASSES = FALSE; -int TESTING_MODE_CLASSES = FALSE; +char *FILENAME_CLASSES_HT = "classes.ht"; +char *FILENAME_CLASSES_NAMES = "classes.cn"; +int testing_mode_classes = FALSE; FILE *hash_file_classes; -int FILE_EXISTS_CLASSES = FALSE; +FILE *name_file_classes; +int pointer_file_exists_classes = FALSE; +int name_file_exists_classes = FALSE; +int classes_ht_initialized = FALSE; + static Class *addClassToHash(Class *class, Object *class_loader) { HashTable *table; Class *entry; - int count_hash_entries= 0; //Testing variable #define HASH(ptr) utf8Hash(CLASS_CB((Class *)ptr)->name) -#define COMPARE(ptr1, ptr2, hash1, hash2) (hash1 == hash2) && \ - CLASS_CB((Class *)ptr1)->name == CLASS_CB((Class *)ptr2)->name +#define COMPARE(ptr1, ptr2, hash1, hash2) (hash1 == hash2) if(class_loader == NULL) { table = &boot_classes; @@ -153,47 +155,6 @@ static Class *addClassToHash(Class *class, Object *class_loader) { initHashTable((*table), CLASS_INITSZE, TRUE); - //NVM MODIFICATION - //Initializing table from file if it exists - if(IS_PERSISTENT){ - if(access (FILENAME_CLASSES, F_OK) != -1) { - FILE_EXISTS_CLASSES = TRUE; - } - if(FILE_EXISTS_CLASSES == TRUE) { - hash_file_classes = fopen (FILENAME_CLASSES, "rb"); - if(hash_file_classes == NULL) { - printf("ERROR: error trying to open classes hash table file\n"); - exit(EXIT_FAILURE); - } - size_t len = 0; - Class *interned = NULL; - Class *to_add = (Class*)malloc(sizeof(Class*)); - len = fread(&to_add, sizeof(Class*), 1, hash_file_classes); - while (len == 1) { - do { - addHashEntry((*table), to_add, interned); - interned = NULL; - findHashEntry((*table), to_add, interned, FALSE, FALSE, TRUE); - }while(interned == NULL); - count_hash_entries++; - len = fread(&to_add, sizeof(Class*), 1, hash_file_classes); - } - } - } - //END OF MODIFICATION - - //UNIT TESTS - if(TESTING_MODE_CLASSES) { - log_test_results("initaliseClasses_fileExists", FILE_EXISTS_CLASSES); - if(count_hash_entries == table->hash_count){ - log_test_results("initaliseClasses_recoverCLASSES", TRUE); - } else { - log_test_results("initaliseClasses_recoverCLASSES", FALSE); - } - } - - - INST_DATA(vmdata, HashTable*, ldr_data_tbl_offset) = table; INST_DATA(class_loader, Object*, ldr_vmdata_offset) = vmdata; @@ -206,14 +167,20 @@ static Class *addClassToHash(Class *class, Object *class_loader) { //NVM MODIFICATION //Adding entry to file if needed - if(IS_PERSISTENT){ + if(is_persistent_classes){ if(class_loader != NULL){ entry = NULL; findOnlyHashEntry((*table), class, entry, TRUE); if(entry == NULL){ - hash_file_classes = fopen (FILENAME_CLASSES, "a+b"); + hash_file_classes = fopen (FILENAME_CLASSES_HT, "a+b"); + name_file_classes = fopen (FILENAME_CLASSES_NAMES, "a+b"); + unsigned short string_lenght = strlen(CLASS_CB((Class*)class)->name) + 1; + fwrite(&string_lenght, sizeof(unsigned short), 1, name_file_classes); + fwrite(CLASS_CB((Class*)class)->name, sizeof(char), string_lenght, name_file_classes); fwrite(&class, sizeof(Class*), 1, hash_file_classes); fclose(hash_file_classes); + fclose(name_file_classes); + classes_ht_initialized = TRUE; } } } @@ -1483,6 +1450,132 @@ void addInitiatingLoaderToClass(Object *class_loader, Class *class) { addClassToHash(class, class_loader); } +//NVM method to initialize the classes hash table +void initializeClassesHT(Object *class_loader){ + +#undef COMPARE + +#define COMPARE(ptr1, ptr2, hash1, hash2) (hash1 == hash2) + + int count_hash_entries = 0; //Testing variable + int count_name_entries = 0; //Testing variable + + Object *vmdata = allocObject(ldr_new_unloader->class); + HashTable *table = sysMalloc(sizeof(HashTable)); + initHashTable((*table), CLASS_INITSZE, TRUE); + + INST_DATA(vmdata, HashTable*, ldr_data_tbl_offset) = table; + INST_DATA(class_loader, Object*, ldr_vmdata_offset) = vmdata; + + if(access (FILENAME_CLASSES_HT, F_OK) != -1) { + pointer_file_exists_classes = TRUE; + } + if(access (FILENAME_CLASSES_NAMES, F_OK) != -1) { + name_file_exists_classes = TRUE; + } + if((pointer_file_exists_classes == TRUE) && (name_file_exists_classes == TRUE)) { + hash_file_classes = fopen (FILENAME_CLASSES_HT, "rb"); + name_file_classes = fopen (FILENAME_CLASSES_NAMES, "rb"); + if((hash_file_classes == NULL) || (name_file_classes == NULL)) { + printf("ERROR: error trying to open classes hash table context files\n"); + exit(EXIT_FAILURE); + } + size_t len_pointer = 0; + size_t len_string = 0; + Class *interned = NULL; + Class *to_add = (Class*)malloc(sizeof(Class*)); + len_pointer = fread(&to_add, sizeof(Class*), 1, hash_file_classes); + while (len_pointer == 1) { + do { + + unsigned short string_length = 0; + len_string = fread(&string_length, sizeof(unsigned short), 1, name_file_classes); + + char *class_name = (char*)malloc(string_length * sizeof(char)); + int count = fread(class_name, sizeof(char), string_length, name_file_classes); + + if(count == string_length){ + count_name_entries++; + } + else{ + printf("ERROR: error trying to read class name from classname file\n"); + exit(EXIT_FAILURE); + } + + //addHashEntry() adapted + int hash = utf8Hash(class_name); + int i; + + Thread *self; + self = threadSelf(); + lockHashTable0(&(*table), self); + + i = hash & ((*table).hash_size - 1); + + for(;;) { + interned = (*table).hash_table[i].data; + if((interned == NULL) || (COMPARE(to_add, interned, hash, (*table).hash_table[i].hash))) + break; + + i = (i+1) & ((*table).hash_size - 1); + } + (*table).hash_table[i].hash = hash; + interned = (*table).hash_table[i].data = PREPARE(to_add); + (*table).hash_count++; + + if(((*table).hash_count * 4) > ((*table).hash_size * 3)) { + resizeHash(&(*table), (*table).hash_size * 2); + } + + unlockHashTable0(&(*table), self); + //End of addHashEntry() + + interned = NULL; + + //findOnlyHashEntry() adapted + hash = utf8Hash(class_name); + + self = threadSelf(); + lockHashTable0(&(*table), self); + + i = hash & ((*table).hash_size - 1); + + for(;;) { + interned = (*table).hash_table[i].data; + if((interned == NULL) || (COMPARE(to_add, interned, hash, (*table).hash_table[i].hash))) + break; + + i = (i+1) & ((*table).hash_size - 1); + } + + unlockHashTable0(&(*table), self); + //End of finfOnlyHashEntry() + + }while(interned == NULL); + count_hash_entries++; + len_pointer = fread(&to_add, sizeof(Class*), 1, hash_file_classes); + } + fclose(hash_file_classes); + fclose(name_file_classes); + } + //UNIT TESTS + if(testing_mode_classes) { + log_test_results("initaliseClasses_fileExists", pointer_file_exists_classes && name_file_exists_classes); + if(count_hash_entries == table->hash_count){ + log_test_results("initaliseClasses_recoverClassesPOINTERS", TRUE); + } else { + log_test_results("initaliseClasses_recoverClassesPOINTERS", FALSE); + } + if(count_name_entries == count_hash_entries){ + log_test_results("initaliseClasses_recoverClassesNAMES", TRUE); + } else { + log_test_results("initaliseClasses_recoverClassesNAMES", FALSE); + } + } + +} + + Class *findHashedClass(char *classname, Object *class_loader) { HashTable *table; Class *class; @@ -1500,7 +1593,15 @@ Class *findHashedClass(char *classname, Object *class_loader) { table = &boot_classes; } else { - Object *vmdata = INST_DATA(class_loader, Object*, ldr_vmdata_offset); + if(is_persistent_classes){ + if(classes_ht_initialized == FALSE){ + initializeClassesHT(class_loader); + classes_ht_initialized = TRUE; + } + } + Object *vmdata = INST_DATA(class_loader, Object*, ldr_vmdata_offset); + + if(vmdata == NULL) { return NULL; @@ -1652,7 +1753,7 @@ Class *findNonArrayClassFromClassLoader(char *classname, Object *loader) { Class* findInFile (char* name_to_find){ Class *class; - FILE *file = fopen (NH_filename, "rt"); + FILE *file = fopen (NH_FILENAME, "rt"); char *line = NULL; size_t len = 0; size_t read = 0; @@ -1699,7 +1800,7 @@ Class *findClassFromClassLoader_persistent(char *classname, Object *loader) { return findArrayClassFromClassLoader(classname, loader); if(loader != NULL){ - if(access (NH_filename, F_OK) != -1){ + if(access (NH_FILENAME, F_OK) != -1){ class = findInFile(classname); if (class != NULL){ return class; @@ -1708,12 +1809,12 @@ Class *findClassFromClassLoader_persistent(char *classname, Object *loader) { class = findNonArrayClassFromClassLoader(classname, loader); FILE * nonHashedFile; - nonHashedFile = fopen (NH_filename, "a+"); + nonHashedFile = fopen (NH_FILENAME, "a+"); - fprintf(nonHashedFile, "%s%s", classname, sep); - fprintf(nonHashedFile, "%p%s", class, sep); - fprintf(nonHashedFile, "%u%s", class->lock, sep); - fprintf(nonHashedFile, "%p%s", class->class, sep); + fprintf(nonHashedFile, "%s%s", classname, SEP); + fprintf(nonHashedFile, "%p%s", class, SEP); + fprintf(nonHashedFile, "%u%s", class->lock, SEP); + fprintf(nonHashedFile, "%p%s", class->class, SEP); fclose(nonHashedFile); return class; @@ -1724,7 +1825,7 @@ Class *findClassFromClassLoader_persistent(char *classname, Object *loader) { Class *findClassFromClassLoader(char *classname, Object *loader) { //XXX uncomment for different approach - /*if (IS_PERSISTENT) + /*if (is_persistent_classes) return findClassFromClassLoader_persistent(classname, loader); else{*/ @@ -2196,8 +2297,8 @@ void initialiseClass(InitArgs *args) { Class *vm_loader_class; if(args->persistent_heap == TRUE){ - IS_PERSISTENT = TRUE; - TESTING_MODE_CLASSES = TRUE; + is_persistent_classes = TRUE; + testing_mode_classes = TRUE; } if(!(bcp && parseBootClassPath(bcp))) { diff --git a/src/jamvm/jamvm-1.5.4/src/utf8.c b/src/jamvm/jamvm-1.5.4/src/utf8.c index dd4a2ad6..062e4eaf 100644 --- a/src/jamvm/jamvm-1.5.4/src/utf8.c +++ b/src/jamvm/jamvm-1.5.4/src/utf8.c @@ -38,11 +38,10 @@ HashTable *hash_table; char *FILENAME_UTF8 = "utf8.ht"; char *SEP_UTF8 = "\n"; -int PERSISTENT_HEAP_UTF8 = FALSE; -int TESTING_MODE_UTF8 = FALSE; +int persistent_heap_utf8 = FALSE; +int testing_mode_utf8 = FALSE; FILE *hash_file_utf8; -int FILE_EXISTS_UTF8 = FALSE; -int ifa = 0; +int file_exists_utf8 = FALSE; #define GET_UTF8_CHAR(ptr, c) \ @@ -118,7 +117,6 @@ char *findHashedUtf8Persintent(char *string, int add_if_absent, int class_to_sav if(add_if_absent){ fwrite(&string_lenght, sizeof(unsigned short), 1, hash_file_utf8); fwrite(string, sizeof(char), string_lenght, hash_file_utf8); - ifa++; } } return interned; @@ -127,7 +125,7 @@ char *findHashedUtf8Persintent(char *string, int add_if_absent, int class_to_sav char *findHashedUtf8(char *string, int add_if_absent, int class_to_save) { char *interned = NULL; - if(PERSISTENT_HEAP_UTF8 == TRUE){ + if(persistent_heap_utf8 == TRUE){ interned = findHashedUtf8Persintent(string, add_if_absent, class_to_save); } else{ @@ -179,18 +177,17 @@ void initialiseUtf8Persistent(){ int countHashEntries = 0; if(access (FILENAME_UTF8, F_OK) != -1) { - FILE_EXISTS_UTF8 = TRUE; + file_exists_utf8 = TRUE; } // Adding entries to hash table since file exists - if(FILE_EXISTS_UTF8 == TRUE) { + if(file_exists_utf8 == TRUE) { hash_file_utf8 = fopen (FILENAME_UTF8, "rb"); if(hash_file_utf8 == NULL) { exit(EXIT_FAILURE); } - char *line = NULL; size_t len = 0; @@ -212,15 +209,12 @@ void initialiseUtf8Persistent(){ } - if(line){ - free(line); - } fclose(hash_file_utf8); } hash_file_utf8 = fopen (FILENAME_UTF8, "a+b"); // Unit tests - if(TESTING_MODE_UTF8) { - log_test_results("initaliseUTF8_fileExists", FILE_EXISTS_UTF8); + if(testing_mode_utf8) { + log_test_results("initaliseUTF8_fileExists", file_exists_utf8); if(countHashEntries == hash_table->hash_count){ log_test_results("initaliseUTF8_recoverUTF8", TRUE); } else { @@ -236,8 +230,8 @@ void initialiseUtf8(InitArgs *args) { initHashTable((*hash_table), HASHTABSZE, TRUE); if(args->persistent_heap){ - PERSISTENT_HEAP_UTF8 = args->persistent_heap; - TESTING_MODE_UTF8 = args->testing_mode; + persistent_heap_utf8 = args->persistent_heap; + testing_mode_utf8 = args->testing_mode; initialiseUtf8Persistent(); } From f48317e8aa39bf13b8dbbbb3ed7e91c6a7b5a81a Mon Sep 17 00:00:00 2001 From: Pedro Monteiro Date: Mon, 11 Aug 2014 13:43:44 -0300 Subject: [PATCH 4/5] Added searchClass function to search classes on classes hash table before definition to avoid redefinition --- src/jamvm/jamvm-1.5.4/src/class.c | 182 ++++++++++++++++++++++++++++-- 1 file changed, 174 insertions(+), 8 deletions(-) diff --git a/src/jamvm/jamvm-1.5.4/src/class.c b/src/jamvm/jamvm-1.5.4/src/class.c index 4f0e7472..1ddc0a6d 100644 --- a/src/jamvm/jamvm-1.5.4/src/class.c +++ b/src/jamvm/jamvm-1.5.4/src/class.c @@ -210,16 +210,178 @@ static void prepareClass(Class *class) { class->class = java_lang_Class; } } +//NVM method to check if a class is already on the hash table +Class *searchClass(char *classname, char *data, int offset, int len, Object *class_loader){ + Object *vmdata = INST_DATA(class_loader, Object*, ldr_vmdata_offset); + if(vmdata == NULL){ + return NULL; + } + u2 major_version, minor_version, this_idx, super_idx; + unsigned char *ptr = (unsigned char *)data + offset; + int cp_count, intf_count, i; + u2 attr_count; + u4 magic; + + ConstantPool *constant_pool; + ClassBlock *classblock; + Class *class, *found; + Class **interfaces; + + READ_U4(magic, ptr, len); + + if(magic != 0xcafebabe) { + signalException(java_lang_ClassFormatError, "bad magic"); + return NULL; + } + + READ_U2(minor_version, ptr, len); + READ_U2(major_version, ptr, len); + + + if((class = allocClass()) == NULL) + return NULL; + + classblock = CLASS_CB(class); + READ_U2(cp_count, ptr, len); + + + + constant_pool = &classblock->constant_pool; + constant_pool->type = sysMalloc(cp_count); + constant_pool->info = sysMalloc(cp_count*sizeof(ConstantPoolEntry)); + + + + for(i = 1; i < cp_count; i++) { + u1 tag; + + READ_U1(tag, ptr, len); + CP_TYPE(constant_pool,i) = tag; + + switch(tag) { + case CONSTANT_Class: + case CONSTANT_String: + READ_INDEX(CP_INFO(constant_pool,i), ptr, len); + break; + + case CONSTANT_Fieldref: + case CONSTANT_Methodref: + case CONSTANT_NameAndType: + case CONSTANT_InterfaceMethodref: + { + u2 idx1, idx2; + + READ_INDEX(idx1, ptr, len); + READ_INDEX(idx2, ptr, len); + CP_INFO(constant_pool,i) = (idx2<<16)+idx1; + break; + } + + case CONSTANT_Float: + case CONSTANT_Integer: + READ_U4(CP_INFO(constant_pool,i), ptr, len); + break; + + case CONSTANT_Long: + READ_U8(*(u8 *)&(CP_INFO(constant_pool,i)), ptr, len); + CP_TYPE(constant_pool,++i) = 0; + break; + + case CONSTANT_Double: + READ_DBL(*(u8 *)&(CP_INFO(constant_pool,i)), ptr, len); + CP_TYPE(constant_pool,++i) = 0; + break; + + case CONSTANT_Utf8: + { + int length; + char *buff, *utf8; + + READ_U2(length, ptr, len); + buff = sysMalloc(length+1); + + memcpy(buff, ptr, length); + buff[length] = '\0'; + ptr += length; + + //Changed this part to save utf8 entries of classes with classloaders + if(class_to_save){ + CP_INFO(constant_pool,i) = (uintptr_t) (utf8 = newUtf8Save(buff)); + } + else{ + CP_INFO(constant_pool,i) = (uintptr_t) (utf8 = newUtf8(buff)); + } + + if(utf8 != buff) + sysFree(buff); + + break; + } + + default: + signalException(java_lang_ClassFormatError, + "bad constant pool tag"); + return NULL; + } + } + + + /* Set count after constant pool has been initialised -- it is now + safe to be scanned by GC */ + classblock->constant_pool_count = cp_count; + + READ_U2(classblock->access_flags, ptr, len); + + READ_TYPE_INDEX(this_idx, constant_pool, CONSTANT_Class, ptr, len); + classblock->name = CP_UTF8(constant_pool, CP_CLASS(constant_pool, this_idx)); + + // Search class on classes hash table + HashTable *classes_table = INST_DATA(vmdata, HashTable*, ldr_data_tbl_offset); + Class *result = NULL; + findHashEntry((*classes_table), class, result, FALSE, FALSE, TRUE); + + // Unit tests + if(testing_mode_classes) { + FILE *test_output = fopen("testsoutput.txt", "a+"); + fprintf(test_output, (const char*)classname); + fprintf(test_output, "\n"); + if(result == NULL){ + log_test_results("searchClass_foundClass", FALSE); + } + else{ + log_test_results("searchClass_foundClass", TRUE); + } + fclose(test_output); + } + return result; + +} Class *defineClass(char *classname, char *data, int offset, int len, Object *class_loader) { - if(class_loader != NULL){ - class_to_save = TRUE; - } - else{ - class_to_save = FALSE; + + int reload = FALSE; + Class *result = NULL; + + if(is_persistent_classes){ + if(class_loader != NULL){ + class_to_save = TRUE; + result = searchClass(classname, data, offset, len, class_loader); + if(result == NULL){ + reload = FALSE; + } + else{ + reload = TRUE; + } + } + else{ + class_to_save = FALSE; + reload = FALSE; + } } + + u2 major_version, minor_version, this_idx, super_idx; unsigned char *ptr = (unsigned char *)data + offset; int cp_count, intf_count, i; @@ -241,9 +403,13 @@ Class *defineClass(char *classname, char *data, int offset, int len, READ_U2(minor_version, ptr, len); READ_U2(major_version, ptr, len); - - if((class = allocClass()) == NULL) - return NULL; + if(reload == TRUE){ + class = result; + } + else{ + if((class = allocClass()) == NULL) + return NULL; + } classblock = CLASS_CB(class); READ_U2(cp_count, ptr, len); From ded1d9d99c22380a4a8d5a7e0cc9815d297daebb Mon Sep 17 00:00:00 2001 From: Pedro Monteiro Date: Thu, 14 Aug 2014 03:40:42 -0300 Subject: [PATCH 5/5] Fixed our java test code --- src/jamvm/jamvm-1.5.4/HelloWorld.class | Bin 718 -> 664 bytes src/jamvm/jamvm-1.5.4/src/HelloWorld.class | Bin 718 -> 664 bytes src/jamvm/jamvm-1.5.4/src/HelloWorld.java | 2 +- 3 files changed, 1 insertion(+), 1 deletion(-) diff --git a/src/jamvm/jamvm-1.5.4/HelloWorld.class b/src/jamvm/jamvm-1.5.4/HelloWorld.class index 6ce682bd7a1c147add747947159c7a55ec3952d3..674e0da97755e4801997678316b4ad223d2f748c 100644 GIT binary patch delta 131 zcmWlSJr==07yxJEt+nf;lMwM2k@#2Wa}39EhkY8IL+BKG3PZ-^UX; za&QQVrO&{SIvOM`hQXPo%_!73VB(lEGvtQ3uTTC~Gz(!t>0fzTu@pLVg^HE1W@Fe2 UJN9?2Vx^)>7M-o4_kTvjKezu71poj5 delta 183 zcmW-bOAf(M07XyRw6Cp4kfZ-^UX; za&QQVrO&{SIvOM`hQXPo%_!73VB(lEGvtQ3uTTC~Gz(!t>0fzTu@pLVg^HE1W@Fe2 UJN9?2Vx^)>7M-o4_kTvjKezu71poj5 delta 183 zcmW-bOAf(M07XyRw6Cp4kf