xeye_ atsu
JVM test
Embed:
(wiki syntax)
Show/hide line numbers
ravem.cpp
00001 /* 00002 * RAVEM.c 00003 * 00004 * Created on: return 2013/07/18 00005 * Author: return lynxeyed 00006 */ 00007 #include <stdio.h> 00008 #include <string.h> 00009 #include "ravem.h" 00010 00011 00012 00013 /* 00014 const unsigned char vm_array[] = { 00015 0xCA, 0xFE, 0xBA, 0xBE, 0x00, 0x00, 0x00, 0x32, 0x00, 0x35, 0x0A, 0x00, 0x0F, 00016 0x00, 0x1B, 0x09, 0x00, 0x1C, 0x00, 0x1D, 0x08, 0x00, 0x1E, 0x0A, 0x00, 0x1F, 0x00, 0x20, 0x0A, 00017 0x00, 0x0B, 0x00, 0x21, 0x0A, 0x00, 0x1F, 0x00, 0x22, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 00018 0x03, 0xE8, 0x0A, 0x00, 0x0B, 0x00, 0x23, 0x07, 0x00, 0x24, 0x07, 0x00, 0x25, 0x0A, 0x00, 0x0B, 00019 0x00, 0x1B, 0x0A, 0x00, 0x0B, 0x00, 0x26, 0x08, 0x00, 0x27, 0x07, 0x00, 0x28, 0x01, 0x00, 0x06, 00020 0x3C, 0x69, 0x6E, 0x69, 0x74, 0x3E, 0x01, 0x00, 0x03, 0x28, 0x29, 0x56, 0x01, 0x00, 0x04, 0x43, 00021 0x6F, 0x64, 0x65, 0x01, 0x00, 0x0F, 0x4C, 0x69, 0x6E, 0x65, 0x4E, 0x75, 0x6D, 0x62, 0x65, 0x72, 00022 0x54, 0x61, 0x62, 0x6C, 0x65, 0x01, 0x00, 0x03, 0x72, 0x75, 0x6E, 0x01, 0x00, 0x0D, 0x53, 0x74, 00023 0x61, 0x63, 0x6B, 0x4D, 0x61, 0x70, 0x54, 0x61, 0x62, 0x6C, 0x65, 0x07, 0x00, 0x24, 0x01, 0x00, 00024 0x04, 0x6D, 0x61, 0x69, 0x6E, 0x01, 0x00, 0x16, 0x28, 0x5B, 0x4C, 0x6A, 0x61, 0x76, 0x61, 0x2F, 00025 0x6C, 0x61, 0x6E, 0x67, 0x2F, 0x53, 0x74, 0x72, 0x69, 0x6E, 0x67, 0x3B, 0x29, 0x56, 0x01, 0x00, 00026 0x0A, 0x53, 0x6F, 0x75, 0x72, 0x63, 0x65, 0x46, 0x69, 0x6C, 0x65, 0x01, 0x00, 0x0A, 0x68, 0x6F, 00027 0x67, 0x65, 0x31, 0x2E, 0x6A, 0x61, 0x76, 0x61, 0x0C, 0x00, 0x10, 0x00, 0x11, 0x07, 0x00, 0x29, 00028 0x0C, 0x00, 0x2A, 0x00, 0x2B, 0x01, 0x00, 0x0E, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x20, 0x4E, 00029 0x75, 0x6D, 0x62, 0x65, 0x72, 0x3D, 0x07, 0x00, 0x2C, 0x0C, 0x00, 0x2D, 0x00, 0x2E, 0x0C, 0x00, 00030 0x2F, 0x00, 0x30, 0x0C, 0x00, 0x31, 0x00, 0x2E, 0x0C, 0x00, 0x32, 0x00, 0x33, 0x01, 0x00, 0x1E, 00031 0x6A, 0x61, 0x76, 0x61, 0x2F, 0x6C, 0x61, 0x6E, 0x67, 0x2F, 0x49, 0x6E, 0x74, 0x65, 0x72, 0x72, 00032 0x75, 0x70, 0x74, 0x65, 0x64, 0x45, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6F, 0x6E, 0x01, 0x00, 00033 0x05, 0x68, 0x6F, 0x67, 0x65, 0x31, 0x0C, 0x00, 0x34, 0x00, 0x11, 0x01, 0x00, 0x0B, 0x54, 0x68, 00034 0x72, 0x65, 0x61, 0x64, 0x20, 0x74, 0x65, 0x73, 0x74, 0x01, 0x00, 0x10, 0x6A, 0x61, 0x76, 0x61, 00035 0x2F, 0x6C, 0x61, 0x6E, 0x67, 0x2F, 0x54, 0x68, 0x72, 0x65, 0x61, 0x64, 0x01, 0x00, 0x10, 0x6A, 00036 0x61, 0x76, 0x61, 0x2F, 0x6C, 0x61, 0x6E, 0x67, 0x2F, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x01, 00037 0x00, 0x03, 0x6F, 0x75, 0x74, 0x01, 0x00, 0x15, 0x4C, 0x6A, 0x61, 0x76, 0x61, 0x2F, 0x69, 0x6F, 00038 0x2F, 0x50, 0x72, 0x69, 0x6E, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6D, 0x3B, 0x01, 0x00, 0x13, 00039 0x6A, 0x61, 0x76, 0x61, 0x2F, 0x69, 0x6F, 0x2F, 0x50, 0x72, 0x69, 0x6E, 0x74, 0x53, 0x74, 0x72, 00040 0x65, 0x61, 0x6D, 0x01, 0x00, 0x05, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x01, 0x00, 0x15, 0x28, 0x4C, 00041 0x6A, 0x61, 0x76, 0x61, 0x2F, 0x6C, 0x61, 0x6E, 0x67, 0x2F, 0x53, 0x74, 0x72, 0x69, 0x6E, 0x67, 00042 0x3B, 0x29, 0x56, 0x01, 0x00, 0x07, 0x67, 0x65, 0x74, 0x4E, 0x61, 0x6D, 0x65, 0x01, 0x00, 0x14, 00043 0x28, 0x29, 0x4C, 0x6A, 0x61, 0x76, 0x61, 0x2F, 0x6C, 0x61, 0x6E, 0x67, 0x2F, 0x53, 0x74, 0x72, 00044 0x69, 0x6E, 0x67, 0x3B, 0x01, 0x00, 0x07, 0x70, 0x72, 0x69, 0x6E, 0x74, 0x6C, 0x6E, 0x01, 0x00, 00045 0x05, 0x73, 0x6C, 0x65, 0x65, 0x70, 0x01, 0x00, 0x04, 0x28, 0x4A, 0x29, 0x56, 0x01, 0x00, 0x05, 00046 0x73, 0x74, 0x61, 0x72, 0x74, 0x00, 0x20, 0x00, 0x0B, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 00047 0x03, 0x00, 0x00, 0x00, 0x10, 0x00, 0x11, 0x00, 0x01, 0x00, 0x12, 0x00, 0x00, 0x00, 0x1D, 0x00, 00048 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x05, 0x2A, 0xB7, 0x00, 0x01, 0xB1, 0x00, 0x00, 0x00, 0x01, 00049 0x00, 0x13, 0x00, 0x00, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x14, 00050 0x00, 0x11, 0x00, 0x01, 0x00, 0x12, 0x00, 0x00, 0x00, 0x60, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 00051 0x00, 0x1F, 0xB2, 0x00, 0x02, 0x12, 0x03, 0xB6, 0x00, 0x04, 0xB2, 0x00, 0x02, 0x2A, 0xB6, 0x00, 00052 0x05, 0xB6, 0x00, 0x06, 0x14, 0x00, 0x07, 0xB8, 0x00, 0x09, 0xA7, 0xFF, 0xE8, 0x4C, 0xA7, 0xFF, 00053 0xE4, 0x00, 0x01, 0x00, 0x12, 0x00, 0x18, 0x00, 0x1B, 0x00, 0x0A, 0x00, 0x02, 0x00, 0x13, 0x00, 00054 0x00, 0x00, 0x1A, 0x00, 0x06, 0x00, 0x00, 0x00, 0x05, 0x00, 0x08, 0x00, 0x06, 0x00, 0x12, 0x00, 00055 0x08, 0x00, 0x18, 0x00, 0x0A, 0x00, 0x1B, 0x00, 0x09, 0x00, 0x1C, 0x00, 0x0A, 0x00, 0x15, 0x00, 00056 0x00, 0x00, 0x07, 0x00, 0x02, 0x00, 0x5A, 0x07, 0x00, 0x16, 0x00, 0x09, 0x00, 0x17, 0x00, 0x18, 00057 0x00, 0x01, 0x00, 0x12, 0x00, 0x00, 0x00, 0x4D, 0x00, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x21, 00058 0xBB, 0x00, 0x0B, 0x59, 0xB7, 0x00, 0x0C, 0x4C, 0xBB, 0x00, 0x0B, 0x59, 0xB7, 0x00, 0x0C, 0x4D, 00059 0x2B, 0xB6, 0x00, 0x0D, 0x2C, 0xB6, 0x00, 0x0D, 0xB2, 0x00, 0x02, 0x12, 0x0E, 0xB6, 0x00, 0x06, 00060 0xB1, 0x00, 0x00, 0x00, 0x01, 0x00, 0x13, 0x00, 0x00, 0x00, 0x1A, 0x00, 0x06, 0x00, 0x00, 0x00, 00061 0x11, 0x00, 0x08, 0x00, 0x12, 0x00, 0x10, 0x00, 0x14, 0x00, 0x14, 0x00, 0x15, 0x00, 0x18, 0x00, 00062 0x17, 0x00, 0x20, 0x00, 0x18, 0x00, 0x01, 0x00, 0x19, 0x00, 0x00, 0x00, 0x02, 0x00, 0x1A, 0x00, 00063 0x00, 0x00 00064 }; 00065 */ 00066 char cp_str[32]; 00067 int32_t total_const_pool_num; 00068 int32_t methods_count; 00069 00070 void bc_init(void){ 00071 bytecode_read_init(); 00072 } 00073 char *bc_seek(int bc_num, int length){ 00074 00075 return bytecode_read(bc_num, length); 00076 } 00077 00078 int32_t getLengthOfConstantInfo(uint8_t constantType) 00079 { 00080 switch (constantType) { 00081 00082 case CONSTANT_Class: 00083 case CONSTANT_String: 00084 case CONSTANT_MethodType: 00085 case CONSTANT_InvokeDynamic: 00086 return 3; 00087 00088 case CONSTANT_Fieldref: 00089 case CONSTANT_Methodref: 00090 case CONSTANT_InterfaceMethodref: 00091 case CONSTANT_Integer: 00092 case CONSTANT_Float: 00093 case CONSTANT_MethodHandle: 00094 case CONSTANT_NameAndType: 00095 return 5; 00096 00097 case CONSTANT_Long: 00098 case CONSTANT_Double: 00099 return 9; 00100 00101 case CONSTANT_Utf8: 00102 return (-1); //4 or more (see 'length') 00103 00104 default: 00105 return 0; 00106 } 00107 } 00108 00109 const_pool_t getConstantPoolInfo(int const_num){ 00110 00111 const_pool_t c; 00112 int i=0, j=1, length; 00113 00114 total_const_pool_num = (*bc_seek(8,1) << 8) + *bc_seek(9,1); 00115 00116 if ((const_num ==0)||(const_num >= total_const_pool_num)) 00117 { 00118 c.index = 0; 00119 return c; 00120 } 00121 00122 while(1) 00123 { 00124 c.tag = *bc_seek(10+i,1); // tag 00125 length = getLengthOfConstantInfo(*bc_seek(10+i,1)); 00126 00127 // Constant_UTF8 00128 if(length == -1){ 00129 length = ((*bc_seek(11+i,1)<<8) + *bc_seek(12+i,1)) + 3 /* tag + length = 3byte*/ ; 00130 } 00131 00132 if(j == const_num)break; 00133 if((c.tag == CONSTANT_Long)||(c.tag == CONSTANT_Double)){ 00134 j = j + 2; 00135 }else{ 00136 j = j + 1; 00137 } 00138 00139 if(j >= total_const_pool_num)break; 00140 i += length; 00141 } 00142 00143 c.index = ((*bc_seek(11+i,1)<<8) + *bc_seek(12+i,1)); 00144 c.index2 = ((*bc_seek(13+i,1)<<8) + *bc_seek(14+i,1)); 00145 c.bc_num = 10 + i; //todo: fix this 00146 switch(c.tag) 00147 { 00148 case CONSTANT_Utf8: 00149 memcpy((char*)cp_str, bc_seek(13+i,c.index), c.index); 00150 cp_str[c.index] = '\0'; 00151 c.stack_pt = (char *)&cp_str; 00152 break; 00153 00154 //case CONSTANT_Float: 00155 //case CONSTANT_Long: 00156 //case CONSTANT_Double: 00157 case CONSTANT_Integer: 00158 case CONSTANT_Float: 00159 c.index = (*bc_seek(11+i,1)<<24) + (*bc_seek(12+i,1) << 16) + (*bc_seek(13+i,1)<<8) + *bc_seek(14+i,1); 00160 break; 00161 case CONSTANT_Double: 00162 case CONSTANT_Long: 00163 c.index = (*bc_seek(11+i,1)<<24) + (*bc_seek(12+i,1) << 16) + (*bc_seek(13+i,1)<<8) + *bc_seek(14+i,1); 00164 c.index2 = (*bc_seek(15+i,1)<<24) + (*bc_seek(16+i,1) << 16) + (*bc_seek(17+i,1)<<8) + *bc_seek(18+i,1); 00165 break; 00166 default: 00167 break; 00168 00169 } 00170 00171 return c; 00172 } 00173 00174 //seek class_name_index,Strings,Numerics from Constant Pool 00175 const_pool_t seekConstClassNumString(int const_num) 00176 { 00177 const_pool_t c; 00178 c = getConstantPoolInfo(const_num); 00179 00180 switch (c.tag) 00181 { 00182 case CONSTANT_String: 00183 case CONSTANT_Class: 00184 c = getConstantPoolInfo(c.index); 00185 break; 00186 00187 default: 00188 break; 00189 } 00190 return c; 00191 } 00192 00193 // for methodref & Fieldref 00194 const_pool_t seekClassIndex(int const_num){ 00195 const_pool_t c; 00196 c = getConstantPoolInfo(const_num); 00197 00198 switch(c.tag) 00199 { 00200 case CONSTANT_Methodref: 00201 case CONSTANT_Fieldref: 00202 c = seekConstClassNumString(c.index); 00203 break; 00204 00205 default: 00206 break; // in fact,we must program in error process but tedious;-P 00207 } 00208 00209 return c; 00210 } 00211 00212 // For NameAndType:name index 00213 const_pool_t seekNameAndType_name(int const_num){ 00214 const_pool_t c; 00215 c = getConstantPoolInfo(const_num); 00216 00217 00218 switch(c.tag) 00219 { 00220 case CONSTANT_Methodref: 00221 case CONSTANT_Fieldref: 00222 c = getConstantPoolInfo(c.index2); //Constant_NAmeAndType 00223 // do not insert break; here 00224 00225 case CONSTANT_NameAndType: 00226 c = seekConstClassNumString(c.index); 00227 break; 00228 00229 default: 00230 break; // in fact,we must program in error process but tedious;-P 00231 } 00232 return c; 00233 } 00234 00235 00236 // For NameAndType:descriptor 00237 const_pool_t seekNameAndType_desc(int const_num){ 00238 const_pool_t c; 00239 c = getConstantPoolInfo(const_num); 00240 00241 switch(c.tag) 00242 { 00243 case CONSTANT_Methodref: 00244 case CONSTANT_Fieldref: 00245 c = getConstantPoolInfo(c.index2); // Constant_NAmeAndType 00246 c = seekConstClassNumString(c.index2); 00247 break; 00248 00249 case CONSTANT_NameAndType: 00250 c = seekConstClassNumString(c.index2); 00251 break; 00252 00253 default: 00254 break; 00255 00256 } 00257 return c; 00258 } 00259 00260 class_st seekCodeArrtibute(class_st cl, char* method_name,int strlen){ 00261 00262 int i,j; 00263 int length,cmp; 00264 volatile int pointr; 00265 int attribute_length, attributes_count,fields_count; 00266 const_pool_t z; 00267 cl.code_length = 0; 00268 00269 00270 // get length of Constant_pool[last_num] 00271 z = getConstantPoolInfo(total_const_pool_num - 1); 00272 00273 if(z.tag == CONSTANT_Utf8) length = z.index + 3; else length = getLengthOfConstantInfo(z.tag); 00274 00275 pointr = z.bc_num + length; 00276 00277 // seek pointr to interfaces_count 00278 pointr += 00279 + 2 // access_flag 00280 + 2 // this_class 00281 + 2 // super_class 00282 ; 00283 00284 pointr += (((*bc_seek(pointr,1) << 8) + *bc_seek(pointr + 1,1)) * 2) + 2; // 2 = length of 'interfaces_count' 00285 00286 // now, pointr's locate is fields_count(2bytes) 00287 fields_count = ((*bc_seek(pointr,1) << 8) + *bc_seek(pointr + 1,1)); 00288 pointr += 2; // fields_count 00289 00290 if(fields_count != 0){ 00291 // fields info 00292 for(i = 0 ; i < fields_count ; i++){ 00293 pointr += 00294 + 2 // access_flags 00295 + 2 // name_index 00296 + 2 // descriptor_index 00297 ; 00298 attributes_count = (*bc_seek(pointr,1) << 8) + *bc_seek(pointr + 1,1); 00299 pointr += 2; 00300 pointr += attributes_count; 00301 } 00302 } 00303 00304 // now, pointr's locate is methods_count(2bytes) 00305 methods_count = ((*bc_seek(pointr,1) << 8) + *bc_seek(pointr + 1,1)); 00306 pointr += 2; // method info (access_flag) 00307 for(i = 0 ; i < methods_count; i++) 00308 { 00309 00310 pointr += 2; // name_index 00311 00312 z = getConstantPoolInfo((*bc_seek(pointr,1)<<8)+*bc_seek(pointr + 1,1)); 00313 cmp = strncmp((const char*)z.stack_pt,method_name,strlen); 00314 00315 pointr += 2; //descriptor_index; 00316 pointr += 2; 00317 00318 attributes_count = ((*bc_seek(pointr,1) << 8) + *bc_seek(pointr + 1,1)); 00319 pointr += 2; //attributes_count; 00320 00321 for(j = 0 ; j < attributes_count ; j++) 00322 { 00323 pointr = pointr + 2; //attribute_name_index 00324 attribute_length = (*bc_seek(pointr,1) << 24) 00325 + (*bc_seek(pointr + 1,1) << 16) 00326 + (*bc_seek(pointr + 2,1) << 8) 00327 + *bc_seek(pointr + 3,1) 00328 ; 00329 00330 pointr += 4; //attribute_length 00331 if(!cmp) 00332 { 00333 cl.stack_num = (*bc_seek(pointr,1) << 8) + *bc_seek(pointr+1,1); 00334 cl.local_num = (*bc_seek(pointr+2,1) << 8) + *bc_seek(pointr+3,1); 00335 cl.code_length = (*bc_seek(pointr + 4,1) << 24) 00336 + (*bc_seek(pointr + 5,1) << 16) 00337 + (*bc_seek(pointr + 6,1) << 8) 00338 + *bc_seek(pointr + 7,1) 00339 ; 00340 cl.bc_offset = pointr + 8; 00341 cl.code_offset = 0; 00342 } 00343 pointr += attribute_length; // code attribute 00344 } 00345 } 00346 00347 return cl; 00348 } 00349 00350 char* getStringFromOperandStack(class_st cl) 00351 { 00352 int i; 00353 const_pool_t cp; 00354 00355 for(i = 0 ; i < cl.stack_num ; i++){ 00356 if(cl.op_stack_type[i]==0){ // seek top of stack 00357 if(i == 0)return NULL; // return NULL if operand stack has no stack 00358 break; 00359 } 00360 } 00361 00362 i = i - 1; 00363 00364 if(cl.op_stack_type[i] == Stack_ConstantPool){ 00365 cp = seekConstClassNumString(cl.op_stack[i]); 00366 cl.op_stack_type[i] = Stack_Nothing; 00367 return (char*)cp.stack_pt; 00368 } 00369 if(cl.op_stack_type[i] == Stack_IntType){ 00370 cl.op_stack_type[i] = Stack_Nothing; 00371 sprintf(cp_str,"%d",cl.op_stack[i]); 00372 return cp_str; 00373 } 00374 if(cl.op_stack_type[i] == Stack_CharType){ 00375 cl.op_stack_type[i] = Stack_Nothing; 00376 sprintf(cp_str,"%c",(char)cl.op_stack[i]); 00377 return cp_str; 00378 } 00379 00380 return NULL; 00381 } 00382 00383 int getIntegerFromOperandStack(class_st cl){ 00384 int i; 00385 const_pool_t cp; 00386 00387 for(i = 0 ; i < cl.stack_num ; i++){ 00388 if(cl.op_stack_type[i]==0){ // seek top of stack 00389 if(i == 0)return 0; 00390 break; 00391 } 00392 } 00393 i = i - 1; 00394 00395 if(cl.op_stack_type[i] == Stack_ConstantPool){ // Const_Integer 00396 cp = seekConstClassNumString(cl.op_stack[i]); 00397 cl.op_stack_type[i] = 0; 00398 if((cp.tag == CONSTANT_Long)||(cp.tag == CONSTANT_Double)) 00399 return (cp.index2); 00400 else 00401 return (cp.index); 00402 } 00403 00404 if(cl.op_stack_type[i] == Stack_IntType){ // stack direct 00405 cl.op_stack_type[i] = 0; 00406 return cl.op_stack[i]; 00407 } 00408 return 0; 00409 } 00410 00411 class_st setStackFromConstantPool(class_st cl, int cp_num){ 00412 00413 int i; 00414 for(i=0 ; i < cl.stack_num ; i++){ 00415 if(cl.op_stack_type[i]==0){ // seek top of stack 00416 break; 00417 } 00418 } 00419 00420 if((i == cl.stack_num - 1)&&(cl.op_stack_type[i] != 0)) 00421 return cl;// stack full 00422 00423 cl.op_stack_type[i] = Stack_ConstantPool; 00424 cl.op_stack[i] = cp_num; 00425 i = i + 1; 00426 if(i == cl.stack_num) 00427 return cl; 00428 else 00429 cl.op_stack_type[i] = Stack_Nothing; 00430 00431 return cl; 00432 } 00433 00434 class_st changeStackType(class_st cl, int type){ 00435 00436 int i; 00437 for(i=0 ; i < cl.stack_num ; i++){ 00438 if(cl.op_stack_type[i]==0){ // seek top of stack 00439 break; 00440 } 00441 } 00442 00443 i = i - 1; 00444 00445 cl.op_stack_type[i] = type; 00446 return cl; 00447 } 00448 00449 00450 class_st setIntegerToStack(class_st cl, int num){ 00451 00452 int i; 00453 for(i = 0 ; i < cl.stack_num ; i++){ 00454 if(cl.op_stack_type[i]==0){ // seek top of stack 00455 break; 00456 } 00457 } 00458 00459 if((i == cl.stack_num - 1)&&(cl.op_stack_type[i]!=0)) 00460 return cl;// stack full 00461 00462 cl.op_stack_type[i] = Stack_IntType; 00463 cl.op_stack[i] = num; 00464 i = i + 1; 00465 if(i == cl.stack_num) 00466 return cl; 00467 else 00468 cl.op_stack_type[i] = Stack_Nothing; 00469 00470 return cl; 00471 } 00472 00473 class_st putField(class_st cl, int cp_num){ 00474 00475 00476 if(strncmp((const char *)seekNameAndType_desc(cp_num).stack_pt,"I",1) == 0){ // int type 00477 if(cl.field_num == 0){ // first mem alloc 00478 00479 cl.field_mem_reg = (int *)pool_alloc(sizeof(int) * 1); 00480 cl.field_mem_type = (int *)pool_alloc(sizeof(int) * 1); 00481 cl.field_num = cl.field_num + 1; 00482 00483 cl.field_mem_reg[0] = getIntegerFromOperandStack(cl); 00484 cl.field_mem_type[0] = cp_num; 00485 00486 return cl; 00487 } 00488 else{ // field_num != 0 00489 int i; 00490 for(i = 0; i < cl.field_num ; i++){ 00491 if(cl.field_mem_type[i] == cp_num){ //already exists 00492 cl.field_mem_reg[i] = getIntegerFromOperandStack(cl); 00493 return cl; 00494 } 00495 }// 00496 cl.field_num = cl.field_num + 1; 00497 cl.field_mem_reg = (int *)pool_realloc(cl.field_mem_reg, sizeof(int) * (cl.field_num)); 00498 cl.field_mem_type = (int *)pool_realloc(cl.field_mem_type, sizeof(int) * (cl.field_num)); 00499 00500 cl.field_mem_reg[cl.field_num - 1] = getIntegerFromOperandStack(cl); 00501 cl.field_mem_type[cl.field_num - 1] = cp_num; 00502 00503 return cl; 00504 } 00505 } 00506 00507 //memcpy(&cl.field_mem_reg, &s,strlen(s)); 00508 return cl; 00509 } 00510 00511 class_st getField(class_st cl,int cp_num){ 00512 00513 if(strncmp((const char *)seekNameAndType_desc(cp_num).stack_pt,"I",1) == 0){ // int type 00514 int i; 00515 for(i = 0; i < cl.field_num ; i++){ 00516 if(cl.field_mem_type[i] == cp_num){ //already exists 00517 cl = setIntegerToStack(cl,cl.field_mem_reg[i]); 00518 return cl; 00519 } 00520 } 00521 char s[32]; 00522 sprintf(s,"Fnum=%d,memtype=%d,reg=%d\r\n",cl.field_num,cl.field_mem_type[0],cl.field_mem_reg[0]); 00523 uart_print(s); 00524 uart_print("getField error\r\n"); 00525 } 00526 return cl; 00527 } 00528 00529 00530 class_st decodeVM(class_st cl){ 00531 00532 int now_code = 0; 00533 00534 00535 now_code = cl.bc_offset + cl.code_offset; 00536 switch(*bc_seek(now_code,1)){ 00537 case JAVA_nop: 00538 now_code = now_code + 1; 00539 break; 00540 00541 case JAVA_ldc2_w: 00542 cl = setStackFromConstantPool(cl, (*bc_seek(now_code + 1,1)<<8) + *bc_seek(now_code + 2,1)); 00543 now_code = now_code + 3; 00544 break; 00545 case JAVA_ldc: 00546 cl = setStackFromConstantPool(cl, *bc_seek(now_code + 1,1)); 00547 now_code = now_code + 2; 00548 break; 00549 00550 case JAVA_iconst_0: 00551 cl = setIntegerToStack(cl,0); 00552 now_code = now_code + 1; 00553 break; 00554 case JAVA_iconst_1: 00555 cl = setIntegerToStack(cl,1); 00556 now_code = now_code + 1; 00557 break; 00558 case JAVA_iconst_2: 00559 cl = setIntegerToStack(cl,2); 00560 now_code = now_code + 1; 00561 break; 00562 case JAVA_iconst_3: 00563 cl = setIntegerToStack(cl,3); 00564 now_code = now_code + 1; 00565 break; 00566 case JAVA_iconst_4: 00567 cl = setIntegerToStack(cl,4); 00568 now_code = now_code + 1; 00569 break; 00570 case JAVA_iconst_5: 00571 cl = setIntegerToStack(cl,5); 00572 now_code = now_code + 1; 00573 break; 00574 00575 case JAVA_aload: 00576 now_code = now_code + 2; 00577 break; 00578 00579 case JAVA_iload_0: 00580 cl = setIntegerToStack(cl,cl.local_reg[0]); 00581 now_code = now_code + 1; 00582 break; 00583 case JAVA_iload_1: 00584 cl = setIntegerToStack(cl,cl.local_reg[1]); 00585 now_code = now_code + 1; 00586 break; 00587 case JAVA_iload_2: 00588 cl = setIntegerToStack(cl,cl.local_reg[2]); 00589 now_code = now_code + 1; 00590 break; 00591 case JAVA_iload_3: 00592 cl = setIntegerToStack(cl,cl.local_reg[3]); 00593 now_code = now_code + 1; 00594 break; 00595 00596 case JAVA_aload_0: 00597 case JAVA_aload_1: 00598 case JAVA_aload_2: 00599 case JAVA_aload_3: 00600 now_code = now_code + 1; 00601 break; 00602 00603 case JAVA_astore: 00604 now_code = now_code + 2; 00605 break; 00606 00607 case JAVA_istore_0: 00608 cl.local_reg[0] = getIntegerFromOperandStack(cl); 00609 now_code = now_code + 1; 00610 break; 00611 case JAVA_istore_1: 00612 cl.local_reg[1] = getIntegerFromOperandStack(cl); 00613 now_code = now_code + 1; 00614 break; 00615 case JAVA_istore_2: 00616 cl.local_reg[2] = getIntegerFromOperandStack(cl); 00617 now_code = now_code + 1; 00618 break; 00619 case JAVA_istore_3: 00620 cl.local_reg[3] = getIntegerFromOperandStack(cl); 00621 now_code = now_code + 1; 00622 break; 00623 00624 case JAVA_astore_0: 00625 case JAVA_astore_1: 00626 case JAVA_astore_2: 00627 case JAVA_astore_3: 00628 now_code = now_code + 1; 00629 break; 00630 00631 case JAVA_dup: 00632 now_code = now_code + 1; 00633 break; 00634 00635 case JAVA_iadd: 00636 now_code = now_code + 1; 00637 setIntegerToStack(cl,getIntegerFromOperandStack(cl) + getIntegerFromOperandStack(cl)); 00638 break; 00639 00640 case JAVA_iinc: 00641 cl.local_reg[*bc_seek(now_code + 1, 1)] = cl.local_reg[*bc_seek(now_code + 1, 1)] + (int8_t)(*bc_seek(now_code + 2, 1)); 00642 now_code = now_code + 3; 00643 break; 00644 00645 case JAVA_getstatic: 00646 now_code = now_code + 3; 00647 break; 00648 00649 case JAVA_getfield: 00650 cl = getField(cl,(*bc_seek(now_code + 1, 1) << 8) + *bc_seek(now_code + 2, 1)); 00651 now_code = now_code + 3; 00652 break; 00653 00654 case JAVA_putfield: 00655 cl = putField(cl,(*bc_seek(now_code + 1, 1) << 8) + *bc_seek(now_code + 2, 1)); 00656 now_code = now_code + 3; 00657 break; 00658 00659 case JAVA_i2l: 00660 //cl = changeStackType(cl, Stack_LongType); 00661 now_code = now_code + 1; 00662 break; 00663 00664 case JAVA_i2c: 00665 now_code = now_code + 1; 00666 cl = changeStackType(cl, Stack_CharType); 00667 break; 00668 00669 case JAVA_if_icmplt: 00670 if(getIntegerFromOperandStack(cl) > getIntegerFromOperandStack(cl)){ 00671 now_code = now_code +(int16_t)((*bc_seek(now_code + 1, 1) << 8) + *bc_seek(now_code + 2, 1)); // goto 00672 break; 00673 }else{ 00674 now_code = now_code + 3; 00675 } 00676 break; 00677 00678 case JAVA_if_icmpge: 00679 if(getIntegerFromOperandStack(cl) <= getIntegerFromOperandStack(cl)){ 00680 now_code = now_code +(int16_t)((*bc_seek(now_code + 1, 1) << 8) + *bc_seek(now_code + 2, 1)); // goto 00681 break; 00682 }else{ 00683 now_code = now_code + 3; 00684 } 00685 break; 00686 00687 case JAVA_if_icmpgt: 00688 if(getIntegerFromOperandStack(cl) < getIntegerFromOperandStack(cl)){ 00689 now_code = now_code +(int16_t)((*bc_seek(now_code + 1, 1) << 8) + *bc_seek(now_code + 2, 1)); // goto 00690 break; 00691 }else{ 00692 now_code = now_code + 3; 00693 } 00694 break; 00695 00696 case JAVA_if_icmple: 00697 if(getIntegerFromOperandStack(cl) >= getIntegerFromOperandStack(cl)){ 00698 now_code = now_code +(int16_t)((*bc_seek(now_code + 1, 1) << 8) + *bc_seek(now_code + 2, 1)); // goto 00699 break; 00700 }else{ 00701 now_code = now_code + 3; 00702 } 00703 break; 00704 00705 case JAVA_goto: 00706 now_code = now_code +(int16_t)((*bc_seek(now_code + 1, 1) << 8) + *bc_seek(now_code + 2, 1)); 00707 break; 00708 00709 case JAVA_bipush: 00710 cl = setIntegerToStack(cl,*bc_seek(now_code + 1,1)); 00711 now_code = now_code + 2; 00712 break; 00713 00714 case JAVA_sipush: 00715 cl = setIntegerToStack(cl,((*bc_seek(now_code + 1, 1) << 8) + *bc_seek(now_code + 2, 1))); 00716 now_code = now_code + 3; 00717 break; 00718 00719 case JAVA_invokevirtual: 00720 cl = invokevirtual_callFunction(cl,(*bc_seek(now_code + 1, 1) << 8) + *bc_seek(now_code + 2, 1)); 00721 now_code = now_code + 3; 00722 break; 00723 00724 case JAVA_invokestatic: 00725 cl = invokestatic_callFunction(cl,(*bc_seek(now_code + 1, 1) << 8) + *bc_seek(now_code + 2, 1)); 00726 now_code = cl.bc_offset + cl.code_offset; 00727 break; 00728 00729 case JAVA_invokespecial: 00730 cl = invokespecial_callFunction(cl, (*bc_seek(now_code + 1, 1) << 8) + *bc_seek(now_code + 2, 1)); 00731 now_code = now_code + 3; 00732 break; 00733 00734 case JAVA_new: 00735 now_code = now_code + 3; 00736 break; 00737 00738 case JAVA_return: 00739 cl.code_offset = 0; 00740 cl.threadCommand = Thread_returned; 00741 00742 default: 00743 break; 00744 } 00745 00746 cl.code_offset = now_code - cl.bc_offset; 00747 00748 00749 return cl; 00750 } 00751 00752 00753 class_st invokespecial_callFunction(class_st cl, int cp_num){ 00754 00755 char* func_name = (char *)seekNameAndType_name(cp_num).stack_pt; 00756 00757 if(strncmp(func_name,"<init>",6) == 0){ 00758 if(strncmp((const char *)seekNameAndType_desc(cp_num).stack_pt,"(I",2) != 0) {return cl;} 00759 int i; 00760 for(i = 0 ; i < cl.stack_num ; i++){ 00761 if(cl.op_stack_type[i] == Stack_Nothing){ // seek top of stack 00762 if(i == 0){ 00763 cl.threadCommand = Thread_getInitMethod; 00764 00765 return cl; 00766 } 00767 break; 00768 } 00769 } 00770 i = i - 1; 00771 cl.threadCommand = Thread_getInitMethodWithStack; 00772 00773 cl.threadArg = i; 00774 return cl; 00775 } 00776 return cl; 00777 } 00778 00779 class_st invokestatic_callFunction(class_st cl, int cp_num){ 00780 00781 char* func_name = (char *)seekNameAndType_name(cp_num).stack_pt; 00782 00783 if(strncmp(func_name,"sleep",5) == 0){ 00784 int hold_time = 0; 00785 hold_time = getIntegerFromOperandStack(cl); 00786 switch(cl.threadCommand){ 00787 case Thread_Active: 00788 cl.threadCommand = Thread_inSleep; 00789 cl.threadArg = time_millis(); 00790 cl = setIntegerToStack(cl,hold_time); 00791 break; 00792 case Thread_inSleep: 00793 if(time_millis() - cl.threadArg >= hold_time){ 00794 cl.threadCommand = Thread_Active; 00795 cl.threadArg = 0; 00796 cl.code_offset = cl.code_offset + 3; 00797 hold_time = 0; 00798 }else{ 00799 cl = setIntegerToStack(cl,hold_time); 00800 } 00801 break; 00802 default: 00803 break; 00804 } 00805 00806 return cl; 00807 }else if(strncmp(func_name,"portWrite",9) == 0){// writePort(bit,value) 00808 int value = getIntegerFromOperandStack(cl); 00809 int bit = getIntegerFromOperandStack(cl); 00810 port_write(0,bit,value); 00811 } 00812 cl.code_offset = cl.code_offset + 3; 00813 return cl; 00814 } 00815 00816 //user code 00817 class_st invokevirtual_callFunction(class_st cl, int cp_num){ 00818 00819 char* func_name = (char *)seekNameAndType_name(cp_num).stack_pt; 00820 00821 if(strncmp(func_name,"println",7) == 0){ 00822 char str[64]; 00823 char *strn = getStringFromOperandStack(cl); 00824 sprintf(str,"%s",strn); 00825 uart_print(str); 00826 uart_print("\r\n"); 00827 return cl; 00828 }else if(strncmp(func_name,"print",5) == 0){ 00829 char str[64]; 00830 char *strn = getStringFromOperandStack(cl); 00831 sprintf(str,"%s",strn); 00832 uart_print(str); 00833 return cl; 00834 }else if(strncmp(func_name,"read",4) == 0){ 00835 int getInt; 00836 getInt = uart_read(); 00837 cl = setIntegerToStack(cl,getInt); 00838 return cl; 00839 }else if(strncmp(func_name,"start",5) == 0){ 00840 cl.threadCommand = Thread_getStartMethod; 00841 return cl; 00842 }else if(strncmp(func_name,"getName",7) == 0){ 00843 cl = setIntegerToStack(cl, cl.myThreadNum); 00844 return cl; 00845 } 00846 00847 return cl; 00848 } 00849
Generated on Tue Jul 12 2022 21:16:03 by
1.7.2