1/* 2 * Copyright (c) 1994, 2016, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26/*- 27 * Verify that the code within a method block doesn't exploit any 28 * security holes. 29 */ 30/* 31 Exported function: 32 33 jboolean 34 VerifyClass(JNIEnv *env, jclass cb, char *message_buffer, 35 jint buffer_length) 36 jboolean 37 VerifyClassForMajorVersion(JNIEnv *env, jclass cb, char *message_buffer, 38 jint buffer_length, jint major_version) 39 40 This file now only uses the standard JNI and the following VM functions 41 exported in jvm.h: 42 43 JVM_FindClassFromClass 44 JVM_IsInterface 45 JVM_GetClassNameUTF 46 JVM_GetClassCPEntriesCount 47 JVM_GetClassCPTypes 48 JVM_GetClassFieldsCount 49 JVM_GetClassMethodsCount 50 51 JVM_GetFieldIxModifiers 52 53 JVM_GetMethodIxModifiers 54 JVM_GetMethodIxExceptionTableLength 55 JVM_GetMethodIxLocalsCount 56 JVM_GetMethodIxArgsSize 57 JVM_GetMethodIxMaxStack 58 JVM_GetMethodIxNameUTF 59 JVM_GetMethodIxSignatureUTF 60 JVM_GetMethodIxExceptionsCount 61 JVM_GetMethodIxExceptionIndexes 62 JVM_GetMethodIxByteCodeLength 63 JVM_GetMethodIxByteCode 64 JVM_GetMethodIxExceptionTableEntry 65 JVM_IsConstructorIx 66 67 JVM_GetCPClassNameUTF 68 JVM_GetCPFieldNameUTF 69 JVM_GetCPMethodNameUTF 70 JVM_GetCPFieldSignatureUTF 71 JVM_GetCPMethodSignatureUTF 72 JVM_GetCPFieldClassNameUTF 73 JVM_GetCPMethodClassNameUTF 74 JVM_GetCPFieldModifiers 75 JVM_GetCPMethodModifiers 76 77 JVM_ReleaseUTF 78 JVM_IsSameClassPackage 79 80 */ 81 82#include <string.h> 83#include <setjmp.h> 84#include <assert.h> 85#include <limits.h> 86#include <stdlib.h> 87 88#include "jni.h" 89#include "jni_util.h" 90#include "jvm.h" 91#include "classfile_constants.h" 92#include "opcodes.in_out" 93 94/* On AIX malloc(0) and calloc(0, ...) return a NULL pointer, which is legal, 95 * but the code here does not handles it. So we wrap the methods and return non-NULL 96 * pointers even if we allocate 0 bytes. 97 */ 98#ifdef _AIX 99static int aix_dummy; 100static void* aix_malloc(size_t len) { 101 if (len == 0) { 102 return &aix_dummy; 103 } 104 return malloc(len); 105} 106 107static void* aix_calloc(size_t n, size_t size) { 108 if (n == 0) { 109 return &aix_dummy; 110 } 111 return calloc(n, size); 112} 113 114static void aix_free(void* p) { 115 if (p == &aix_dummy) { 116 return; 117 } 118 free(p); 119} 120 121#undef malloc 122#undef calloc 123#undef free 124#define malloc aix_malloc 125#define calloc aix_calloc 126#define free aix_free 127#endif 128 129#ifdef __APPLE__ 130/* use setjmp/longjmp versions that do not save/restore the signal mask */ 131#define setjmp _setjmp 132#define longjmp _longjmp 133#endif 134 135#define MAX_ARRAY_DIMENSIONS 255 136/* align byte code */ 137#ifndef ALIGN_UP 138#define ALIGN_UP(n,align_grain) (((n) + ((align_grain) - 1)) & ~((align_grain)-1)) 139#endif /* ALIGN_UP */ 140#define UCALIGN(n) ((unsigned char *)ALIGN_UP((uintptr_t)(n),sizeof(int))) 141 142#ifdef DEBUG 143 144int verify_verbose = 0; 145static struct context_type *GlobalContext; 146#endif 147 148enum { 149 ITEM_Bogus, 150 ITEM_Void, /* only as a function return value */ 151 ITEM_Integer, 152 ITEM_Float, 153 ITEM_Double, 154 ITEM_Double_2, /* 2nd word of double in register */ 155 ITEM_Long, 156 ITEM_Long_2, /* 2nd word of long in register */ 157 ITEM_Array, 158 ITEM_Object, /* Extra info field gives name. */ 159 ITEM_NewObject, /* Like object, but uninitialized. */ 160 ITEM_InitObject, /* "this" is init method, before call 161 to super() */ 162 ITEM_ReturnAddress, /* Extra info gives instr # of start pc */ 163 /* The following four are only used within array types. 164 * Normally, we use ITEM_Integer, instead. */ 165 ITEM_Byte, 166 ITEM_Short, 167 ITEM_Char, 168 ITEM_Boolean 169}; 170 171 172#define UNKNOWN_STACK_SIZE -1 173#define UNKNOWN_REGISTER_COUNT -1 174#define UNKNOWN_RET_INSTRUCTION -1 175 176#undef MAX 177#undef MIN 178#define MAX(a, b) ((a) > (b) ? (a) : (b)) 179#define MIN(a, b) ((a) < (b) ? (a) : (b)) 180 181#define BITS_PER_INT (CHAR_BIT * sizeof(int)/sizeof(char)) 182#define SET_BIT(flags, i) (flags[(i)/BITS_PER_INT] |= \ 183 ((unsigned)1 << ((i) % BITS_PER_INT))) 184#define IS_BIT_SET(flags, i) (flags[(i)/BITS_PER_INT] & \ 185 ((unsigned)1 << ((i) % BITS_PER_INT))) 186 187typedef unsigned int fullinfo_type; 188typedef unsigned int *bitvector; 189 190#define GET_ITEM_TYPE(thing) ((thing) & 0x1F) 191#define GET_INDIRECTION(thing) (((thing) & 0xFFFF) >> 5) 192#define GET_EXTRA_INFO(thing) ((thing) >> 16) 193#define WITH_ZERO_INDIRECTION(thing) ((thing) & ~(0xFFE0)) 194#define WITH_ZERO_EXTRA_INFO(thing) ((thing) & 0xFFFF) 195 196#define MAKE_FULLINFO(type, indirect, extra) \ 197 ((type) + ((indirect) << 5) + ((extra) << 16)) 198 199#define MAKE_Object_ARRAY(indirect) \ 200 (context->object_info + ((indirect) << 5)) 201 202#define NULL_FULLINFO MAKE_FULLINFO(ITEM_Object, 0, 0) 203 204/* JVM_OPC_invokespecial calls to <init> need to be treated special */ 205#define JVM_OPC_invokeinit 0x100 206 207/* A hash mechanism used by the verifier. 208 * Maps class names to unique 16 bit integers. 209 */ 210 211#define HASH_TABLE_SIZE 503 212 213/* The buckets are managed as a 256 by 256 matrix. We allocate an entire 214 * row (256 buckets) at a time to minimize fragmentation. Rows are 215 * allocated on demand so that we don't waste too much space. 216 */ 217 218#define MAX_HASH_ENTRIES 65536 219#define HASH_ROW_SIZE 256 220 221typedef struct hash_bucket_type { 222 char *name; 223 unsigned int hash; 224 jclass class; 225 unsigned short ID; 226 unsigned short next; 227 unsigned loadable:1; /* from context->class loader */ 228} hash_bucket_type; 229 230typedef struct { 231 hash_bucket_type **buckets; 232 unsigned short *table; 233 int entries_used; 234} hash_table_type; 235 236#define GET_BUCKET(class_hash, ID)\ 237 (class_hash->buckets[ID / HASH_ROW_SIZE] + ID % HASH_ROW_SIZE) 238 239/* 240 * There are currently two types of resources that we need to keep 241 * track of (in addition to the CCalloc pool). 242 */ 243enum { 244 VM_STRING_UTF, /* VM-allocated UTF strings */ 245 VM_MALLOC_BLK /* malloc'ed blocks */ 246}; 247 248#define LDC_CLASS_MAJOR_VERSION 49 249 250#define LDC_METHOD_HANDLE_MAJOR_VERSION 51 251 252#define NONZERO_PADDING_BYTES_IN_SWITCH_MAJOR_VERSION 51 253 254#define STATIC_METHOD_IN_INTERFACE_MAJOR_VERSION 52 255 256#define ALLOC_STACK_SIZE 16 /* big enough */ 257 258typedef struct alloc_stack_type { 259 void *ptr; 260 int kind; 261 struct alloc_stack_type *next; 262} alloc_stack_type; 263 264/* The context type encapsulates the current invocation of the byte 265 * code verifier. 266 */ 267struct context_type { 268 269 JNIEnv *env; /* current JNIEnv */ 270 271 /* buffers etc. */ 272 char *message; 273 jint message_buf_len; 274 jboolean err_code; 275 276 alloc_stack_type *allocated_memory; /* all memory blocks that we have not 277 had a chance to free */ 278 /* Store up to ALLOC_STACK_SIZE number of handles to allocated memory 279 blocks here, to save mallocs. */ 280 alloc_stack_type alloc_stack[ALLOC_STACK_SIZE]; 281 int alloc_stack_top; 282 283 /* these fields are per class */ 284 jclass class; /* current class */ 285 jint major_version; 286 jint nconstants; 287 unsigned char *constant_types; 288 hash_table_type class_hash; 289 290 fullinfo_type object_info; /* fullinfo for java/lang/Object */ 291 fullinfo_type string_info; /* fullinfo for java/lang/String */ 292 fullinfo_type throwable_info; /* fullinfo for java/lang/Throwable */ 293 fullinfo_type cloneable_info; /* fullinfo for java/lang/Cloneable */ 294 fullinfo_type serializable_info; /* fullinfo for java/io/Serializable */ 295 296 fullinfo_type currentclass_info; /* fullinfo for context->class */ 297 fullinfo_type superclass_info; /* fullinfo for superclass */ 298 299 /* these fields are per method */ 300 int method_index; /* current method */ 301 unsigned short *exceptions; /* exceptions */ 302 unsigned char *code; /* current code object */ 303 jint code_length; 304 int *code_data; /* offset to instruction number */ 305 struct instruction_data_type *instruction_data; /* info about each */ 306 struct handler_info_type *handler_info; 307 fullinfo_type *superclasses; /* null terminated superclasses */ 308 int instruction_count; /* number of instructions */ 309 fullinfo_type return_type; /* function return type */ 310 fullinfo_type swap_table[4]; /* used for passing information */ 311 int bitmask_size; /* words needed to hold bitmap of arguments */ 312 313 /* these fields are per field */ 314 int field_index; 315 316 /* Used by the space allocator */ 317 struct CCpool *CCroot, *CCcurrent; 318 char *CCfree_ptr; 319 int CCfree_size; 320 321 /* Jump here on any error. */ 322 jmp_buf jump_buffer; 323 324#ifdef DEBUG 325 /* keep track of how many global refs are allocated. */ 326 int n_globalrefs; 327#endif 328}; 329 330struct stack_info_type { 331 struct stack_item_type *stack; 332 int stack_size; 333}; 334 335struct register_info_type { 336 int register_count; /* number of registers used */ 337 fullinfo_type *registers; 338 int mask_count; /* number of masks in the following */ 339 struct mask_type *masks; 340}; 341 342struct mask_type { 343 int entry; 344 int *modifies; 345}; 346 347typedef unsigned short flag_type; 348 349struct instruction_data_type { 350 int opcode; /* may turn into "canonical" opcode */ 351 unsigned changed:1; /* has it changed */ 352 unsigned protected:1; /* must accessor be a subclass of "this" */ 353 union { 354 int i; /* operand to the opcode */ 355 int *ip; 356 fullinfo_type fi; 357 } operand, operand2; 358 fullinfo_type p; 359 struct stack_info_type stack_info; 360 struct register_info_type register_info; 361#define FLAG_REACHED 0x01 /* instruction reached */ 362#define FLAG_NEED_CONSTRUCTOR 0x02 /* must call this.<init> or super.<init> */ 363#define FLAG_NO_RETURN 0x04 /* must throw out of method */ 364 flag_type or_flags; /* true for at least one path to this inst */ 365#define FLAG_CONSTRUCTED 0x01 /* this.<init> or super.<init> called */ 366 flag_type and_flags; /* true for all paths to this instruction */ 367}; 368 369struct handler_info_type { 370 int start, end, handler; 371 struct stack_info_type stack_info; 372}; 373 374struct stack_item_type { 375 fullinfo_type item; 376 struct stack_item_type *next; 377}; 378 379typedef struct context_type context_type; 380typedef struct instruction_data_type instruction_data_type; 381typedef struct stack_item_type stack_item_type; 382typedef struct register_info_type register_info_type; 383typedef struct stack_info_type stack_info_type; 384typedef struct mask_type mask_type; 385 386static void read_all_code(context_type *context, jclass cb, int num_methods, 387 int** code_lengths, unsigned char*** code); 388static void verify_method(context_type *context, jclass cb, int index, 389 int code_length, unsigned char* code); 390static void free_all_code(context_type* context, int num_methods, 391 unsigned char** code); 392static void verify_field(context_type *context, jclass cb, int index); 393 394static void verify_opcode_operands (context_type *, unsigned int inumber, int offset); 395static void set_protected(context_type *, unsigned int inumber, int key, int); 396static jboolean is_superclass(context_type *, fullinfo_type); 397 398static void initialize_exception_table(context_type *); 399static int instruction_length(unsigned char *iptr, unsigned char *end); 400static jboolean isLegalTarget(context_type *, int offset); 401static void verify_constant_pool_type(context_type *, int, unsigned); 402 403static void initialize_dataflow(context_type *); 404static void run_dataflow(context_type *context); 405static void check_register_values(context_type *context, unsigned int inumber); 406static void check_flags(context_type *context, unsigned int inumber); 407static void pop_stack(context_type *, unsigned int inumber, stack_info_type *); 408static void update_registers(context_type *, unsigned int inumber, register_info_type *); 409static void update_flags(context_type *, unsigned int inumber, 410 flag_type *new_and_flags, flag_type *new_or_flags); 411static void push_stack(context_type *, unsigned int inumber, stack_info_type *stack); 412 413static void merge_into_successors(context_type *, unsigned int inumber, 414 register_info_type *register_info, 415 stack_info_type *stack_info, 416 flag_type and_flags, flag_type or_flags); 417static void merge_into_one_successor(context_type *context, 418 unsigned int from_inumber, 419 unsigned int inumber, 420 register_info_type *register_info, 421 stack_info_type *stack_info, 422 flag_type and_flags, flag_type or_flags, 423 jboolean isException); 424static void merge_stack(context_type *, unsigned int inumber, 425 unsigned int to_inumber, stack_info_type *); 426static void merge_registers(context_type *, unsigned int inumber, 427 unsigned int to_inumber, 428 register_info_type *); 429static void merge_flags(context_type *context, unsigned int from_inumber, 430 unsigned int to_inumber, 431 flag_type new_and_flags, flag_type new_or_flags); 432 433static stack_item_type *copy_stack(context_type *, stack_item_type *); 434static mask_type *copy_masks(context_type *, mask_type *masks, int mask_count); 435static mask_type *add_to_masks(context_type *, mask_type *, int , int); 436 437static fullinfo_type decrement_indirection(fullinfo_type); 438 439static fullinfo_type merge_fullinfo_types(context_type *context, 440 fullinfo_type a, 441 fullinfo_type b, 442 jboolean assignment); 443static jboolean isAssignableTo(context_type *, 444 fullinfo_type a, 445 fullinfo_type b); 446 447static jclass object_fullinfo_to_classclass(context_type *, fullinfo_type); 448 449 450#define NEW(type, count) \ 451 ((type *)CCalloc(context, (count)*(sizeof(type)), JNI_FALSE)) 452#define ZNEW(type, count) \ 453 ((type *)CCalloc(context, (count)*(sizeof(type)), JNI_TRUE)) 454 455static void CCinit(context_type *context); 456static void CCreinit(context_type *context); 457static void CCdestroy(context_type *context); 458static void *CCalloc(context_type *context, int size, jboolean zero); 459 460static fullinfo_type cp_index_to_class_fullinfo(context_type *, int, int); 461 462static const char* get_result_signature(const char* signature); 463 464static char signature_to_fieldtype(context_type *context, 465 const char **signature_p, fullinfo_type *info); 466 467static void CCerror (context_type *, char *format, ...); 468static void CFerror (context_type *, char *format, ...); 469static void CCout_of_memory (context_type *); 470 471/* Because we can longjmp any time, we need to be very careful about 472 * remembering what needs to be freed. */ 473 474static void check_and_push(context_type *context, const void *ptr, int kind); 475static void pop_and_free(context_type *context); 476 477static int signature_to_args_size(const char *method_signature); 478 479#ifdef DEBUG 480static void print_stack (context_type *, stack_info_type *stack_info); 481static void print_registers(context_type *, register_info_type *register_info); 482static void print_flags(context_type *, flag_type, flag_type); 483static void print_formatted_fieldname(context_type *context, int index); 484static void print_formatted_methodname(context_type *context, int index); 485#endif 486 487/* 488 * Declare library specific JNI_Onload entry if static build 489 */ 490DEF_STATIC_JNI_OnLoad 491 492void initialize_class_hash(context_type *context) 493{ 494 hash_table_type *class_hash = &(context->class_hash); 495 class_hash->buckets = (hash_bucket_type **) 496 calloc(MAX_HASH_ENTRIES / HASH_ROW_SIZE, sizeof(hash_bucket_type *)); 497 class_hash->table = (unsigned short *) 498 calloc(HASH_TABLE_SIZE, sizeof(unsigned short)); 499 if (class_hash->buckets == 0 || 500 class_hash->table == 0) 501 CCout_of_memory(context); 502 class_hash->entries_used = 0; 503} 504 505static void finalize_class_hash(context_type *context) 506{ 507 hash_table_type *class_hash = &(context->class_hash); 508 JNIEnv *env = context->env; 509 int i; 510 /* 4296677: bucket index starts from 1. */ 511 for (i=1;i<=class_hash->entries_used;i++) { 512 hash_bucket_type *bucket = GET_BUCKET(class_hash, i); 513 assert(bucket != NULL); 514 free(bucket->name); 515 if (bucket->class) { 516 (*env)->DeleteGlobalRef(env, bucket->class); 517#ifdef DEBUG 518 context->n_globalrefs--; 519#endif 520 } 521 } 522 if (class_hash->buckets) { 523 for (i=0;i<MAX_HASH_ENTRIES / HASH_ROW_SIZE; i++) { 524 if (class_hash->buckets[i] == 0) 525 break; 526 free(class_hash->buckets[i]); 527 } 528 } 529 free(class_hash->buckets); 530 free(class_hash->table); 531} 532 533static hash_bucket_type * 534new_bucket(context_type *context, unsigned short *pID) 535{ 536 hash_table_type *class_hash = &(context->class_hash); 537 int i = *pID = class_hash->entries_used + 1; 538 int row = i / HASH_ROW_SIZE; 539 if (i >= MAX_HASH_ENTRIES) 540 CCerror(context, "Exceeded verifier's limit of 65535 referred classes"); 541 if (class_hash->buckets[row] == 0) { 542 class_hash->buckets[row] = (hash_bucket_type*) 543 calloc(HASH_ROW_SIZE, sizeof(hash_bucket_type)); 544 if (class_hash->buckets[row] == 0) 545 CCout_of_memory(context); 546 } 547 class_hash->entries_used++; /* only increment when we are sure there 548 is no overflow. */ 549 return GET_BUCKET(class_hash, i); 550} 551 552static unsigned int 553class_hash_fun(const char *s) 554{ 555 int i; 556 unsigned raw_hash; 557 for (raw_hash = 0; (i = *s) != '\0'; ++s) 558 raw_hash = raw_hash * 37 + i; 559 return raw_hash; 560} 561 562/* 563 * Find a class using the defining loader of the current class 564 * and return a local reference to it. 565 */ 566static jclass load_class_local(context_type *context,const char *classname) 567{ 568 jclass cb = JVM_FindClassFromClass(context->env, classname, 569 JNI_FALSE, context->class); 570 if (cb == 0) 571 CCerror(context, "Cannot find class %s", classname); 572 return cb; 573} 574 575/* 576 * Find a class using the defining loader of the current class 577 * and return a global reference to it. 578 */ 579static jclass load_class_global(context_type *context, const char *classname) 580{ 581 JNIEnv *env = context->env; 582 jclass local, global; 583 584 local = load_class_local(context, classname); 585 global = (*env)->NewGlobalRef(env, local); 586 if (global == 0) 587 CCout_of_memory(context); 588#ifdef DEBUG 589 context->n_globalrefs++; 590#endif 591 (*env)->DeleteLocalRef(env, local); 592 return global; 593} 594 595/* 596 * Return a unique ID given a local class reference. The loadable 597 * flag is true if the defining class loader of context->class 598 * is known to be capable of loading the class. 599 */ 600static unsigned short 601class_to_ID(context_type *context, jclass cb, jboolean loadable) 602{ 603 JNIEnv *env = context->env; 604 hash_table_type *class_hash = &(context->class_hash); 605 unsigned int hash; 606 hash_bucket_type *bucket; 607 unsigned short *pID; 608 const char *name = JVM_GetClassNameUTF(env, cb); 609 610 check_and_push(context, name, VM_STRING_UTF); 611 hash = class_hash_fun(name); 612 pID = &(class_hash->table[hash % HASH_TABLE_SIZE]); 613 while (*pID) { 614 bucket = GET_BUCKET(class_hash, *pID); 615 if (bucket->hash == hash && strcmp(name, bucket->name) == 0) { 616 /* 617 * There is an unresolved entry with our name 618 * so we're forced to load it in case it matches us. 619 */ 620 if (bucket->class == 0) { 621 assert(bucket->loadable == JNI_TRUE); 622 bucket->class = load_class_global(context, name); 623 } 624 625 /* 626 * It's already in the table. Update the loadable 627 * state if it's known and then we're done. 628 */ 629 if ((*env)->IsSameObject(env, cb, bucket->class)) { 630 if (loadable && !bucket->loadable) 631 bucket->loadable = JNI_TRUE; 632 goto done; 633 } 634 } 635 pID = &bucket->next; 636 } 637 bucket = new_bucket(context, pID); 638 bucket->next = 0; 639 bucket->hash = hash; 640 bucket->name = malloc(strlen(name) + 1); 641 if (bucket->name == 0) 642 CCout_of_memory(context); 643 strcpy(bucket->name, name); 644 bucket->loadable = loadable; 645 bucket->class = (*env)->NewGlobalRef(env, cb); 646 if (bucket->class == 0) 647 CCout_of_memory(context); 648#ifdef DEBUG 649 context->n_globalrefs++; 650#endif 651 652done: 653 pop_and_free(context); 654 return *pID; 655} 656 657/* 658 * Return a unique ID given a class name from the constant pool. 659 * All classes are lazily loaded from the defining loader of 660 * context->class. 661 */ 662static unsigned short 663class_name_to_ID(context_type *context, const char *name) 664{ 665 hash_table_type *class_hash = &(context->class_hash); 666 unsigned int hash = class_hash_fun(name); 667 hash_bucket_type *bucket; 668 unsigned short *pID; 669 jboolean force_load = JNI_FALSE; 670 671 pID = &(class_hash->table[hash % HASH_TABLE_SIZE]); 672 while (*pID) { 673 bucket = GET_BUCKET(class_hash, *pID); 674 if (bucket->hash == hash && strcmp(name, bucket->name) == 0) { 675 if (bucket->loadable) 676 goto done; 677 force_load = JNI_TRUE; 678 } 679 pID = &bucket->next; 680 } 681 682 if (force_load) { 683 /* 684 * We found at least one matching named entry for a class that 685 * was not known to be loadable through the defining class loader 686 * of context->class. We must load our named class and update 687 * the hash table in case one these entries matches our class. 688 */ 689 JNIEnv *env = context->env; 690 jclass cb = load_class_local(context, name); 691 unsigned short id = class_to_ID(context, cb, JNI_TRUE); 692 (*env)->DeleteLocalRef(env, cb); 693 return id; 694 } 695 696 bucket = new_bucket(context, pID); 697 bucket->next = 0; 698 bucket->class = 0; 699 bucket->loadable = JNI_TRUE; /* name-only IDs are implicitly loadable */ 700 bucket->hash = hash; 701 bucket->name = malloc(strlen(name) + 1); 702 if (bucket->name == 0) 703 CCout_of_memory(context); 704 strcpy(bucket->name, name); 705 706done: 707 return *pID; 708} 709 710static const char * 711ID_to_class_name(context_type *context, unsigned short ID) 712{ 713 hash_table_type *class_hash = &(context->class_hash); 714 hash_bucket_type *bucket = GET_BUCKET(class_hash, ID); 715 return bucket->name; 716} 717 718static jclass 719ID_to_class(context_type *context, unsigned short ID) 720{ 721 hash_table_type *class_hash = &(context->class_hash); 722 hash_bucket_type *bucket = GET_BUCKET(class_hash, ID); 723 if (bucket->class == 0) { 724 assert(bucket->loadable == JNI_TRUE); 725 bucket->class = load_class_global(context, bucket->name); 726 } 727 return bucket->class; 728} 729 730static fullinfo_type 731make_loadable_class_info(context_type *context, jclass cb) 732{ 733 return MAKE_FULLINFO(ITEM_Object, 0, 734 class_to_ID(context, cb, JNI_TRUE)); 735} 736 737static fullinfo_type 738make_class_info(context_type *context, jclass cb) 739{ 740 return MAKE_FULLINFO(ITEM_Object, 0, 741 class_to_ID(context, cb, JNI_FALSE)); 742} 743 744static fullinfo_type 745make_class_info_from_name(context_type *context, const char *name) 746{ 747 return MAKE_FULLINFO(ITEM_Object, 0, 748 class_name_to_ID(context, name)); 749} 750 751/* RETURNS 752 * 1: on success chosen to be consistent with previous VerifyClass 753 * 0: verify error 754 * 2: out of memory 755 * 3: class format error 756 * 757 * Called by verify_class. Verify the code of each of the methods 758 * in a class. Note that this function apparently can't be JNICALL, 759 * because if it is the dynamic linker doesn't appear to be able to 760 * find it on Win32. 761 */ 762 763#define CC_OK 1 764#define CC_VerifyError 0 765#define CC_OutOfMemory 2 766#define CC_ClassFormatError 3 767 768JNIEXPORT jboolean 769VerifyClassForMajorVersion(JNIEnv *env, jclass cb, char *buffer, jint len, 770 jint major_version) 771{ 772 context_type context_structure; 773 context_type *context = &context_structure; 774 jboolean result = CC_OK; 775 int i; 776 int num_methods; 777 int* code_lengths; 778 unsigned char** code; 779 780#ifdef DEBUG 781 GlobalContext = context; 782#endif 783 784 memset(context, 0, sizeof(context_type)); 785 context->message = buffer; 786 context->message_buf_len = len; 787 788 context->env = env; 789 context->class = cb; 790 791 /* Set invalid method/field index of the context, in case anyone 792 calls CCerror */ 793 context->method_index = -1; 794 context->field_index = -1; 795 796 /* Don't call CCerror or anything that can call it above the setjmp! */ 797 if (!setjmp(context->jump_buffer)) { 798 jclass super; 799 800 CCinit(context); /* initialize heap; may throw */ 801 802 initialize_class_hash(context); 803 804 context->major_version = major_version; 805 context->nconstants = JVM_GetClassCPEntriesCount(env, cb); 806 context->constant_types = (unsigned char *) 807 malloc(sizeof(unsigned char) * context->nconstants + 1); 808 809 if (context->constant_types == 0) 810 CCout_of_memory(context); 811 812 JVM_GetClassCPTypes(env, cb, context->constant_types); 813 814 if (context->constant_types == 0) 815 CCout_of_memory(context); 816 817 context->object_info = 818 make_class_info_from_name(context, "java/lang/Object"); 819 context->string_info = 820 make_class_info_from_name(context, "java/lang/String"); 821 context->throwable_info = 822 make_class_info_from_name(context, "java/lang/Throwable"); 823 context->cloneable_info = 824 make_class_info_from_name(context, "java/lang/Cloneable"); 825 context->serializable_info = 826 make_class_info_from_name(context, "java/io/Serializable"); 827 828 context->currentclass_info = make_loadable_class_info(context, cb); 829 830 super = (*env)->GetSuperclass(env, cb); 831 832 if (super != 0) { 833 fullinfo_type *gptr; 834 int i = 0; 835 836 context->superclass_info = make_loadable_class_info(context, super); 837 838 while(super != 0) { 839 jclass tmp_cb = (*env)->GetSuperclass(env, super); 840 (*env)->DeleteLocalRef(env, super); 841 super = tmp_cb; 842 i++; 843 } 844 (*env)->DeleteLocalRef(env, super); 845 super = 0; 846 847 /* Can't go on context heap since it survives more than 848 one method */ 849 context->superclasses = gptr = 850 malloc(sizeof(fullinfo_type)*(i + 1)); 851 if (gptr == 0) { 852 CCout_of_memory(context); 853 } 854 855 super = (*env)->GetSuperclass(env, context->class); 856 while(super != 0) { 857 jclass tmp_cb; 858 *gptr++ = make_class_info(context, super); 859 tmp_cb = (*env)->GetSuperclass(env, super); 860 (*env)->DeleteLocalRef(env, super); 861 super = tmp_cb; 862 } 863 *gptr = 0; 864 } else { 865 context->superclass_info = 0; 866 } 867 868 (*env)->DeleteLocalRef(env, super); 869 870 /* Look at each method */ 871 for (i = JVM_GetClassFieldsCount(env, cb); --i >= 0;) 872 verify_field(context, cb, i); 873 num_methods = JVM_GetClassMethodsCount(env, cb); 874 read_all_code(context, cb, num_methods, &code_lengths, &code); 875 for (i = num_methods - 1; i >= 0; --i) 876 verify_method(context, cb, i, code_lengths[i], code[i]); 877 free_all_code(context, num_methods, code); 878 result = CC_OK; 879 } else { 880 result = context->err_code; 881 } 882 883 /* Cleanup */ 884 finalize_class_hash(context); 885 886 while(context->allocated_memory) 887 pop_and_free(context); 888 889#ifdef DEBUG 890 GlobalContext = 0; 891#endif 892 893 if (context->exceptions) 894 free(context->exceptions); 895 896 if (context->constant_types) 897 free(context->constant_types); 898 899 if (context->superclasses) 900 free(context->superclasses); 901 902#ifdef DEBUG 903 /* Make sure all global refs created in the verifier are freed */ 904 assert(context->n_globalrefs == 0); 905#endif 906 907 CCdestroy(context); /* destroy heap */ 908 return result; 909} 910 911#define OLD_FORMAT_MAX_MAJOR_VERSION 48 912 913JNIEXPORT jboolean 914VerifyClass(JNIEnv *env, jclass cb, char *buffer, jint len) 915{ 916 static int warned = 0; 917 if (!warned) { 918 jio_fprintf(stdout, "Warning! An old version of jvm is used. This is not supported.\n"); 919 warned = 1; 920 } 921 return VerifyClassForMajorVersion(env, cb, buffer, len, 922 OLD_FORMAT_MAX_MAJOR_VERSION); 923} 924 925static void 926verify_field(context_type *context, jclass cb, int field_index) 927{ 928 JNIEnv *env = context->env; 929 int access_bits = JVM_GetFieldIxModifiers(env, cb, field_index); 930 context->field_index = field_index; 931 932 if ( ((access_bits & JVM_ACC_PUBLIC) != 0) && 933 ((access_bits & (JVM_ACC_PRIVATE | JVM_ACC_PROTECTED)) != 0)) { 934 CCerror(context, "Inconsistent access bits."); 935 } 936 context->field_index = -1; 937} 938 939 940/** 941 * We read all of the class's methods' code because it is possible that 942 * the verification of one method could resulting in linking further 943 * down the stack (due to class loading), which could end up rewriting 944 * some of the bytecode of methods we haven't verified yet. Since we 945 * don't want to see the rewritten bytecode, cache all the code and 946 * operate only on that. 947 */ 948static void 949read_all_code(context_type* context, jclass cb, int num_methods, 950 int** lengths_addr, unsigned char*** code_addr) 951{ 952 int* lengths; 953 unsigned char** code; 954 int i; 955 956 lengths = malloc(sizeof(int) * num_methods); 957 check_and_push(context, lengths, VM_MALLOC_BLK); 958 959 code = malloc(sizeof(unsigned char*) * num_methods); 960 check_and_push(context, code, VM_MALLOC_BLK); 961 962 *(lengths_addr) = lengths; 963 *(code_addr) = code; 964 965 for (i = 0; i < num_methods; ++i) { 966 lengths[i] = JVM_GetMethodIxByteCodeLength(context->env, cb, i); 967 if (lengths[i] > 0) { 968 code[i] = malloc(sizeof(unsigned char) * (lengths[i] + 1)); 969 check_and_push(context, code[i], VM_MALLOC_BLK); 970 JVM_GetMethodIxByteCode(context->env, cb, i, code[i]); 971 } else { 972 code[i] = NULL; 973 } 974 } 975} 976 977static void 978free_all_code(context_type* context, int num_methods, unsigned char** code) 979{ 980 int i; 981 for (i = 0; i < num_methods; ++i) { 982 if (code[i] != NULL) { 983 pop_and_free(context); 984 } 985 } 986 pop_and_free(context); /* code */ 987 pop_and_free(context); /* lengths */ 988} 989 990/* Verify the code of one method */ 991static void 992verify_method(context_type *context, jclass cb, int method_index, 993 int code_length, unsigned char* code) 994{ 995 JNIEnv *env = context->env; 996 int access_bits = JVM_GetMethodIxModifiers(env, cb, method_index); 997 int *code_data; 998 instruction_data_type *idata = 0; 999 int instruction_count; 1000 int i, offset; 1001 unsigned int inumber; 1002 jint nexceptions; 1003 1004 if ((access_bits & (JVM_ACC_NATIVE | JVM_ACC_ABSTRACT)) != 0) { 1005 /* not much to do for abstract and native methods */ 1006 return; 1007 } 1008 1009 context->code_length = code_length; 1010 context->code = code; 1011 1012 /* CCerror can give method-specific info once this is set */ 1013 context->method_index = method_index; 1014 1015 CCreinit(context); /* initial heap */ 1016 code_data = NEW(int, code_length); 1017 1018#ifdef DEBUG 1019 if (verify_verbose) { 1020 const char *classname = JVM_GetClassNameUTF(env, cb); 1021 const char *methodname = 1022 JVM_GetMethodIxNameUTF(env, cb, method_index); 1023 const char *signature = 1024 JVM_GetMethodIxSignatureUTF(env, cb, method_index); 1025 jio_fprintf(stdout, "Looking at %s.%s%s\n", 1026 (classname ? classname : ""), 1027 (methodname ? methodname : ""), 1028 (signature ? signature : "")); 1029 JVM_ReleaseUTF(classname); 1030 JVM_ReleaseUTF(methodname); 1031 JVM_ReleaseUTF(signature); 1032 } 1033#endif 1034 1035 if (((access_bits & JVM_ACC_PUBLIC) != 0) && 1036 ((access_bits & (JVM_ACC_PRIVATE | JVM_ACC_PROTECTED)) != 0)) { 1037 CCerror(context, "Inconsistent access bits."); 1038 } 1039 1040 // If this method is an overpass method, which is generated by the VM, 1041 // we trust the code and no check needs to be done. 1042 if (JVM_IsVMGeneratedMethodIx(env, cb, method_index)) { 1043 return; 1044 } 1045 1046 /* Run through the code. Mark the start of each instruction, and give 1047 * the instruction a number */ 1048 for (i = 0, offset = 0; offset < code_length; i++) { 1049 int length = instruction_length(&code[offset], code + code_length); 1050 int next_offset = offset + length; 1051 if (length <= 0) 1052 CCerror(context, "Illegal instruction found at offset %d", offset); 1053 if (next_offset > code_length) 1054 CCerror(context, "Code stops in the middle of instruction " 1055 " starting at offset %d", offset); 1056 code_data[offset] = i; 1057 while (++offset < next_offset) 1058 code_data[offset] = -1; /* illegal location */ 1059 } 1060 instruction_count = i; /* number of instructions in code */ 1061 1062 /* Allocate a structure to hold info about each instruction. */ 1063 idata = NEW(instruction_data_type, instruction_count); 1064 1065 /* Initialize the heap, and other info in the context structure. */ 1066 context->code = code; 1067 context->instruction_data = idata; 1068 context->code_data = code_data; 1069 context->instruction_count = instruction_count; 1070 context->handler_info = 1071 NEW(struct handler_info_type, 1072 JVM_GetMethodIxExceptionTableLength(env, cb, method_index)); 1073 context->bitmask_size = 1074 (JVM_GetMethodIxLocalsCount(env, cb, method_index) 1075 + (BITS_PER_INT - 1))/BITS_PER_INT; 1076 1077 if (instruction_count == 0) 1078 CCerror(context, "Empty code"); 1079 1080 for (inumber = 0, offset = 0; offset < code_length; inumber++) { 1081 int length = instruction_length(&code[offset], code + code_length); 1082 instruction_data_type *this_idata = &idata[inumber]; 1083 this_idata->opcode = code[offset]; 1084 this_idata->stack_info.stack = NULL; 1085 this_idata->stack_info.stack_size = UNKNOWN_STACK_SIZE; 1086 this_idata->register_info.register_count = UNKNOWN_REGISTER_COUNT; 1087 this_idata->changed = JNI_FALSE; /* no need to look at it yet. */ 1088 this_idata->protected = JNI_FALSE; /* no need to look at it yet. */ 1089 this_idata->and_flags = (flag_type) -1; /* "bottom" and value */ 1090 this_idata->or_flags = 0; /* "bottom" or value*/ 1091 /* This also sets up this_data->operand. It also makes the 1092 * xload_x and xstore_x instructions look like the generic form. */ 1093 verify_opcode_operands(context, inumber, offset); 1094 offset += length; 1095 } 1096 1097 1098 /* make sure exception table is reasonable. */ 1099 initialize_exception_table(context); 1100 /* Set up first instruction, and start of exception handlers. */ 1101 initialize_dataflow(context); 1102 /* Run data flow analysis on the instructions. */ 1103 run_dataflow(context); 1104 1105 /* verify checked exceptions, if any */ 1106 nexceptions = JVM_GetMethodIxExceptionsCount(env, cb, method_index); 1107 context->exceptions = (unsigned short *) 1108 malloc(sizeof(unsigned short) * nexceptions + 1); 1109 if (context->exceptions == 0) 1110 CCout_of_memory(context); 1111 JVM_GetMethodIxExceptionIndexes(env, cb, method_index, 1112 context->exceptions); 1113 for (i = 0; i < nexceptions; i++) { 1114 /* Make sure the constant pool item is JVM_CONSTANT_Class */ 1115 verify_constant_pool_type(context, (int)context->exceptions[i], 1116 1 << JVM_CONSTANT_Class); 1117 } 1118 free(context->exceptions); 1119 context->exceptions = 0; 1120 context->code = 0; 1121 context->method_index = -1; 1122} 1123 1124 1125/* Look at a single instruction, and verify its operands. Also, for 1126 * simplicity, move the operand into the ->operand field. 1127 * Make sure that branches don't go into the middle of nowhere. 1128 */ 1129 1130static jint _ck_ntohl(jint n) 1131{ 1132 unsigned char *p = (unsigned char *)&n; 1133 return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]; 1134} 1135 1136static void 1137verify_opcode_operands(context_type *context, unsigned int inumber, int offset) 1138{ 1139 JNIEnv *env = context->env; 1140 instruction_data_type *idata = context->instruction_data; 1141 instruction_data_type *this_idata = &idata[inumber]; 1142 int *code_data = context->code_data; 1143 int mi = context->method_index; 1144 unsigned char *code = context->code; 1145 int opcode = this_idata->opcode; 1146 int var; 1147 1148 /* 1149 * Set the ip fields to 0 not the i fields because the ip fields 1150 * are 64 bits on 64 bit architectures, the i field is only 32 1151 */ 1152 this_idata->operand.ip = 0; 1153 this_idata->operand2.ip = 0; 1154 1155 switch (opcode) { 1156 1157 case JVM_OPC_jsr: 1158 /* instruction of ret statement */ 1159 this_idata->operand2.i = UNKNOWN_RET_INSTRUCTION; 1160 /* FALLTHROUGH */ 1161 case JVM_OPC_ifeq: case JVM_OPC_ifne: case JVM_OPC_iflt: 1162 case JVM_OPC_ifge: case JVM_OPC_ifgt: case JVM_OPC_ifle: 1163 case JVM_OPC_ifnull: case JVM_OPC_ifnonnull: 1164 case JVM_OPC_if_icmpeq: case JVM_OPC_if_icmpne: case JVM_OPC_if_icmplt: 1165 case JVM_OPC_if_icmpge: case JVM_OPC_if_icmpgt: case JVM_OPC_if_icmple: 1166 case JVM_OPC_if_acmpeq: case JVM_OPC_if_acmpne: 1167 case JVM_OPC_goto: { 1168 /* Set the ->operand to be the instruction number of the target. */ 1169 int jump = (((signed char)(code[offset+1])) << 8) + code[offset+2]; 1170 int target = offset + jump; 1171 if (!isLegalTarget(context, target)) 1172 CCerror(context, "Illegal target of jump or branch"); 1173 this_idata->operand.i = code_data[target]; 1174 break; 1175 } 1176 1177 case JVM_OPC_jsr_w: 1178 /* instruction of ret statement */ 1179 this_idata->operand2.i = UNKNOWN_RET_INSTRUCTION; 1180 /* FALLTHROUGH */ 1181 case JVM_OPC_goto_w: { 1182 /* Set the ->operand to be the instruction number of the target. */ 1183 int jump = (((signed char)(code[offset+1])) << 24) + 1184 (code[offset+2] << 16) + (code[offset+3] << 8) + 1185 (code[offset + 4]); 1186 int target = offset + jump; 1187 if (!isLegalTarget(context, target)) 1188 CCerror(context, "Illegal target of jump or branch"); 1189 this_idata->operand.i = code_data[target]; 1190 break; 1191 } 1192 1193 case JVM_OPC_tableswitch: 1194 case JVM_OPC_lookupswitch: { 1195 /* Set the ->operand to be a table of possible instruction targets. */ 1196 int *lpc = (int *) UCALIGN(code + offset + 1); 1197 int *lptr; 1198 int *saved_operand; 1199 int keys; 1200 int k, delta; 1201 1202 if (context->major_version < NONZERO_PADDING_BYTES_IN_SWITCH_MAJOR_VERSION) { 1203 /* 4639449, 4647081: Padding bytes must be zero. */ 1204 unsigned char* bptr = (unsigned char*) (code + offset + 1); 1205 for (; bptr < (unsigned char*)lpc; bptr++) { 1206 if (*bptr != 0) { 1207 CCerror(context, "Non zero padding bytes in switch"); 1208 } 1209 } 1210 } 1211 if (opcode == JVM_OPC_tableswitch) { 1212 keys = _ck_ntohl(lpc[2]) - _ck_ntohl(lpc[1]) + 1; 1213 delta = 1; 1214 } else { 1215 keys = _ck_ntohl(lpc[1]); /* number of pairs */ 1216 delta = 2; 1217 /* Make sure that the tableswitch items are sorted */ 1218 for (k = keys - 1, lptr = &lpc[2]; --k >= 0; lptr += 2) { 1219 int this_key = _ck_ntohl(lptr[0]); /* NB: ntohl may be unsigned */ 1220 int next_key = _ck_ntohl(lptr[2]); 1221 if (this_key >= next_key) { 1222 CCerror(context, "Unsorted lookup switch"); 1223 } 1224 } 1225 } 1226 saved_operand = NEW(int, keys + 2); 1227 if (!isLegalTarget(context, offset + _ck_ntohl(lpc[0]))) 1228 CCerror(context, "Illegal default target in switch"); 1229 saved_operand[keys + 1] = code_data[offset + _ck_ntohl(lpc[0])]; 1230 for (k = keys, lptr = &lpc[3]; --k >= 0; lptr += delta) { 1231 int target = offset + _ck_ntohl(lptr[0]); 1232 if (!isLegalTarget(context, target)) 1233 CCerror(context, "Illegal branch in tableswitch"); 1234 saved_operand[k + 1] = code_data[target]; 1235 } 1236 saved_operand[0] = keys + 1; /* number of successors */ 1237 this_idata->operand.ip = saved_operand; 1238 break; 1239 } 1240 1241 case JVM_OPC_ldc: { 1242 /* Make sure the constant pool item is the right type. */ 1243 int key = code[offset + 1]; 1244 int types = (1 << JVM_CONSTANT_Integer) | (1 << JVM_CONSTANT_Float) | 1245 (1 << JVM_CONSTANT_String); 1246 if (context->major_version >= LDC_CLASS_MAJOR_VERSION) { 1247 types |= 1 << JVM_CONSTANT_Class; 1248 } 1249 if (context->major_version >= LDC_METHOD_HANDLE_MAJOR_VERSION) { 1250 types |= (1 << JVM_CONSTANT_MethodHandle) | 1251 (1 << JVM_CONSTANT_MethodType); 1252 } 1253 this_idata->operand.i = key; 1254 verify_constant_pool_type(context, key, types); 1255 break; 1256 } 1257 1258 case JVM_OPC_ldc_w: { 1259 /* Make sure the constant pool item is the right type. */ 1260 int key = (code[offset + 1] << 8) + code[offset + 2]; 1261 int types = (1 << JVM_CONSTANT_Integer) | (1 << JVM_CONSTANT_Float) | 1262 (1 << JVM_CONSTANT_String); 1263 if (context->major_version >= LDC_CLASS_MAJOR_VERSION) { 1264 types |= 1 << JVM_CONSTANT_Class; 1265 } 1266 if (context->major_version >= LDC_METHOD_HANDLE_MAJOR_VERSION) { 1267 types |= (1 << JVM_CONSTANT_MethodHandle) | 1268 (1 << JVM_CONSTANT_MethodType); 1269 } 1270 this_idata->operand.i = key; 1271 verify_constant_pool_type(context, key, types); 1272 break; 1273 } 1274 1275 case JVM_OPC_ldc2_w: { 1276 /* Make sure the constant pool item is the right type. */ 1277 int key = (code[offset + 1] << 8) + code[offset + 2]; 1278 int types = (1 << JVM_CONSTANT_Double) | (1 << JVM_CONSTANT_Long); 1279 this_idata->operand.i = key; 1280 verify_constant_pool_type(context, key, types); 1281 break; 1282 } 1283 1284 case JVM_OPC_getfield: case JVM_OPC_putfield: 1285 case JVM_OPC_getstatic: case JVM_OPC_putstatic: { 1286 /* Make sure the constant pool item is the right type. */ 1287 int key = (code[offset + 1] << 8) + code[offset + 2]; 1288 this_idata->operand.i = key; 1289 verify_constant_pool_type(context, key, 1 << JVM_CONSTANT_Fieldref); 1290 if (opcode == JVM_OPC_getfield || opcode == JVM_OPC_putfield) 1291 set_protected(context, inumber, key, opcode); 1292 break; 1293 } 1294 1295 case JVM_OPC_invokevirtual: 1296 case JVM_OPC_invokespecial: 1297 case JVM_OPC_invokestatic: 1298 case JVM_OPC_invokeinterface: { 1299 /* Make sure the constant pool item is the right type. */ 1300 int key = (code[offset + 1] << 8) + code[offset + 2]; 1301 const char *methodname; 1302 jclass cb = context->class; 1303 fullinfo_type clazz_info; 1304 int is_constructor, is_internal; 1305 int kind; 1306 1307 switch (opcode ) { 1308 case JVM_OPC_invokestatic: 1309 kind = ((context->major_version < STATIC_METHOD_IN_INTERFACE_MAJOR_VERSION) 1310 ? (1 << JVM_CONSTANT_Methodref) 1311 : ((1 << JVM_CONSTANT_InterfaceMethodref) | (1 << JVM_CONSTANT_Methodref))); 1312 break; 1313 case JVM_OPC_invokeinterface: 1314 kind = 1 << JVM_CONSTANT_InterfaceMethodref; 1315 break; 1316 default: 1317 kind = 1 << JVM_CONSTANT_Methodref; 1318 } 1319 1320 /* Make sure the constant pool item is the right type. */ 1321 verify_constant_pool_type(context, key, kind); 1322 methodname = JVM_GetCPMethodNameUTF(env, cb, key); 1323 check_and_push(context, methodname, VM_STRING_UTF); 1324 is_constructor = !strcmp(methodname, "<init>"); 1325 is_internal = methodname[0] == '<'; 1326 pop_and_free(context); 1327 1328 clazz_info = cp_index_to_class_fullinfo(context, key, 1329 JVM_CONSTANT_Methodref); 1330 this_idata->operand.i = key; 1331 this_idata->operand2.fi = clazz_info; 1332 if (is_constructor) { 1333 if (opcode != JVM_OPC_invokespecial) { 1334 CCerror(context, 1335 "Must call initializers using invokespecial"); 1336 } 1337 this_idata->opcode = JVM_OPC_invokeinit; 1338 } else { 1339 if (is_internal) { 1340 CCerror(context, "Illegal call to internal method"); 1341 } 1342 if (opcode == JVM_OPC_invokespecial 1343 && clazz_info != context->currentclass_info 1344 && clazz_info != context->superclass_info) { 1345 int not_found = 1; 1346 1347 jclass super = (*env)->GetSuperclass(env, context->class); 1348 while(super != 0) { 1349 jclass tmp_cb; 1350 fullinfo_type new_info = make_class_info(context, super); 1351 if (clazz_info == new_info) { 1352 not_found = 0; 1353 break; 1354 } 1355 tmp_cb = (*env)->GetSuperclass(env, super); 1356 (*env)->DeleteLocalRef(env, super); 1357 super = tmp_cb; 1358 } 1359 (*env)->DeleteLocalRef(env, super); 1360 1361 /* The optimizer may cause this to happen on local code */ 1362 if (not_found) { 1363 CCerror(context, "Illegal use of nonvirtual function call"); 1364 } 1365 } 1366 } 1367 if (opcode == JVM_OPC_invokeinterface) { 1368 unsigned int args1; 1369 unsigned int args2; 1370 const char *signature = 1371 JVM_GetCPMethodSignatureUTF(env, context->class, key); 1372 check_and_push(context, signature, VM_STRING_UTF); 1373 args1 = signature_to_args_size(signature) + 1; 1374 args2 = code[offset + 3]; 1375 if (args1 != args2) { 1376 CCerror(context, 1377 "Inconsistent args_size for invokeinterface"); 1378 } 1379 if (code[offset + 4] != 0) { 1380 CCerror(context, 1381 "Fourth operand byte of invokeinterface must be zero"); 1382 } 1383 pop_and_free(context); 1384 } else if (opcode == JVM_OPC_invokevirtual 1385 || opcode == JVM_OPC_invokespecial) 1386 set_protected(context, inumber, key, opcode); 1387 break; 1388 } 1389 1390 case JVM_OPC_invokedynamic: 1391 CCerror(context, 1392 "invokedynamic bytecode is not supported in this class file version"); 1393 1394 case JVM_OPC_instanceof: 1395 case JVM_OPC_checkcast: 1396 case JVM_OPC_new: 1397 case JVM_OPC_anewarray: 1398 case JVM_OPC_multianewarray: { 1399 /* Make sure the constant pool item is a class */ 1400 int key = (code[offset + 1] << 8) + code[offset + 2]; 1401 fullinfo_type target; 1402 verify_constant_pool_type(context, key, 1 << JVM_CONSTANT_Class); 1403 target = cp_index_to_class_fullinfo(context, key, JVM_CONSTANT_Class); 1404 if (GET_ITEM_TYPE(target) == ITEM_Bogus) 1405 CCerror(context, "Illegal type"); 1406 switch(opcode) { 1407 case JVM_OPC_anewarray: 1408 if ((GET_INDIRECTION(target)) >= MAX_ARRAY_DIMENSIONS) 1409 CCerror(context, "Array with too many dimensions"); 1410 this_idata->operand.fi = MAKE_FULLINFO(GET_ITEM_TYPE(target), 1411 GET_INDIRECTION(target) + 1, 1412 GET_EXTRA_INFO(target)); 1413 break; 1414 case JVM_OPC_new: 1415 if (WITH_ZERO_EXTRA_INFO(target) != 1416 MAKE_FULLINFO(ITEM_Object, 0, 0)) 1417 CCerror(context, "Illegal creation of multi-dimensional array"); 1418 /* operand gets set to the "unitialized object". operand2 gets 1419 * set to what the value will be after it's initialized. */ 1420 this_idata->operand.fi = MAKE_FULLINFO(ITEM_NewObject, 0, inumber); 1421 this_idata->operand2.fi = target; 1422 break; 1423 case JVM_OPC_multianewarray: 1424 this_idata->operand.fi = target; 1425 this_idata->operand2.i = code[offset + 3]; 1426 if ( (this_idata->operand2.i > (int)GET_INDIRECTION(target)) 1427 || (this_idata->operand2.i == 0)) 1428 CCerror(context, "Illegal dimension argument"); 1429 break; 1430 default: 1431 this_idata->operand.fi = target; 1432 } 1433 break; 1434 } 1435 1436 case JVM_OPC_newarray: { 1437 /* Cache the result of the JVM_OPC_newarray into the operand slot */ 1438 fullinfo_type full_info; 1439 switch (code[offset + 1]) { 1440 case JVM_T_INT: 1441 full_info = MAKE_FULLINFO(ITEM_Integer, 1, 0); break; 1442 case JVM_T_LONG: 1443 full_info = MAKE_FULLINFO(ITEM_Long, 1, 0); break; 1444 case JVM_T_FLOAT: 1445 full_info = MAKE_FULLINFO(ITEM_Float, 1, 0); break; 1446 case JVM_T_DOUBLE: 1447 full_info = MAKE_FULLINFO(ITEM_Double, 1, 0); break; 1448 case JVM_T_BOOLEAN: 1449 full_info = MAKE_FULLINFO(ITEM_Boolean, 1, 0); break; 1450 case JVM_T_BYTE: 1451 full_info = MAKE_FULLINFO(ITEM_Byte, 1, 0); break; 1452 case JVM_T_CHAR: 1453 full_info = MAKE_FULLINFO(ITEM_Char, 1, 0); break; 1454 case JVM_T_SHORT: 1455 full_info = MAKE_FULLINFO(ITEM_Short, 1, 0); break; 1456 default: 1457 full_info = 0; /* Keep lint happy */ 1458 CCerror(context, "Bad type passed to newarray"); 1459 } 1460 this_idata->operand.fi = full_info; 1461 break; 1462 } 1463 1464 /* Fudge iload_x, aload_x, etc to look like their generic cousin. */ 1465 case JVM_OPC_iload_0: case JVM_OPC_iload_1: case JVM_OPC_iload_2: case JVM_OPC_iload_3: 1466 this_idata->opcode = JVM_OPC_iload; 1467 var = opcode - JVM_OPC_iload_0; 1468 goto check_local_variable; 1469 1470 case JVM_OPC_fload_0: case JVM_OPC_fload_1: case JVM_OPC_fload_2: case JVM_OPC_fload_3: 1471 this_idata->opcode = JVM_OPC_fload; 1472 var = opcode - JVM_OPC_fload_0; 1473 goto check_local_variable; 1474 1475 case JVM_OPC_aload_0: case JVM_OPC_aload_1: case JVM_OPC_aload_2: case JVM_OPC_aload_3: 1476 this_idata->opcode = JVM_OPC_aload; 1477 var = opcode - JVM_OPC_aload_0; 1478 goto check_local_variable; 1479 1480 case JVM_OPC_lload_0: case JVM_OPC_lload_1: case JVM_OPC_lload_2: case JVM_OPC_lload_3: 1481 this_idata->opcode = JVM_OPC_lload; 1482 var = opcode - JVM_OPC_lload_0; 1483 goto check_local_variable2; 1484 1485 case JVM_OPC_dload_0: case JVM_OPC_dload_1: case JVM_OPC_dload_2: case JVM_OPC_dload_3: 1486 this_idata->opcode = JVM_OPC_dload; 1487 var = opcode - JVM_OPC_dload_0; 1488 goto check_local_variable2; 1489 1490 case JVM_OPC_istore_0: case JVM_OPC_istore_1: case JVM_OPC_istore_2: case JVM_OPC_istore_3: 1491 this_idata->opcode = JVM_OPC_istore; 1492 var = opcode - JVM_OPC_istore_0; 1493 goto check_local_variable; 1494 1495 case JVM_OPC_fstore_0: case JVM_OPC_fstore_1: case JVM_OPC_fstore_2: case JVM_OPC_fstore_3: 1496 this_idata->opcode = JVM_OPC_fstore; 1497 var = opcode - JVM_OPC_fstore_0; 1498 goto check_local_variable; 1499 1500 case JVM_OPC_astore_0: case JVM_OPC_astore_1: case JVM_OPC_astore_2: case JVM_OPC_astore_3: 1501 this_idata->opcode = JVM_OPC_astore; 1502 var = opcode - JVM_OPC_astore_0; 1503 goto check_local_variable; 1504 1505 case JVM_OPC_lstore_0: case JVM_OPC_lstore_1: case JVM_OPC_lstore_2: case JVM_OPC_lstore_3: 1506 this_idata->opcode = JVM_OPC_lstore; 1507 var = opcode - JVM_OPC_lstore_0; 1508 goto check_local_variable2; 1509 1510 case JVM_OPC_dstore_0: case JVM_OPC_dstore_1: case JVM_OPC_dstore_2: case JVM_OPC_dstore_3: 1511 this_idata->opcode = JVM_OPC_dstore; 1512 var = opcode - JVM_OPC_dstore_0; 1513 goto check_local_variable2; 1514 1515 case JVM_OPC_wide: 1516 this_idata->opcode = code[offset + 1]; 1517 var = (code[offset + 2] << 8) + code[offset + 3]; 1518 switch(this_idata->opcode) { 1519 case JVM_OPC_lload: case JVM_OPC_dload: 1520 case JVM_OPC_lstore: case JVM_OPC_dstore: 1521 goto check_local_variable2; 1522 default: 1523 goto check_local_variable; 1524 } 1525 1526 case JVM_OPC_iinc: /* the increment amount doesn't matter */ 1527 case JVM_OPC_ret: 1528 case JVM_OPC_aload: case JVM_OPC_iload: case JVM_OPC_fload: 1529 case JVM_OPC_astore: case JVM_OPC_istore: case JVM_OPC_fstore: 1530 var = code[offset + 1]; 1531 check_local_variable: 1532 /* Make sure that the variable number isn't illegal. */ 1533 this_idata->operand.i = var; 1534 if (var >= JVM_GetMethodIxLocalsCount(env, context->class, mi)) 1535 CCerror(context, "Illegal local variable number"); 1536 break; 1537 1538 case JVM_OPC_lload: case JVM_OPC_dload: case JVM_OPC_lstore: case JVM_OPC_dstore: 1539 var = code[offset + 1]; 1540 check_local_variable2: 1541 /* Make sure that the variable number isn't illegal. */ 1542 this_idata->operand.i = var; 1543 if ((var + 1) >= JVM_GetMethodIxLocalsCount(env, context->class, mi)) 1544 CCerror(context, "Illegal local variable number"); 1545 break; 1546 1547 default: 1548 if (opcode > JVM_OPC_MAX) 1549 CCerror(context, "Quick instructions shouldn't appear yet."); 1550 break; 1551 } /* of switch */ 1552} 1553 1554 1555static void 1556set_protected(context_type *context, unsigned int inumber, int key, int opcode) 1557{ 1558 JNIEnv *env = context->env; 1559 fullinfo_type clazz_info; 1560 if (opcode != JVM_OPC_invokevirtual && opcode != JVM_OPC_invokespecial) { 1561 clazz_info = cp_index_to_class_fullinfo(context, key, 1562 JVM_CONSTANT_Fieldref); 1563 } else { 1564 clazz_info = cp_index_to_class_fullinfo(context, key, 1565 JVM_CONSTANT_Methodref); 1566 } 1567 if (is_superclass(context, clazz_info)) { 1568 jclass calledClass = 1569 object_fullinfo_to_classclass(context, clazz_info); 1570 int access; 1571 /* 4734966: JVM_GetCPFieldModifiers() or JVM_GetCPMethodModifiers() only 1572 searches the referenced field or method in calledClass. The following 1573 while loop is added to search up the superclass chain to make this 1574 symbolic resolution consistent with the field/method resolution 1575 specified in VM spec 5.4.3. */ 1576 calledClass = (*env)->NewLocalRef(env, calledClass); 1577 do { 1578 jclass tmp_cb; 1579 if (opcode != JVM_OPC_invokevirtual && opcode != JVM_OPC_invokespecial) { 1580 access = JVM_GetCPFieldModifiers 1581 (env, context->class, key, calledClass); 1582 } else { 1583 access = JVM_GetCPMethodModifiers 1584 (env, context->class, key, calledClass); 1585 } 1586 if (access != -1) { 1587 break; 1588 } 1589 tmp_cb = (*env)->GetSuperclass(env, calledClass); 1590 (*env)->DeleteLocalRef(env, calledClass); 1591 calledClass = tmp_cb; 1592 } while (calledClass != 0); 1593 1594 if (access == -1) { 1595 /* field/method not found, detected at runtime. */ 1596 } else if (access & JVM_ACC_PROTECTED) { 1597 if (!JVM_IsSameClassPackage(env, calledClass, context->class)) 1598 context->instruction_data[inumber].protected = JNI_TRUE; 1599 } 1600 (*env)->DeleteLocalRef(env, calledClass); 1601 } 1602} 1603 1604 1605static jboolean 1606is_superclass(context_type *context, fullinfo_type clazz_info) { 1607 fullinfo_type *fptr = context->superclasses; 1608 1609 if (fptr == 0) 1610 return JNI_FALSE; 1611 for (; *fptr != 0; fptr++) { 1612 if (*fptr == clazz_info) 1613 return JNI_TRUE; 1614 } 1615 return JNI_FALSE; 1616} 1617 1618 1619/* Look through each item on the exception table. Each of the fields must 1620 * refer to a legal instruction. 1621 */ 1622static void 1623initialize_exception_table(context_type *context) 1624{ 1625 JNIEnv *env = context->env; 1626 int mi = context->method_index; 1627 struct handler_info_type *handler_info = context->handler_info; 1628 int *code_data = context->code_data; 1629 int code_length = context->code_length; 1630 int max_stack_size = JVM_GetMethodIxMaxStack(env, context->class, mi); 1631 int i = JVM_GetMethodIxExceptionTableLength(env, context->class, mi); 1632 if (max_stack_size < 1 && i > 0) { 1633 // If the method contains exception handlers, it must have room 1634 // on the expression stack for the exception that the VM could push 1635 CCerror(context, "Stack size too large"); 1636 } 1637 for (; --i >= 0; handler_info++) { 1638 JVM_ExceptionTableEntryType einfo; 1639 stack_item_type *stack_item = NEW(stack_item_type, 1); 1640 1641 JVM_GetMethodIxExceptionTableEntry(env, context->class, mi, 1642 i, &einfo); 1643 1644 if (!(einfo.start_pc < einfo.end_pc && 1645 einfo.start_pc >= 0 && 1646 isLegalTarget(context, einfo.start_pc) && 1647 (einfo.end_pc == code_length || 1648 isLegalTarget(context, einfo.end_pc)))) { 1649 CFerror(context, "Illegal exception table range"); 1650 } 1651 if (!((einfo.handler_pc > 0) && 1652 isLegalTarget(context, einfo.handler_pc))) { 1653 CFerror(context, "Illegal exception table handler"); 1654 } 1655 1656 handler_info->start = code_data[einfo.start_pc]; 1657 /* einfo.end_pc may point to one byte beyond the end of bytecodes. */ 1658 handler_info->end = (einfo.end_pc == context->code_length) ? 1659 context->instruction_count : code_data[einfo.end_pc]; 1660 handler_info->handler = code_data[einfo.handler_pc]; 1661 handler_info->stack_info.stack = stack_item; 1662 handler_info->stack_info.stack_size = 1; 1663 stack_item->next = NULL; 1664 if (einfo.catchType != 0) { 1665 const char *classname; 1666 /* Constant pool entry type has been checked in format checker */ 1667 classname = JVM_GetCPClassNameUTF(env, 1668 context->class, 1669 einfo.catchType); 1670 check_and_push(context, classname, VM_STRING_UTF); 1671 stack_item->item = make_class_info_from_name(context, classname); 1672 if (!isAssignableTo(context, 1673 stack_item->item, 1674 context->throwable_info)) 1675 CCerror(context, "catch_type not a subclass of Throwable"); 1676 pop_and_free(context); 1677 } else { 1678 stack_item->item = context->throwable_info; 1679 } 1680 } 1681} 1682 1683 1684/* Given a pointer to an instruction, return its length. Use the table 1685 * opcode_length[] which is automatically built. 1686 */ 1687static int instruction_length(unsigned char *iptr, unsigned char *end) 1688{ 1689 static unsigned char opcode_length[] = JVM_OPCODE_LENGTH_INITIALIZER; 1690 int instruction = *iptr; 1691 switch (instruction) { 1692 case JVM_OPC_tableswitch: { 1693 int *lpc = (int *)UCALIGN(iptr + 1); 1694 int index; 1695 if (lpc + 2 >= (int *)end) { 1696 return -1; /* do not read pass the end */ 1697 } 1698 index = _ck_ntohl(lpc[2]) - _ck_ntohl(lpc[1]); 1699 if ((index < 0) || (index > 65535)) { 1700 return -1; /* illegal */ 1701 } else { 1702 return (unsigned char *)(&lpc[index + 4]) - iptr; 1703 } 1704 } 1705 1706 case JVM_OPC_lookupswitch: { 1707 int *lpc = (int *) UCALIGN(iptr + 1); 1708 int npairs; 1709 if (lpc + 1 >= (int *)end) 1710 return -1; /* do not read pass the end */ 1711 npairs = _ck_ntohl(lpc[1]); 1712 /* There can't be more than 64K labels because of the limit 1713 * on per-method byte code length. 1714 */ 1715 if (npairs < 0 || npairs >= 65536) 1716 return -1; 1717 else 1718 return (unsigned char *)(&lpc[2 * (npairs + 1)]) - iptr; 1719 } 1720 1721 case JVM_OPC_wide: 1722 if (iptr + 1 >= end) 1723 return -1; /* do not read pass the end */ 1724 switch(iptr[1]) { 1725 case JVM_OPC_ret: 1726 case JVM_OPC_iload: case JVM_OPC_istore: 1727 case JVM_OPC_fload: case JVM_OPC_fstore: 1728 case JVM_OPC_aload: case JVM_OPC_astore: 1729 case JVM_OPC_lload: case JVM_OPC_lstore: 1730 case JVM_OPC_dload: case JVM_OPC_dstore: 1731 return 4; 1732 case JVM_OPC_iinc: 1733 return 6; 1734 default: 1735 return -1; 1736 } 1737 1738 default: { 1739 if (instruction < 0 || instruction > JVM_OPC_MAX) 1740 return -1; 1741 1742 /* A length of 0 indicates an error. */ 1743 if (opcode_length[instruction] <= 0) 1744 return -1; 1745 1746 return opcode_length[instruction]; 1747 } 1748 } 1749} 1750 1751 1752/* Given the target of a branch, make sure that it's a legal target. */ 1753static jboolean 1754isLegalTarget(context_type *context, int offset) 1755{ 1756 int code_length = context->code_length; 1757 int *code_data = context->code_data; 1758 return (offset >= 0 && offset < code_length && code_data[offset] >= 0); 1759} 1760 1761 1762/* Make sure that an element of the constant pool really is of the indicated 1763 * type. 1764 */ 1765static void 1766verify_constant_pool_type(context_type *context, int index, unsigned mask) 1767{ 1768 int nconstants = context->nconstants; 1769 unsigned char *type_table = context->constant_types; 1770 unsigned type; 1771 1772 if ((index <= 0) || (index >= nconstants)) 1773 CCerror(context, "Illegal constant pool index"); 1774 1775 type = type_table[index]; 1776 if ((mask & (1 << type)) == 0) 1777 CCerror(context, "Illegal type in constant pool"); 1778} 1779 1780 1781static void 1782initialize_dataflow(context_type *context) 1783{ 1784 JNIEnv *env = context->env; 1785 instruction_data_type *idata = context->instruction_data; 1786 int mi = context->method_index; 1787 jclass cb = context->class; 1788 int args_size = JVM_GetMethodIxArgsSize(env, cb, mi); 1789 fullinfo_type *reg_ptr; 1790 fullinfo_type full_info; 1791 const char *p; 1792 const char *signature; 1793 1794 /* Initialize the function entry, since we know everything about it. */ 1795 idata[0].stack_info.stack_size = 0; 1796 idata[0].stack_info.stack = NULL; 1797 idata[0].register_info.register_count = args_size; 1798 idata[0].register_info.registers = NEW(fullinfo_type, args_size); 1799 idata[0].register_info.mask_count = 0; 1800 idata[0].register_info.masks = NULL; 1801 idata[0].and_flags = 0; /* nothing needed */ 1802 idata[0].or_flags = FLAG_REACHED; /* instruction reached */ 1803 reg_ptr = idata[0].register_info.registers; 1804 1805 if ((JVM_GetMethodIxModifiers(env, cb, mi) & JVM_ACC_STATIC) == 0) { 1806 /* A non static method. If this is an <init> method, the first 1807 * argument is an uninitialized object. Otherwise it is an object of 1808 * the given class type. java.lang.Object.<init> is special since 1809 * we don't call its superclass <init> method. 1810 */ 1811 if (JVM_IsConstructorIx(env, cb, mi) 1812 && context->currentclass_info != context->object_info) { 1813 *reg_ptr++ = MAKE_FULLINFO(ITEM_InitObject, 0, 0); 1814 idata[0].or_flags |= FLAG_NEED_CONSTRUCTOR; 1815 } else { 1816 *reg_ptr++ = context->currentclass_info; 1817 } 1818 } 1819 signature = JVM_GetMethodIxSignatureUTF(env, cb, mi); 1820 check_and_push(context, signature, VM_STRING_UTF); 1821 /* Fill in each of the arguments into the registers. */ 1822 for (p = signature + 1; *p != JVM_SIGNATURE_ENDFUNC; ) { 1823 char fieldchar = signature_to_fieldtype(context, &p, &full_info); 1824 switch (fieldchar) { 1825 case 'D': case 'L': 1826 *reg_ptr++ = full_info; 1827 *reg_ptr++ = full_info + 1; 1828 break; 1829 default: 1830 *reg_ptr++ = full_info; 1831 break; 1832 } 1833 } 1834 p++; /* skip over right parenthesis */ 1835 if (*p == 'V') { 1836 context->return_type = MAKE_FULLINFO(ITEM_Void, 0, 0); 1837 } else { 1838 signature_to_fieldtype(context, &p, &full_info); 1839 context->return_type = full_info; 1840 } 1841 pop_and_free(context); 1842 /* Indicate that we need to look at the first instruction. */ 1843 idata[0].changed = JNI_TRUE; 1844} 1845 1846 1847/* Run the data flow analysis, as long as there are things to change. */ 1848static void 1849run_dataflow(context_type *context) { 1850 JNIEnv *env = context->env; 1851 int mi = context->method_index; 1852 jclass cb = context->class; 1853 int max_stack_size = JVM_GetMethodIxMaxStack(env, cb, mi); 1854 instruction_data_type *idata = context->instruction_data; 1855 unsigned int icount = context->instruction_count; 1856 jboolean work_to_do = JNI_TRUE; 1857 unsigned int inumber; 1858 1859 /* Run through the loop, until there is nothing left to do. */ 1860 while (work_to_do) { 1861 work_to_do = JNI_FALSE; 1862 for (inumber = 0; inumber < icount; inumber++) { 1863 instruction_data_type *this_idata = &idata[inumber]; 1864 if (this_idata->changed) { 1865 register_info_type new_register_info; 1866 stack_info_type new_stack_info; 1867 flag_type new_and_flags, new_or_flags; 1868 1869 this_idata->changed = JNI_FALSE; 1870 work_to_do = JNI_TRUE; 1871#ifdef DEBUG 1872 if (verify_verbose) { 1873 int opcode = this_idata->opcode; 1874 jio_fprintf(stdout, "Instruction %d: ", inumber); 1875 print_stack(context, &this_idata->stack_info); 1876 print_registers(context, &this_idata->register_info); 1877 print_flags(context, 1878 this_idata->and_flags, this_idata->or_flags); 1879 fflush(stdout); 1880 } 1881#endif 1882 /* Make sure the registers and flags are appropriate */ 1883 check_register_values(context, inumber); 1884 check_flags(context, inumber); 1885 1886 /* Make sure the stack can deal with this instruction */ 1887 pop_stack(context, inumber, &new_stack_info); 1888 1889 /* Update the registers and flags */ 1890 update_registers(context, inumber, &new_register_info); 1891 update_flags(context, inumber, &new_and_flags, &new_or_flags); 1892 1893 /* Update the stack. */ 1894 push_stack(context, inumber, &new_stack_info); 1895 1896 if (new_stack_info.stack_size > max_stack_size) 1897 CCerror(context, "Stack size too large"); 1898#ifdef DEBUG 1899 if (verify_verbose) { 1900 jio_fprintf(stdout, " "); 1901 print_stack(context, &new_stack_info); 1902 print_registers(context, &new_register_info); 1903 print_flags(context, new_and_flags, new_or_flags); 1904 fflush(stdout); 1905 } 1906#endif 1907 /* Add the new stack and register information to any 1908 * instructions that can follow this instruction. */ 1909 merge_into_successors(context, inumber, 1910 &new_register_info, &new_stack_info, 1911 new_and_flags, new_or_flags); 1912 } 1913 } 1914 } 1915} 1916 1917 1918/* Make sure that the registers contain a legitimate value for the given 1919 * instruction. 1920*/ 1921 1922static void 1923check_register_values(context_type *context, unsigned int inumber) 1924{ 1925 instruction_data_type *idata = context->instruction_data; 1926 instruction_data_type *this_idata = &idata[inumber]; 1927 int opcode = this_idata->opcode; 1928 int operand = this_idata->operand.i; 1929 int register_count = this_idata->register_info.register_count; 1930 fullinfo_type *registers = this_idata->register_info.registers; 1931 jboolean double_word = JNI_FALSE; /* default value */ 1932 int type; 1933 1934 switch (opcode) { 1935 default: 1936 return; 1937 case JVM_OPC_iload: case JVM_OPC_iinc: 1938 type = ITEM_Integer; break; 1939 case JVM_OPC_fload: 1940 type = ITEM_Float; break; 1941 case JVM_OPC_aload: 1942 type = ITEM_Object; break; 1943 case JVM_OPC_ret: 1944 type = ITEM_ReturnAddress; break; 1945 case JVM_OPC_lload: 1946 type = ITEM_Long; double_word = JNI_TRUE; break; 1947 case JVM_OPC_dload: 1948 type = ITEM_Double; double_word = JNI_TRUE; break; 1949 } 1950 if (!double_word) { 1951 fullinfo_type reg; 1952 /* Make sure we don't have an illegal register or one with wrong type */ 1953 if (operand >= register_count) { 1954 CCerror(context, 1955 "Accessing value from uninitialized register %d", operand); 1956 } 1957 reg = registers[operand]; 1958 1959 if (WITH_ZERO_EXTRA_INFO(reg) == (unsigned)MAKE_FULLINFO(type, 0, 0)) { 1960 /* the register is obviously of the given type */ 1961 return; 1962 } else if (GET_INDIRECTION(reg) > 0 && type == ITEM_Object) { 1963 /* address type stuff be used on all arrays */ 1964 return; 1965 } else if (GET_ITEM_TYPE(reg) == ITEM_ReturnAddress) { 1966 CCerror(context, "Cannot load return address from register %d", 1967 operand); 1968 /* alternatively 1969 (GET_ITEM_TYPE(reg) == ITEM_ReturnAddress) 1970 && (opcode == JVM_OPC_iload) 1971 && (type == ITEM_Object || type == ITEM_Integer) 1972 but this never occurs 1973 */ 1974 } else if (reg == ITEM_InitObject && type == ITEM_Object) { 1975 return; 1976 } else if (WITH_ZERO_EXTRA_INFO(reg) == 1977 MAKE_FULLINFO(ITEM_NewObject, 0, 0) && 1978 type == ITEM_Object) { 1979 return; 1980 } else { 1981 CCerror(context, "Register %d contains wrong type", operand); 1982 } 1983 } else { 1984 /* Make sure we don't have an illegal register or one with wrong type */ 1985 if ((operand + 1) >= register_count) { 1986 CCerror(context, 1987 "Accessing value from uninitialized register pair %d/%d", 1988 operand, operand+1); 1989 } else { 1990 if ((registers[operand] == (unsigned)MAKE_FULLINFO(type, 0, 0)) && 1991 (registers[operand + 1] == (unsigned)MAKE_FULLINFO(type + 1, 0, 0))) { 1992 return; 1993 } else { 1994 CCerror(context, "Register pair %d/%d contains wrong type", 1995 operand, operand+1); 1996 } 1997 } 1998 } 1999} 2000 2001 2002/* Make sure the flags contain legitimate values for this instruction. 2003*/ 2004 2005static void 2006check_flags(context_type *context, unsigned int inumber) 2007{ 2008 instruction_data_type *idata = context->instruction_data; 2009 instruction_data_type *this_idata = &idata[inumber]; 2010 int opcode = this_idata->opcode; 2011 switch (opcode) { 2012 case JVM_OPC_return: 2013 /* We need a constructor, but we aren't guaranteed it's called */ 2014 if ((this_idata->or_flags & FLAG_NEED_CONSTRUCTOR) && 2015 !(this_idata->and_flags & FLAG_CONSTRUCTED)) 2016 CCerror(context, "Constructor must call super() or this()"); 2017 /* fall through */ 2018 case JVM_OPC_ireturn: case JVM_OPC_lreturn: 2019 case JVM_OPC_freturn: case JVM_OPC_dreturn: case JVM_OPC_areturn: 2020 if (this_idata->or_flags & FLAG_NO_RETURN) 2021 /* This method cannot exit normally */ 2022 CCerror(context, "Cannot return normally"); 2023 default: 2024 break; /* nothing to do. */ 2025 } 2026} 2027 2028/* Make sure that the top of the stack contains reasonable values for the 2029 * given instruction. The post-pop values of the stack and its size are 2030 * returned in *new_stack_info. 2031 */ 2032 2033static void 2034pop_stack(context_type *context, unsigned int inumber, stack_info_type *new_stack_info) 2035{ 2036 instruction_data_type *idata = context->instruction_data; 2037 instruction_data_type *this_idata = &idata[inumber]; 2038 int opcode = this_idata->opcode; 2039 stack_item_type *stack = this_idata->stack_info.stack; 2040 int stack_size = this_idata->stack_info.stack_size; 2041 char *stack_operands, *p; 2042 char buffer[257]; /* for holding manufactured argument lists */ 2043 fullinfo_type stack_extra_info_buffer[256]; /* save info popped off stack */ 2044 fullinfo_type *stack_extra_info = &stack_extra_info_buffer[256]; 2045 fullinfo_type full_info; /* only used in case of invoke instructions */ 2046 fullinfo_type put_full_info; /* only used in case JVM_OPC_putstatic and JVM_OPC_putfield */ 2047 2048 switch(opcode) { 2049 default: 2050 /* For most instructions, we just use a built-in table */ 2051 stack_operands = opcode_in_out[opcode][0]; 2052 break; 2053 2054 case JVM_OPC_putstatic: case JVM_OPC_putfield: { 2055 /* The top thing on the stack depends on the signature of 2056 * the object. */ 2057 int operand = this_idata->operand.i; 2058 const char *signature = 2059 JVM_GetCPFieldSignatureUTF(context->env, 2060 context->class, 2061 operand); 2062 char *ip = buffer; 2063 check_and_push(context, signature, VM_STRING_UTF); 2064#ifdef DEBUG 2065 if (verify_verbose) { 2066 print_formatted_fieldname(context, operand); 2067 } 2068#endif 2069 if (opcode == JVM_OPC_putfield) 2070 *ip++ = 'A'; /* object for putfield */ 2071 *ip++ = signature_to_fieldtype(context, &signature, &put_full_info); 2072 *ip = '\0'; 2073 stack_operands = buffer; 2074 pop_and_free(context); 2075 break; 2076 } 2077 2078 case JVM_OPC_invokevirtual: case JVM_OPC_invokespecial: 2079 case JVM_OPC_invokeinit: /* invokespecial call to <init> */ 2080 case JVM_OPC_invokestatic: case JVM_OPC_invokeinterface: { 2081 /* The top stuff on the stack depends on the method signature */ 2082 int operand = this_idata->operand.i; 2083 const char *signature = 2084 JVM_GetCPMethodSignatureUTF(context->env, 2085 context->class, 2086 operand); 2087 char *ip = buffer; 2088 const char *p; 2089 check_and_push(context, signature, VM_STRING_UTF); 2090#ifdef DEBUG 2091 if (verify_verbose) { 2092 print_formatted_methodname(context, operand); 2093 } 2094#endif 2095 if (opcode != JVM_OPC_invokestatic) 2096 /* First, push the object */ 2097 *ip++ = (opcode == JVM_OPC_invokeinit ? '@' : 'A'); 2098 for (p = signature + 1; *p != JVM_SIGNATURE_ENDFUNC; ) { 2099 *ip++ = signature_to_fieldtype(context, &p, &full_info); 2100 if (ip >= buffer + sizeof(buffer) - 1) 2101 CCerror(context, "Signature %s has too many arguments", 2102 signature); 2103 } 2104 *ip = 0; 2105 stack_operands = buffer; 2106 pop_and_free(context); 2107 break; 2108 } 2109 2110 case JVM_OPC_multianewarray: { 2111 /* Count can't be larger than 255. So can't overflow buffer */ 2112 int count = this_idata->operand2.i; /* number of ints on stack */ 2113 memset(buffer, 'I', count); 2114 buffer[count] = '\0'; 2115 stack_operands = buffer; 2116 break; 2117 } 2118 2119 } /* of switch */ 2120 2121 /* Run through the list of operands >>backwards<< */ 2122 for ( p = stack_operands + strlen(stack_operands); 2123 p > stack_operands; 2124 stack = stack->next) { 2125 int type = *--p; 2126 fullinfo_type top_type = stack ? stack->item : 0; 2127 int size = (type == 'D' || type == 'L') ? 2 : 1; 2128 *--stack_extra_info = top_type; 2129 if (stack == NULL) 2130 CCerror(context, "Unable to pop operand off an empty stack"); 2131 2132 switch (type) { 2133 case 'I': 2134 if (top_type != MAKE_FULLINFO(ITEM_Integer, 0, 0)) 2135 CCerror(context, "Expecting to find integer on stack"); 2136 break; 2137 2138 case 'F': 2139 if (top_type != MAKE_FULLINFO(ITEM_Float, 0, 0)) 2140 CCerror(context, "Expecting to find float on stack"); 2141 break; 2142 2143 case 'A': /* object or array */ 2144 if ( (GET_ITEM_TYPE(top_type) != ITEM_Object) 2145 && (GET_INDIRECTION(top_type) == 0)) { 2146 /* The thing isn't an object or an array. Let's see if it's 2147 * one of the special cases */ 2148 if ( (WITH_ZERO_EXTRA_INFO(top_type) == 2149 MAKE_FULLINFO(ITEM_ReturnAddress, 0, 0)) 2150 && (opcode == JVM_OPC_astore)) 2151 break; 2152 if ( (GET_ITEM_TYPE(top_type) == ITEM_NewObject 2153 || (GET_ITEM_TYPE(top_type) == ITEM_InitObject)) 2154 && ((opcode == JVM_OPC_astore) || (opcode == JVM_OPC_aload) 2155 || (opcode == JVM_OPC_ifnull) || (opcode == JVM_OPC_ifnonnull))) 2156 break; 2157 /* The 2nd edition VM of the specification allows field 2158 * initializations before the superclass initializer, 2159 * if the field is defined within the current class. 2160 */ 2161 if ( (GET_ITEM_TYPE(top_type) == ITEM_InitObject) 2162 && (opcode == JVM_OPC_putfield)) { 2163 int operand = this_idata->operand.i; 2164 int access_bits = JVM_GetCPFieldModifiers(context->env, 2165 context->class, 2166 operand, 2167 context->class); 2168 /* Note: This relies on the fact that 2169 * JVM_GetCPFieldModifiers retrieves only local fields, 2170 * and does not respect inheritance. 2171 */ 2172 if (access_bits != -1) { 2173 if ( cp_index_to_class_fullinfo(context, operand, JVM_CONSTANT_Fieldref) == 2174 context->currentclass_info ) { 2175 top_type = context->currentclass_info; 2176 *stack_extra_info = top_type; 2177 break; 2178 } 2179 } 2180 } 2181 CCerror(context, "Expecting to find object/array on stack"); 2182 } 2183 break; 2184 2185 case '@': { /* unitialized object, for call to <init> */ 2186 int item_type = GET_ITEM_TYPE(top_type); 2187 if (item_type != ITEM_NewObject && item_type != ITEM_InitObject) 2188 CCerror(context, 2189 "Expecting to find unitialized object on stack"); 2190 break; 2191 } 2192 2193 case 'O': /* object, not array */ 2194 if (WITH_ZERO_EXTRA_INFO(top_type) != 2195 MAKE_FULLINFO(ITEM_Object, 0, 0)) 2196 CCerror(context, "Expecting to find object on stack"); 2197 break; 2198 2199 case 'a': /* integer, object, or array */ 2200 if ( (top_type != MAKE_FULLINFO(ITEM_Integer, 0, 0)) 2201 && (GET_ITEM_TYPE(top_type) != ITEM_Object) 2202 && (GET_INDIRECTION(top_type) == 0)) 2203 CCerror(context, 2204 "Expecting to find object, array, or int on stack"); 2205 break; 2206 2207 case 'D': /* double */ 2208 if (top_type != MAKE_FULLINFO(ITEM_Double, 0, 0)) 2209 CCerror(context, "Expecting to find double on stack"); 2210 break; 2211 2212 case 'L': /* long */ 2213 if (top_type != MAKE_FULLINFO(ITEM_Long, 0, 0)) 2214 CCerror(context, "Expecting to find long on stack"); 2215 break; 2216 2217 case ']': /* array of some type */ 2218 if (top_type == NULL_FULLINFO) { 2219 /* do nothing */ 2220 } else switch(p[-1]) { 2221 case 'I': /* array of integers */ 2222 if (top_type != MAKE_FULLINFO(ITEM_Integer, 1, 0) && 2223 top_type != NULL_FULLINFO) 2224 CCerror(context, 2225 "Expecting to find array of ints on stack"); 2226 break; 2227 2228 case 'L': /* array of longs */ 2229 if (top_type != MAKE_FULLINFO(ITEM_Long, 1, 0)) 2230 CCerror(context, 2231 "Expecting to find array of longs on stack"); 2232 break; 2233 2234 case 'F': /* array of floats */ 2235 if (top_type != MAKE_FULLINFO(ITEM_Float, 1, 0)) 2236 CCerror(context, 2237 "Expecting to find array of floats on stack"); 2238 break; 2239 2240 case 'D': /* array of doubles */ 2241 if (top_type != MAKE_FULLINFO(ITEM_Double, 1, 0)) 2242 CCerror(context, 2243 "Expecting to find array of doubles on stack"); 2244 break; 2245 2246 case 'A': { /* array of addresses (arrays or objects) */ 2247 int indirection = GET_INDIRECTION(top_type); 2248 if ((indirection == 0) || 2249 ((indirection == 1) && 2250 (GET_ITEM_TYPE(top_type) != ITEM_Object))) 2251 CCerror(context, 2252 "Expecting to find array of objects or arrays " 2253 "on stack"); 2254 break; 2255 } 2256 2257 case 'B': /* array of bytes or booleans */ 2258 if (top_type != MAKE_FULLINFO(ITEM_Byte, 1, 0) && 2259 top_type != MAKE_FULLINFO(ITEM_Boolean, 1, 0)) 2260 CCerror(context, 2261 "Expecting to find array of bytes or Booleans on stack"); 2262 break; 2263 2264 case 'C': /* array of characters */ 2265 if (top_type != MAKE_FULLINFO(ITEM_Char, 1, 0)) 2266 CCerror(context, 2267 "Expecting to find array of chars on stack"); 2268 break; 2269 2270 case 'S': /* array of shorts */ 2271 if (top_type != MAKE_FULLINFO(ITEM_Short, 1, 0)) 2272 CCerror(context, 2273 "Expecting to find array of shorts on stack"); 2274 break; 2275 2276 case '?': /* any type of array is okay */ 2277 if (GET_INDIRECTION(top_type) == 0) 2278 CCerror(context, 2279 "Expecting to find array on stack"); 2280 break; 2281 2282 default: 2283 CCerror(context, "Internal error #1"); 2284 break; 2285 } 2286 p -= 2; /* skip over [ <char> */ 2287 break; 2288 2289 case '1': case '2': case '3': case '4': /* stack swapping */ 2290 if (top_type == MAKE_FULLINFO(ITEM_Double, 0, 0) 2291 || top_type == MAKE_FULLINFO(ITEM_Long, 0, 0)) { 2292 if ((p > stack_operands) && (p[-1] == '+')) { 2293 context->swap_table[type - '1'] = top_type + 1; 2294 context->swap_table[p[-2] - '1'] = top_type; 2295 size = 2; 2296 p -= 2; 2297 } else { 2298 CCerror(context, 2299 "Attempt to split long or double on the stack"); 2300 } 2301 } else { 2302 context->swap_table[type - '1'] = stack->item; 2303 if ((p > stack_operands) && (p[-1] == '+')) 2304 p--; /* ignore */ 2305 } 2306 break; 2307 case '+': /* these should have been caught. */ 2308 default: 2309 CCerror(context, "Internal error #2"); 2310 } 2311 stack_size -= size; 2312 } 2313 2314 /* For many of the opcodes that had an "A" in their field, we really 2315 * need to go back and do a little bit more accurate testing. We can, of 2316 * course, assume that the minimal type checking has already been done. 2317 */ 2318 switch (opcode) { 2319 default: break; 2320 case JVM_OPC_aastore: { /* array index object */ 2321 fullinfo_type array_type = stack_extra_info[0]; 2322 fullinfo_type object_type = stack_extra_info[2]; 2323 fullinfo_type target_type = decrement_indirection(array_type); 2324 if ((GET_ITEM_TYPE(object_type) != ITEM_Object) 2325 && (GET_INDIRECTION(object_type) == 0)) { 2326 CCerror(context, "Expecting reference type on operand stack in aastore"); 2327 } 2328 if ((GET_ITEM_TYPE(target_type) != ITEM_Object) 2329 && (GET_INDIRECTION(target_type) == 0)) { 2330 CCerror(context, "Component type of the array must be reference type in aastore"); 2331 } 2332 break; 2333 } 2334 2335 case JVM_OPC_putfield: 2336 case JVM_OPC_getfield: 2337 case JVM_OPC_putstatic: { 2338 int operand = this_idata->operand.i; 2339 fullinfo_type stack_object = stack_extra_info[0]; 2340 if (opcode == JVM_OPC_putfield || opcode == JVM_OPC_getfield) { 2341 if (!isAssignableTo 2342 (context, 2343 stack_object, 2344 cp_index_to_class_fullinfo 2345 (context, operand, JVM_CONSTANT_Fieldref))) { 2346 CCerror(context, 2347 "Incompatible type for getting or setting field"); 2348 } 2349 if (this_idata->protected && 2350 !isAssignableTo(context, stack_object, 2351 context->currentclass_info)) { 2352 CCerror(context, "Bad access to protected data"); 2353 } 2354 } 2355 if (opcode == JVM_OPC_putfield || opcode == JVM_OPC_putstatic) { 2356 int item = (opcode == JVM_OPC_putfield ? 1 : 0); 2357 if (!isAssignableTo(context, 2358 stack_extra_info[item], put_full_info)) { 2359 CCerror(context, "Bad type in putfield/putstatic"); 2360 } 2361 } 2362 break; 2363 } 2364 2365 case JVM_OPC_athrow: 2366 if (!isAssignableTo(context, stack_extra_info[0], 2367 context->throwable_info)) { 2368 CCerror(context, "Can only throw Throwable objects"); 2369 } 2370 break; 2371 2372 case JVM_OPC_aaload: { /* array index */ 2373 /* We need to pass the information to the stack updater */ 2374 fullinfo_type array_type = stack_extra_info[0]; 2375 context->swap_table[0] = decrement_indirection(array_type); 2376 break; 2377 } 2378 2379 case JVM_OPC_invokevirtual: case JVM_OPC_invokespecial: 2380 case JVM_OPC_invokeinit: 2381 case JVM_OPC_invokeinterface: case JVM_OPC_invokestatic: { 2382 int operand = this_idata->operand.i; 2383 const char *signature = 2384 JVM_GetCPMethodSignatureUTF(context->env, 2385 context->class, 2386 operand); 2387 int item; 2388 const char *p; 2389 check_and_push(context, signature, VM_STRING_UTF); 2390 if (opcode == JVM_OPC_invokestatic) { 2391 item = 0; 2392 } else if (opcode == JVM_OPC_invokeinit) { 2393 fullinfo_type init_type = this_idata->operand2.fi; 2394 fullinfo_type object_type = stack_extra_info[0]; 2395 context->swap_table[0] = object_type; /* save value */ 2396 if (GET_ITEM_TYPE(stack_extra_info[0]) == ITEM_NewObject) { 2397 /* We better be calling the appropriate init. Find the 2398 * inumber of the "JVM_OPC_new" instruction", and figure 2399 * out what the type really is. 2400 */ 2401 unsigned int new_inumber = GET_EXTRA_INFO(stack_extra_info[0]); 2402 fullinfo_type target_type = idata[new_inumber].operand2.fi; 2403 context->swap_table[1] = target_type; 2404 2405 if (target_type != init_type) { 2406 CCerror(context, "Call to wrong initialization method"); 2407 } 2408 if (this_idata->protected 2409 && !isAssignableTo(context, object_type, 2410 context->currentclass_info)) { 2411 CCerror(context, "Bad access to protected data"); 2412 } 2413 } else { 2414 /* We better be calling super() or this(). */ 2415 if (init_type != context->superclass_info && 2416 init_type != context->currentclass_info) { 2417 CCerror(context, "Call to wrong initialization method"); 2418 } 2419 context->swap_table[1] = context->currentclass_info; 2420 } 2421 item = 1; 2422 } else { 2423 fullinfo_type target_type = this_idata->operand2.fi; 2424 fullinfo_type object_type = stack_extra_info[0]; 2425 if (!isAssignableTo(context, object_type, target_type)){ 2426 CCerror(context, 2427 "Incompatible object argument for function call"); 2428 } 2429 if (opcode == JVM_OPC_invokespecial 2430 && !isAssignableTo(context, object_type, 2431 context->currentclass_info)) { 2432 /* Make sure object argument is assignment compatible to current class */ 2433 CCerror(context, 2434 "Incompatible object argument for invokespecial"); 2435 } 2436 if (this_idata->protected 2437 && !isAssignableTo(context, object_type, 2438 context->currentclass_info)) { 2439 /* This is ugly. Special dispensation. Arrays pretend to 2440 implement public Object clone() even though they don't */ 2441 const char *utfName = 2442 JVM_GetCPMethodNameUTF(context->env, 2443 context->class, 2444 this_idata->operand.i); 2445 int is_clone = utfName && (strcmp(utfName, "clone") == 0); 2446 JVM_ReleaseUTF(utfName); 2447 2448 if ((target_type == context->object_info) && 2449 (GET_INDIRECTION(object_type) > 0) && 2450 is_clone) { 2451 } else { 2452 CCerror(context, "Bad access to protected data"); 2453 } 2454 } 2455 item = 1; 2456 } 2457 for (p = signature + 1; *p != JVM_SIGNATURE_ENDFUNC; item++) 2458 if (signature_to_fieldtype(context, &p, &full_info) == 'A') { 2459 if (!isAssignableTo(context, 2460 stack_extra_info[item], full_info)) { 2461 CCerror(context, "Incompatible argument to function"); 2462 } 2463 } 2464 2465 pop_and_free(context); 2466 break; 2467 } 2468 2469 case JVM_OPC_return: 2470 if (context->return_type != MAKE_FULLINFO(ITEM_Void, 0, 0)) 2471 CCerror(context, "Wrong return type in function"); 2472 break; 2473 2474 case JVM_OPC_ireturn: case JVM_OPC_lreturn: case JVM_OPC_freturn: 2475 case JVM_OPC_dreturn: case JVM_OPC_areturn: { 2476 fullinfo_type target_type = context->return_type; 2477 fullinfo_type object_type = stack_extra_info[0]; 2478 if (!isAssignableTo(context, object_type, target_type)) { 2479 CCerror(context, "Wrong return type in function"); 2480 } 2481 break; 2482 } 2483 2484 case JVM_OPC_new: { 2485 /* Make sure that nothing on the stack already looks like what 2486 * we want to create. I can't image how this could possibly happen 2487 * but we should test for it anyway, since if it could happen, the 2488 * result would be an unitialized object being able to masquerade 2489 * as an initialized one. 2490 */ 2491 stack_item_type *item; 2492 for (item = stack; item != NULL; item = item->next) { 2493 if (item->item == this_idata->operand.fi) { 2494 CCerror(context, 2495 "Uninitialized object on stack at creating point"); 2496 } 2497 } 2498 /* Info for update_registers */ 2499 context->swap_table[0] = this_idata->operand.fi; 2500 context->swap_table[1] = MAKE_FULLINFO(ITEM_Bogus, 0, 0); 2501 2502 break; 2503 } 2504 } 2505 new_stack_info->stack = stack; 2506 new_stack_info->stack_size = stack_size; 2507} 2508 2509 2510/* We've already determined that the instruction is legal. Perform the 2511 * operation on the registers, and return the updated results in 2512 * new_register_count_p and new_registers. 2513 */ 2514 2515static void 2516update_registers(context_type *context, unsigned int inumber, 2517 register_info_type *new_register_info) 2518{ 2519 instruction_data_type *idata = context->instruction_data; 2520 instruction_data_type *this_idata = &idata[inumber]; 2521 int opcode = this_idata->opcode; 2522 int operand = this_idata->operand.i; 2523 int register_count = this_idata->register_info.register_count; 2524 fullinfo_type *registers = this_idata->register_info.registers; 2525 stack_item_type *stack = this_idata->stack_info.stack; 2526 int mask_count = this_idata->register_info.mask_count; 2527 mask_type *masks = this_idata->register_info.masks; 2528 2529 /* Use these as default new values. */ 2530 int new_register_count = register_count; 2531 int new_mask_count = mask_count; 2532 fullinfo_type *new_registers = registers; 2533 mask_type *new_masks = masks; 2534 2535 enum { ACCESS_NONE, ACCESS_SINGLE, ACCESS_DOUBLE } access = ACCESS_NONE; 2536 int i; 2537 2538 /* Remember, we've already verified the type at the top of the stack. */ 2539 switch (opcode) { 2540 default: break; 2541 case JVM_OPC_istore: case JVM_OPC_fstore: case JVM_OPC_astore: 2542 access = ACCESS_SINGLE; 2543 goto continue_store; 2544 2545 case JVM_OPC_lstore: case JVM_OPC_dstore: 2546 access = ACCESS_DOUBLE; 2547 goto continue_store; 2548 2549 continue_store: { 2550 /* We have a modification to the registers. Copy them if needed. */ 2551 fullinfo_type stack_top_type = stack->item; 2552 int max_operand = operand + ((access == ACCESS_DOUBLE) ? 1 : 0); 2553 2554 if ( max_operand < register_count 2555 && registers[operand] == stack_top_type 2556 && ((access == ACCESS_SINGLE) || 2557 (registers[operand + 1]== stack_top_type + 1))) 2558 /* No changes have been made to the registers. */ 2559 break; 2560 new_register_count = MAX(max_operand + 1, register_count); 2561 new_registers = NEW(fullinfo_type, new_register_count); 2562 for (i = 0; i < register_count; i++) 2563 new_registers[i] = registers[i]; 2564 for (i = register_count; i < new_register_count; i++) 2565 new_registers[i] = MAKE_FULLINFO(ITEM_Bogus, 0, 0); 2566 new_registers[operand] = stack_top_type; 2567 if (access == ACCESS_DOUBLE) 2568 new_registers[operand + 1] = stack_top_type + 1; 2569 break; 2570 } 2571 2572 case JVM_OPC_iload: case JVM_OPC_fload: case JVM_OPC_aload: 2573 case JVM_OPC_iinc: case JVM_OPC_ret: 2574 access = ACCESS_SINGLE; 2575 break; 2576 2577 case JVM_OPC_lload: case JVM_OPC_dload: 2578 access = ACCESS_DOUBLE; 2579 break; 2580 2581 case JVM_OPC_jsr: case JVM_OPC_jsr_w: 2582 for (i = 0; i < new_mask_count; i++) 2583 if (new_masks[i].entry == operand) 2584 CCerror(context, "Recursive call to jsr entry"); 2585 new_masks = add_to_masks(context, masks, mask_count, operand); 2586 new_mask_count++; 2587 break; 2588 2589 case JVM_OPC_invokeinit: 2590 case JVM_OPC_new: { 2591 /* For invokeinit, an uninitialized object has been initialized. 2592 * For new, all previous occurrences of an uninitialized object 2593 * from the same instruction must be made bogus. 2594 * We find all occurrences of swap_table[0] in the registers, and 2595 * replace them with swap_table[1]; 2596 */ 2597 fullinfo_type from = context->swap_table[0]; 2598 fullinfo_type to = context->swap_table[1]; 2599 2600 int i; 2601 for (i = 0; i < register_count; i++) { 2602 if (new_registers[i] == from) { 2603 /* Found a match */ 2604 break; 2605 } 2606 } 2607 if (i < register_count) { /* We broke out loop for match */ 2608 /* We have to change registers, and possibly a mask */ 2609 jboolean copied_mask = JNI_FALSE; 2610 int k; 2611 new_registers = NEW(fullinfo_type, register_count); 2612 memcpy(new_registers, registers, 2613 register_count * sizeof(registers[0])); 2614 for ( ; i < register_count; i++) { 2615 if (new_registers[i] == from) { 2616 new_registers[i] = to; 2617 for (k = 0; k < new_mask_count; k++) { 2618 if (!IS_BIT_SET(new_masks[k].modifies, i)) { 2619 if (!copied_mask) { 2620 new_masks = copy_masks(context, new_masks, 2621 mask_count); 2622 copied_mask = JNI_TRUE; 2623 } 2624 SET_BIT(new_masks[k].modifies, i); 2625 } 2626 } 2627 } 2628 } 2629 } 2630 break; 2631 } 2632 } /* of switch */ 2633 2634 if ((access != ACCESS_NONE) && (new_mask_count > 0)) { 2635 int i, j; 2636 for (i = 0; i < new_mask_count; i++) { 2637 int *mask = new_masks[i].modifies; 2638 if ((!IS_BIT_SET(mask, operand)) || 2639 ((access == ACCESS_DOUBLE) && 2640 !IS_BIT_SET(mask, operand + 1))) { 2641 new_masks = copy_masks(context, new_masks, mask_count); 2642 for (j = i; j < new_mask_count; j++) { 2643 SET_BIT(new_masks[j].modifies, operand); 2644 if (access == ACCESS_DOUBLE) 2645 SET_BIT(new_masks[j].modifies, operand + 1); 2646 } 2647 break; 2648 } 2649 } 2650 } 2651 2652 new_register_info->register_count = new_register_count; 2653 new_register_info->registers = new_registers; 2654 new_register_info->masks = new_masks; 2655 new_register_info->mask_count = new_mask_count; 2656} 2657 2658 2659 2660/* We've already determined that the instruction is legal, and have updated 2661 * the registers. Update the flags, too. 2662 */ 2663 2664 2665static void 2666update_flags(context_type *context, unsigned int inumber, 2667 flag_type *new_and_flags, flag_type *new_or_flags) 2668 2669{ 2670 instruction_data_type *idata = context->instruction_data; 2671 instruction_data_type *this_idata = &idata[inumber]; 2672 flag_type and_flags = this_idata->and_flags; 2673 flag_type or_flags = this_idata->or_flags; 2674 2675 /* Set the "we've done a constructor" flag */ 2676 if (this_idata->opcode == JVM_OPC_invokeinit) { 2677 fullinfo_type from = context->swap_table[0]; 2678 if (from == MAKE_FULLINFO(ITEM_InitObject, 0, 0)) 2679 and_flags |= FLAG_CONSTRUCTED; 2680 } 2681 *new_and_flags = and_flags; 2682 *new_or_flags = or_flags; 2683} 2684 2685 2686 2687/* We've already determined that the instruction is legal. Perform the 2688 * operation on the stack; 2689 * 2690 * new_stack_size_p and new_stack_p point to the results after the pops have 2691 * already been done. Do the pushes, and then put the results back there. 2692 */ 2693 2694static void 2695push_stack(context_type *context, unsigned int inumber, stack_info_type *new_stack_info) 2696{ 2697 instruction_data_type *idata = context->instruction_data; 2698 instruction_data_type *this_idata = &idata[inumber]; 2699 int opcode = this_idata->opcode; 2700 int operand = this_idata->operand.i; 2701 2702 int stack_size = new_stack_info->stack_size; 2703 stack_item_type *stack = new_stack_info->stack; 2704 char *stack_results; 2705 2706 fullinfo_type full_info = 0; 2707 char buffer[5], *p; /* actually [2] is big enough */ 2708 2709 /* We need to look at all those opcodes in which either we can't tell the 2710 * value pushed onto the stack from the opcode, or in which the value 2711 * pushed onto the stack is an object or array. For the latter, we need 2712 * to make sure that full_info is set to the right value. 2713 */ 2714 switch(opcode) { 2715 default: 2716 stack_results = opcode_in_out[opcode][1]; 2717 break; 2718 2719 case JVM_OPC_ldc: case JVM_OPC_ldc_w: case JVM_OPC_ldc2_w: { 2720 /* Look to constant pool to determine correct result. */ 2721 unsigned char *type_table = context->constant_types; 2722 switch (type_table[operand]) { 2723 case JVM_CONSTANT_Integer: 2724 stack_results = "I"; break; 2725 case JVM_CONSTANT_Float: 2726 stack_results = "F"; break; 2727 case JVM_CONSTANT_Double: 2728 stack_results = "D"; break; 2729 case JVM_CONSTANT_Long: 2730 stack_results = "L"; break; 2731 case JVM_CONSTANT_String: 2732 stack_results = "A"; 2733 full_info = context->string_info; 2734 break; 2735 case JVM_CONSTANT_Class: 2736 if (context->major_version < LDC_CLASS_MAJOR_VERSION) 2737 CCerror(context, "Internal error #3"); 2738 stack_results = "A"; 2739 full_info = make_class_info_from_name(context, 2740 "java/lang/Class"); 2741 break; 2742 case JVM_CONSTANT_MethodHandle: 2743 case JVM_CONSTANT_MethodType: 2744 if (context->major_version < LDC_METHOD_HANDLE_MAJOR_VERSION) 2745 CCerror(context, "Internal error #3"); 2746 stack_results = "A"; 2747 switch (type_table[operand]) { 2748 case JVM_CONSTANT_MethodType: 2749 full_info = make_class_info_from_name(context, 2750 "java/lang/invoke/MethodType"); 2751 break; 2752 default: //JVM_CONSTANT_MethodHandle 2753 full_info = make_class_info_from_name(context, 2754 "java/lang/invoke/MethodHandle"); 2755 break; 2756 } 2757 break; 2758 default: 2759 CCerror(context, "Internal error #3"); 2760 stack_results = ""; /* Never reached: keep lint happy */ 2761 } 2762 break; 2763 } 2764 2765 case JVM_OPC_getstatic: case JVM_OPC_getfield: { 2766 /* Look to signature to determine correct result. */ 2767 int operand = this_idata->operand.i; 2768 const char *signature = JVM_GetCPFieldSignatureUTF(context->env, 2769 context->class, 2770 operand); 2771 check_and_push(context, signature, VM_STRING_UTF); 2772#ifdef DEBUG 2773 if (verify_verbose) { 2774 print_formatted_fieldname(context, operand); 2775 } 2776#endif 2777 buffer[0] = signature_to_fieldtype(context, &signature, &full_info); 2778 buffer[1] = '\0'; 2779 stack_results = buffer; 2780 pop_and_free(context); 2781 break; 2782 } 2783 2784 case JVM_OPC_invokevirtual: case JVM_OPC_invokespecial: 2785 case JVM_OPC_invokeinit: 2786 case JVM_OPC_invokestatic: case JVM_OPC_invokeinterface: { 2787 /* Look to signature to determine correct result. */ 2788 int operand = this_idata->operand.i; 2789 const char *signature = JVM_GetCPMethodSignatureUTF(context->env, 2790 context->class, 2791 operand); 2792 const char *result_signature; 2793 check_and_push(context, signature, VM_STRING_UTF); 2794 result_signature = get_result_signature(signature); 2795 if (result_signature++ == NULL) { 2796 CCerror(context, "Illegal signature %s", signature); 2797 } 2798 if (result_signature[0] == JVM_SIGNATURE_VOID) { 2799 stack_results = ""; 2800 } else { 2801 buffer[0] = signature_to_fieldtype(context, &result_signature, 2802 &full_info); 2803 buffer[1] = '\0'; 2804 stack_results = buffer; 2805 } 2806 pop_and_free(context); 2807 break; 2808 } 2809 2810 case JVM_OPC_aconst_null: 2811 stack_results = opcode_in_out[opcode][1]; 2812 full_info = NULL_FULLINFO; /* special NULL */ 2813 break; 2814 2815 case JVM_OPC_new: 2816 case JVM_OPC_checkcast: 2817 case JVM_OPC_newarray: 2818 case JVM_OPC_anewarray: 2819 case JVM_OPC_multianewarray: 2820 stack_results = opcode_in_out[opcode][1]; 2821 /* Conveniently, this result type is stored here */ 2822 full_info = this_idata->operand.fi; 2823 break; 2824 2825 case JVM_OPC_aaload: 2826 stack_results = opcode_in_out[opcode][1]; 2827 /* pop_stack() saved value for us. */ 2828 full_info = context->swap_table[0]; 2829 break; 2830 2831 case JVM_OPC_aload: 2832 stack_results = opcode_in_out[opcode][1]; 2833 /* The register hasn't been modified, so we can use its value. */ 2834 full_info = this_idata->register_info.registers[operand]; 2835 break; 2836 } /* of switch */ 2837 2838 for (p = stack_results; *p != 0; p++) { 2839 int type = *p; 2840 stack_item_type *new_item = NEW(stack_item_type, 1); 2841 new_item->next = stack; 2842 stack = new_item; 2843 switch (type) { 2844 case 'I': 2845 stack->item = MAKE_FULLINFO(ITEM_Integer, 0, 0); break; 2846 case 'F': 2847 stack->item = MAKE_FULLINFO(ITEM_Float, 0, 0); break; 2848 case 'D': 2849 stack->item = MAKE_FULLINFO(ITEM_Double, 0, 0); 2850 stack_size++; break; 2851 case 'L': 2852 stack->item = MAKE_FULLINFO(ITEM_Long, 0, 0); 2853 stack_size++; break; 2854 case 'R': 2855 stack->item = MAKE_FULLINFO(ITEM_ReturnAddress, 0, operand); 2856 break; 2857 case '1': case '2': case '3': case '4': { 2858 /* Get the info saved in the swap_table */ 2859 fullinfo_type stype = context->swap_table[type - '1']; 2860 stack->item = stype; 2861 if (stype == MAKE_FULLINFO(ITEM_Long, 0, 0) || 2862 stype == MAKE_FULLINFO(ITEM_Double, 0, 0)) { 2863 stack_size++; p++; 2864 } 2865 break; 2866 } 2867 case 'A': 2868 /* full_info should have the appropriate value. */ 2869 assert(full_info != 0); 2870 stack->item = full_info; 2871 break; 2872 default: 2873 CCerror(context, "Internal error #4"); 2874 2875 } /* switch type */ 2876 stack_size++; 2877 } /* outer for loop */ 2878 2879 if (opcode == JVM_OPC_invokeinit) { 2880 /* If there are any instances of "from" on the stack, we need to 2881 * replace it with "to", since calling <init> initializes all versions 2882 * of the object, obviously. */ 2883 fullinfo_type from = context->swap_table[0]; 2884 stack_item_type *ptr; 2885 for (ptr = stack; ptr != NULL; ptr = ptr->next) { 2886 if (ptr->item == from) { 2887 fullinfo_type to = context->swap_table[1]; 2888 stack = copy_stack(context, stack); 2889 for (ptr = stack; ptr != NULL; ptr = ptr->next) 2890 if (ptr->item == from) ptr->item = to; 2891 break; 2892 } 2893 } 2894 } 2895 2896 new_stack_info->stack_size = stack_size; 2897 new_stack_info->stack = stack; 2898} 2899 2900 2901/* We've performed an instruction, and determined the new registers and stack 2902 * value. Look at all of the possibly subsequent instructions, and merge 2903 * this stack value into theirs. 2904 */ 2905 2906static void 2907merge_into_successors(context_type *context, unsigned int inumber, 2908 register_info_type *register_info, 2909 stack_info_type *stack_info, 2910 flag_type and_flags, flag_type or_flags) 2911{ 2912 instruction_data_type *idata = context->instruction_data; 2913 instruction_data_type *this_idata = &idata[inumber]; 2914 int opcode = this_idata->opcode; 2915 int operand = this_idata->operand.i; 2916 struct handler_info_type *handler_info = context->handler_info; 2917 int handler_info_length = 2918 JVM_GetMethodIxExceptionTableLength(context->env, 2919 context->class, 2920 context->method_index); 2921 2922 2923 int buffer[2]; /* default value for successors */ 2924 int *successors = buffer; /* table of successors */ 2925 int successors_count; 2926 int i; 2927 2928 switch (opcode) { 2929 default: 2930 successors_count = 1; 2931 buffer[0] = inumber + 1; 2932 break; 2933 2934 case JVM_OPC_ifeq: case JVM_OPC_ifne: case JVM_OPC_ifgt: 2935 case JVM_OPC_ifge: case JVM_OPC_iflt: case JVM_OPC_ifle: 2936 case JVM_OPC_ifnull: case JVM_OPC_ifnonnull: 2937 case JVM_OPC_if_icmpeq: case JVM_OPC_if_icmpne: case JVM_OPC_if_icmpgt: 2938 case JVM_OPC_if_icmpge: case JVM_OPC_if_icmplt: case JVM_OPC_if_icmple: 2939 case JVM_OPC_if_acmpeq: case JVM_OPC_if_acmpne: 2940 successors_count = 2; 2941 buffer[0] = inumber + 1; 2942 buffer[1] = operand; 2943 break; 2944 2945 case JVM_OPC_jsr: case JVM_OPC_jsr_w: 2946 if (this_idata->operand2.i != UNKNOWN_RET_INSTRUCTION) 2947 idata[this_idata->operand2.i].changed = JNI_TRUE; 2948 /* FALLTHROUGH */ 2949 case JVM_OPC_goto: case JVM_OPC_goto_w: 2950 successors_count = 1; 2951 buffer[0] = operand; 2952 break; 2953 2954 2955 case JVM_OPC_ireturn: case JVM_OPC_lreturn: case JVM_OPC_return: 2956 case JVM_OPC_freturn: case JVM_OPC_dreturn: case JVM_OPC_areturn: 2957 case JVM_OPC_athrow: 2958 /* The testing for the returns is handled in pop_stack() */ 2959 successors_count = 0; 2960 break; 2961 2962 case JVM_OPC_ret: { 2963 /* This is slightly slow, but good enough for a seldom used instruction. 2964 * The EXTRA_ITEM_INFO of the ITEM_ReturnAddress indicates the 2965 * address of the first instruction of the subroutine. We can return 2966 * to 1 after any instruction that jsr's to that instruction. 2967 */ 2968 if (this_idata->operand2.ip == NULL) { 2969 fullinfo_type *registers = this_idata->register_info.registers; 2970 int called_instruction = GET_EXTRA_INFO(registers[operand]); 2971 int i, count, *ptr;; 2972 for (i = context->instruction_count, count = 0; --i >= 0; ) { 2973 if (((idata[i].opcode == JVM_OPC_jsr) || 2974 (idata[i].opcode == JVM_OPC_jsr_w)) && 2975 (idata[i].operand.i == called_instruction)) 2976 count++; 2977 } 2978 this_idata->operand2.ip = ptr = NEW(int, count + 1); 2979 *ptr++ = count; 2980 for (i = context->instruction_count, count = 0; --i >= 0; ) { 2981 if (((idata[i].opcode == JVM_OPC_jsr) || 2982 (idata[i].opcode == JVM_OPC_jsr_w)) && 2983 (idata[i].operand.i == called_instruction)) 2984 *ptr++ = i + 1; 2985 } 2986 } 2987 successors = this_idata->operand2.ip; /* use this instead */ 2988 successors_count = *successors++; 2989 break; 2990 2991 } 2992 2993 case JVM_OPC_tableswitch: 2994 case JVM_OPC_lookupswitch: 2995 successors = this_idata->operand.ip; /* use this instead */ 2996 successors_count = *successors++; 2997 break; 2998 } 2999 3000#ifdef DEBUG 3001 if (verify_verbose) { 3002 jio_fprintf(stdout, " ["); 3003 for (i = handler_info_length; --i >= 0; handler_info++) 3004 if (handler_info->start <= (int)inumber && handler_info->end > (int)inumber) 3005 jio_fprintf(stdout, "%d* ", handler_info->handler); 3006 for (i = 0; i < successors_count; i++) 3007 jio_fprintf(stdout, "%d ", successors[i]); 3008 jio_fprintf(stdout, "]\n"); 3009 } 3010#endif 3011 3012 handler_info = context->handler_info; 3013 for (i = handler_info_length; --i >= 0; handler_info++) { 3014 if (handler_info->start <= (int)inumber && handler_info->end > (int)inumber) { 3015 int handler = handler_info->handler; 3016 if (opcode != JVM_OPC_invokeinit) { 3017 merge_into_one_successor(context, inumber, handler, 3018 &this_idata->register_info, /* old */ 3019 &handler_info->stack_info, 3020 (flag_type) (and_flags 3021 & this_idata->and_flags), 3022 (flag_type) (or_flags 3023 | this_idata->or_flags), 3024 JNI_TRUE); 3025 } else { 3026 /* We need to be a little bit more careful with this 3027 * instruction. Things could either be in the state before 3028 * the instruction or in the state afterwards */ 3029 fullinfo_type from = context->swap_table[0]; 3030 flag_type temp_or_flags = or_flags; 3031 if (from == MAKE_FULLINFO(ITEM_InitObject, 0, 0)) 3032 temp_or_flags |= FLAG_NO_RETURN; 3033 merge_into_one_successor(context, inumber, handler, 3034 &this_idata->register_info, /* old */ 3035 &handler_info->stack_info, 3036 this_idata->and_flags, 3037 this_idata->or_flags, 3038 JNI_TRUE); 3039 merge_into_one_successor(context, inumber, handler, 3040 register_info, 3041 &handler_info->stack_info, 3042 and_flags, temp_or_flags, JNI_TRUE); 3043 } 3044 } 3045 } 3046 for (i = 0; i < successors_count; i++) { 3047 int target = successors[i]; 3048 if (target >= context->instruction_count) 3049 CCerror(context, "Falling off the end of the code"); 3050 merge_into_one_successor(context, inumber, target, 3051 register_info, stack_info, and_flags, or_flags, 3052 JNI_FALSE); 3053 } 3054} 3055 3056/* We have a new set of registers and stack values for a given instruction. 3057 * Merge this new set into the values that are already there. 3058 */ 3059 3060static void 3061merge_into_one_successor(context_type *context, 3062 unsigned int from_inumber, unsigned int to_inumber, 3063 register_info_type *new_register_info, 3064 stack_info_type *new_stack_info, 3065 flag_type new_and_flags, flag_type new_or_flags, 3066 jboolean isException) 3067{ 3068 instruction_data_type *idata = context->instruction_data; 3069 register_info_type register_info_buf; 3070 stack_info_type stack_info_buf; 3071#ifdef DEBUG 3072 instruction_data_type *this_idata = &idata[to_inumber]; 3073 register_info_type old_reg_info; 3074 stack_info_type old_stack_info; 3075 flag_type old_and_flags = 0; 3076 flag_type old_or_flags = 0; 3077#endif 3078 3079#ifdef DEBUG 3080 if (verify_verbose) { 3081 old_reg_info = this_idata->register_info; 3082 old_stack_info = this_idata->stack_info; 3083 old_and_flags = this_idata->and_flags; 3084 old_or_flags = this_idata->or_flags; 3085 } 3086#endif 3087 3088 /* All uninitialized objects are set to "bogus" when jsr and 3089 * ret are executed. Thus uninitialized objects can't propagate 3090 * into or out of a subroutine. 3091 */ 3092 if (idata[from_inumber].opcode == JVM_OPC_ret || 3093 idata[from_inumber].opcode == JVM_OPC_jsr || 3094 idata[from_inumber].opcode == JVM_OPC_jsr_w) { 3095 int new_register_count = new_register_info->register_count; 3096 fullinfo_type *new_registers = new_register_info->registers; 3097 int i; 3098 stack_item_type *item; 3099 3100 for (item = new_stack_info->stack; item != NULL; item = item->next) { 3101 if (GET_ITEM_TYPE(item->item) == ITEM_NewObject) { 3102 /* This check only succeeds for hand-contrived code. 3103 * Efficiency is not an issue. 3104 */ 3105 stack_info_buf.stack = copy_stack(context, 3106 new_stack_info->stack); 3107 stack_info_buf.stack_size = new_stack_info->stack_size; 3108 new_stack_info = &stack_info_buf; 3109 for (item = new_stack_info->stack; item != NULL; 3110 item = item->next) { 3111 if (GET_ITEM_TYPE(item->item) == ITEM_NewObject) { 3112 item->item = MAKE_FULLINFO(ITEM_Bogus, 0, 0); 3113 } 3114 } 3115 break; 3116 } 3117 } 3118 for (i = 0; i < new_register_count; i++) { 3119 if (GET_ITEM_TYPE(new_registers[i]) == ITEM_NewObject) { 3120 /* This check only succeeds for hand-contrived code. 3121 * Efficiency is not an issue. 3122 */ 3123 fullinfo_type *new_set = NEW(fullinfo_type, 3124 new_register_count); 3125 for (i = 0; i < new_register_count; i++) { 3126 fullinfo_type t = new_registers[i]; 3127 new_set[i] = GET_ITEM_TYPE(t) != ITEM_NewObject ? 3128 t : MAKE_FULLINFO(ITEM_Bogus, 0, 0); 3129 } 3130 register_info_buf.register_count = new_register_count; 3131 register_info_buf.registers = new_set; 3132 register_info_buf.mask_count = new_register_info->mask_count; 3133 register_info_buf.masks = new_register_info->masks; 3134 new_register_info = ®ister_info_buf; 3135 break; 3136 } 3137 } 3138 } 3139 3140 /* Returning from a subroutine is somewhat ugly. The actual thing 3141 * that needs to get merged into the new instruction is a joining 3142 * of info from the ret instruction with stuff in the jsr instruction 3143 */ 3144 if (idata[from_inumber].opcode == JVM_OPC_ret && !isException) { 3145 int new_register_count = new_register_info->register_count; 3146 fullinfo_type *new_registers = new_register_info->registers; 3147 int new_mask_count = new_register_info->mask_count; 3148 mask_type *new_masks = new_register_info->masks; 3149 int operand = idata[from_inumber].operand.i; 3150 int called_instruction = GET_EXTRA_INFO(new_registers[operand]); 3151 instruction_data_type *jsr_idata = &idata[to_inumber - 1]; 3152 register_info_type *jsr_reginfo = &jsr_idata->register_info; 3153 if (jsr_idata->operand2.i != (int)from_inumber) { 3154 if (jsr_idata->operand2.i != UNKNOWN_RET_INSTRUCTION) 3155 CCerror(context, "Multiple returns to single jsr"); 3156 jsr_idata->operand2.i = from_inumber; 3157 } 3158 if (jsr_reginfo->register_count == UNKNOWN_REGISTER_COUNT) { 3159 /* We don't want to handle the returned-to instruction until 3160 * we've dealt with the jsr instruction. When we get to the 3161 * jsr instruction (if ever), we'll re-mark the ret instruction 3162 */ 3163 ; 3164 } else { 3165 int register_count = jsr_reginfo->register_count; 3166 fullinfo_type *registers = jsr_reginfo->registers; 3167 int max_registers = MAX(register_count, new_register_count); 3168 fullinfo_type *new_set = NEW(fullinfo_type, max_registers); 3169 int *return_mask; 3170 struct register_info_type new_new_register_info; 3171 int i; 3172 /* Make sure the place we're returning from is legal! */ 3173 for (i = new_mask_count; --i >= 0; ) 3174 if (new_masks[i].entry == called_instruction) 3175 break; 3176 if (i < 0) 3177 CCerror(context, "Illegal return from subroutine"); 3178 /* pop the masks down to the indicated one. Remember the mask 3179 * we're popping off. */ 3180 return_mask = new_masks[i].modifies; 3181 new_mask_count = i; 3182 for (i = 0; i < max_registers; i++) { 3183 if (IS_BIT_SET(return_mask, i)) 3184 new_set[i] = i < new_register_count ? 3185 new_registers[i] : MAKE_FULLINFO(ITEM_Bogus, 0, 0); 3186 else 3187 new_set[i] = i < register_count ? 3188 registers[i] : MAKE_FULLINFO(ITEM_Bogus, 0, 0); 3189 } 3190 new_new_register_info.register_count = max_registers; 3191 new_new_register_info.registers = new_set; 3192 new_new_register_info.mask_count = new_mask_count; 3193 new_new_register_info.masks = new_masks; 3194 3195 3196 merge_stack(context, from_inumber, to_inumber, new_stack_info); 3197 merge_registers(context, to_inumber - 1, to_inumber, 3198 &new_new_register_info); 3199 merge_flags(context, from_inumber, to_inumber, new_and_flags, new_or_flags); 3200 } 3201 } else { 3202 merge_stack(context, from_inumber, to_inumber, new_stack_info); 3203 merge_registers(context, from_inumber, to_inumber, new_register_info); 3204 merge_flags(context, from_inumber, to_inumber, 3205 new_and_flags, new_or_flags); 3206 } 3207 3208#ifdef DEBUG 3209 if (verify_verbose && idata[to_inumber].changed) { 3210 register_info_type *register_info = &this_idata->register_info; 3211 stack_info_type *stack_info = &this_idata->stack_info; 3212 if (memcmp(&old_reg_info, register_info, sizeof(old_reg_info)) || 3213 memcmp(&old_stack_info, stack_info, sizeof(old_stack_info)) || 3214 (old_and_flags != this_idata->and_flags) || 3215 (old_or_flags != this_idata->or_flags)) { 3216 jio_fprintf(stdout, " %2d:", to_inumber); 3217 print_stack(context, &old_stack_info); 3218 print_registers(context, &old_reg_info); 3219 print_flags(context, old_and_flags, old_or_flags); 3220 jio_fprintf(stdout, " => "); 3221 print_stack(context, &this_idata->stack_info); 3222 print_registers(context, &this_idata->register_info); 3223 print_flags(context, this_idata->and_flags, this_idata->or_flags); 3224 jio_fprintf(stdout, "\n"); 3225 } 3226 } 3227#endif 3228 3229} 3230 3231static void 3232merge_stack(context_type *context, unsigned int from_inumber, 3233 unsigned int to_inumber, stack_info_type *new_stack_info) 3234{ 3235 instruction_data_type *idata = context->instruction_data; 3236 instruction_data_type *this_idata = &idata[to_inumber]; 3237 3238 int new_stack_size = new_stack_info->stack_size; 3239 stack_item_type *new_stack = new_stack_info->stack; 3240 3241 int stack_size = this_idata->stack_info.stack_size; 3242 3243 if (stack_size == UNKNOWN_STACK_SIZE) { 3244 /* First time at this instruction. Just copy. */ 3245 this_idata->stack_info.stack_size = new_stack_size; 3246 this_idata->stack_info.stack = new_stack; 3247 this_idata->changed = JNI_TRUE; 3248 } else if (new_stack_size != stack_size) { 3249 CCerror(context, "Inconsistent stack height %d != %d", 3250 new_stack_size, stack_size); 3251 } else { 3252 stack_item_type *stack = this_idata->stack_info.stack; 3253 stack_item_type *old, *new; 3254 jboolean change = JNI_FALSE; 3255 for (old = stack, new = new_stack; old != NULL; 3256 old = old->next, new = new->next) { 3257 if (!isAssignableTo(context, new->item, old->item)) { 3258 change = JNI_TRUE; 3259 break; 3260 } 3261 } 3262 if (change) { 3263 stack = copy_stack(context, stack); 3264 for (old = stack, new = new_stack; old != NULL; 3265 old = old->next, new = new->next) { 3266 if (new == NULL) { 3267 break; 3268 } 3269 old->item = merge_fullinfo_types(context, old->item, new->item, 3270 JNI_FALSE); 3271 if (GET_ITEM_TYPE(old->item) == ITEM_Bogus) { 3272 CCerror(context, "Mismatched stack types"); 3273 } 3274 } 3275 if (old != NULL || new != NULL) { 3276 CCerror(context, "Mismatched stack types"); 3277 } 3278 this_idata->stack_info.stack = stack; 3279 this_idata->changed = JNI_TRUE; 3280 } 3281 } 3282} 3283 3284static void 3285merge_registers(context_type *context, unsigned int from_inumber, 3286 unsigned int to_inumber, register_info_type *new_register_info) 3287{ 3288 instruction_data_type *idata = context->instruction_data; 3289 instruction_data_type *this_idata = &idata[to_inumber]; 3290 register_info_type *this_reginfo = &this_idata->register_info; 3291 3292 int new_register_count = new_register_info->register_count; 3293 fullinfo_type *new_registers = new_register_info->registers; 3294 int new_mask_count = new_register_info->mask_count; 3295 mask_type *new_masks = new_register_info->masks; 3296 3297 3298 if (this_reginfo->register_count == UNKNOWN_REGISTER_COUNT) { 3299 this_reginfo->register_count = new_register_count; 3300 this_reginfo->registers = new_registers; 3301 this_reginfo->mask_count = new_mask_count; 3302 this_reginfo->masks = new_masks; 3303 this_idata->changed = JNI_TRUE; 3304 } else { 3305 /* See if we've got new information on the register set. */ 3306 int register_count = this_reginfo->register_count; 3307 fullinfo_type *registers = this_reginfo->registers; 3308 int mask_count = this_reginfo->mask_count; 3309 mask_type *masks = this_reginfo->masks; 3310 3311 jboolean copy = JNI_FALSE; 3312 int i, j; 3313 if (register_count > new_register_count) { 3314 /* Any register larger than new_register_count is now bogus */ 3315 this_reginfo->register_count = new_register_count; 3316 register_count = new_register_count; 3317 this_idata->changed = JNI_TRUE; 3318 } 3319 for (i = 0; i < register_count; i++) { 3320 fullinfo_type prev_value = registers[i]; 3321 if ((i < new_register_count) 3322 ? (!isAssignableTo(context, new_registers[i], prev_value)) 3323 : (prev_value != MAKE_FULLINFO(ITEM_Bogus, 0, 0))) { 3324 copy = JNI_TRUE; 3325 break; 3326 } 3327 } 3328 3329 if (copy) { 3330 /* We need a copy. So do it. */ 3331 fullinfo_type *new_set = NEW(fullinfo_type, register_count); 3332 for (j = 0; j < i; j++) 3333 new_set[j] = registers[j]; 3334 for (j = i; j < register_count; j++) { 3335 if (i >= new_register_count) 3336 new_set[j] = MAKE_FULLINFO(ITEM_Bogus, 0, 0); 3337 else 3338 new_set[j] = merge_fullinfo_types(context, 3339 new_registers[j], 3340 registers[j], JNI_FALSE); 3341 } 3342 /* Some of the end items might now be bogus. This step isn't 3343 * necessary, but it may save work later. */ 3344 while ( register_count > 0 3345 && GET_ITEM_TYPE(new_set[register_count-1]) == ITEM_Bogus) 3346 register_count--; 3347 this_reginfo->register_count = register_count; 3348 this_reginfo->registers = new_set; 3349 this_idata->changed = JNI_TRUE; 3350 } 3351 if (mask_count > 0) { 3352 /* If the target instruction already has a sequence of masks, then 3353 * we need to merge new_masks into it. We want the entries on 3354 * the mask to be the longest common substring of the two. 3355 * (e.g. a->b->d merged with a->c->d should give a->d) 3356 * The bits set in the mask should be the or of the corresponding 3357 * entries in each of the original masks. 3358 */ 3359 int i, j, k; 3360 int matches = 0; 3361 int last_match = -1; 3362 jboolean copy_needed = JNI_FALSE; 3363 for (i = 0; i < mask_count; i++) { 3364 int entry = masks[i].entry; 3365 for (j = last_match + 1; j < new_mask_count; j++) { 3366 if (new_masks[j].entry == entry) { 3367 /* We have a match */ 3368 int *prev = masks[i].modifies; 3369 int *new = new_masks[j].modifies; 3370 matches++; 3371 /* See if new_mask has bits set for "entry" that 3372 * weren't set for mask. If so, need to copy. */ 3373 for (k = context->bitmask_size - 1; 3374 !copy_needed && k >= 0; 3375 k--) 3376 if (~prev[k] & new[k]) 3377 copy_needed = JNI_TRUE; 3378 last_match = j; 3379 break; 3380 } 3381 } 3382 } 3383 if ((matches < mask_count) || copy_needed) { 3384 /* We need to make a copy for the new item, since either the 3385 * size has decreased, or new bits are set. */ 3386 mask_type *copy = NEW(mask_type, matches); 3387 for (i = 0; i < matches; i++) { 3388 copy[i].modifies = NEW(int, context->bitmask_size); 3389 } 3390 this_reginfo->masks = copy; 3391 this_reginfo->mask_count = matches; 3392 this_idata->changed = JNI_TRUE; 3393 matches = 0; 3394 last_match = -1; 3395 for (i = 0; i < mask_count; i++) { 3396 int entry = masks[i].entry; 3397 for (j = last_match + 1; j < new_mask_count; j++) { 3398 if (new_masks[j].entry == entry) { 3399 int *prev1 = masks[i].modifies; 3400 int *prev2 = new_masks[j].modifies; 3401 int *new = copy[matches].modifies; 3402 copy[matches].entry = entry; 3403 for (k = context->bitmask_size - 1; k >= 0; k--) 3404 new[k] = prev1[k] | prev2[k]; 3405 matches++; 3406 last_match = j; 3407 break; 3408 } 3409 } 3410 } 3411 } 3412 } 3413 } 3414} 3415 3416 3417static void 3418merge_flags(context_type *context, unsigned int from_inumber, 3419 unsigned int to_inumber, 3420 flag_type new_and_flags, flag_type new_or_flags) 3421{ 3422 /* Set this_idata->and_flags &= new_and_flags 3423 this_idata->or_flags |= new_or_flags 3424 */ 3425 instruction_data_type *idata = context->instruction_data; 3426 instruction_data_type *this_idata = &idata[to_inumber]; 3427 flag_type this_and_flags = this_idata->and_flags; 3428 flag_type this_or_flags = this_idata->or_flags; 3429 flag_type merged_and = this_and_flags & new_and_flags; 3430 flag_type merged_or = this_or_flags | new_or_flags; 3431 3432 if ((merged_and != this_and_flags) || (merged_or != this_or_flags)) { 3433 this_idata->and_flags = merged_and; 3434 this_idata->or_flags = merged_or; 3435 this_idata->changed = JNI_TRUE; 3436 } 3437} 3438 3439 3440/* Make a copy of a stack */ 3441 3442static stack_item_type * 3443copy_stack(context_type *context, stack_item_type *stack) 3444{ 3445 int length; 3446 stack_item_type *ptr; 3447 3448 /* Find the length */ 3449 for (ptr = stack, length = 0; ptr != NULL; ptr = ptr->next, length++); 3450 3451 if (length > 0) { 3452 stack_item_type *new_stack = NEW(stack_item_type, length); 3453 stack_item_type *new_ptr; 3454 for ( ptr = stack, new_ptr = new_stack; 3455 ptr != NULL; 3456 ptr = ptr->next, new_ptr++) { 3457 new_ptr->item = ptr->item; 3458 new_ptr->next = new_ptr + 1; 3459 } 3460 new_stack[length - 1].next = NULL; 3461 return new_stack; 3462 } else { 3463 return NULL; 3464 } 3465} 3466 3467 3468static mask_type * 3469copy_masks(context_type *context, mask_type *masks, int mask_count) 3470{ 3471 mask_type *result = NEW(mask_type, mask_count); 3472 int bitmask_size = context->bitmask_size; 3473 int *bitmaps = NEW(int, mask_count * bitmask_size); 3474 int i; 3475 for (i = 0; i < mask_count; i++) { 3476 result[i].entry = masks[i].entry; 3477 result[i].modifies = &bitmaps[i * bitmask_size]; 3478 memcpy(result[i].modifies, masks[i].modifies, bitmask_size * sizeof(int)); 3479 } 3480 return result; 3481} 3482 3483 3484static mask_type * 3485add_to_masks(context_type *context, mask_type *masks, int mask_count, int d) 3486{ 3487 mask_type *result = NEW(mask_type, mask_count + 1); 3488 int bitmask_size = context->bitmask_size; 3489 int *bitmaps = NEW(int, (mask_count + 1) * bitmask_size); 3490 int i; 3491 for (i = 0; i < mask_count; i++) { 3492 result[i].entry = masks[i].entry; 3493 result[i].modifies = &bitmaps[i * bitmask_size]; 3494 memcpy(result[i].modifies, masks[i].modifies, bitmask_size * sizeof(int)); 3495 } 3496 result[mask_count].entry = d; 3497 result[mask_count].modifies = &bitmaps[mask_count * bitmask_size]; 3498 memset(result[mask_count].modifies, 0, bitmask_size * sizeof(int)); 3499 return result; 3500} 3501 3502 3503 3504/* We create our own storage manager, since we malloc lots of little items, 3505 * and I don't want to keep trace of when they become free. I sure wish that 3506 * we had heaps, and I could just free the heap when done. 3507 */ 3508 3509#define CCSegSize 2000 3510 3511struct CCpool { /* a segment of allocated memory in the pool */ 3512 struct CCpool *next; 3513 int segSize; /* almost always CCSegSize */ 3514 int poolPad; 3515 char space[CCSegSize]; 3516}; 3517 3518/* Initialize the context's heap. */ 3519static void CCinit(context_type *context) 3520{ 3521 struct CCpool *new = (struct CCpool *) malloc(sizeof(struct CCpool)); 3522 /* Set context->CCroot to 0 if new == 0 to tell CCdestroy to lay off */ 3523 context->CCroot = context->CCcurrent = new; 3524 if (new == 0) { 3525 CCout_of_memory(context); 3526 } 3527 new->next = NULL; 3528 new->segSize = CCSegSize; 3529 context->CCfree_size = CCSegSize; 3530 context->CCfree_ptr = &new->space[0]; 3531} 3532 3533 3534/* Reuse all the space that we have in the context's heap. */ 3535static void CCreinit(context_type *context) 3536{ 3537 struct CCpool *first = context->CCroot; 3538 context->CCcurrent = first; 3539 context->CCfree_size = CCSegSize; 3540 context->CCfree_ptr = &first->space[0]; 3541} 3542 3543/* Destroy the context's heap. */ 3544static void CCdestroy(context_type *context) 3545{ 3546 struct CCpool *this = context->CCroot; 3547 while (this) { 3548 struct CCpool *next = this->next; 3549 free(this); 3550 this = next; 3551 } 3552 /* These two aren't necessary. But can't hurt either */ 3553 context->CCroot = context->CCcurrent = NULL; 3554 context->CCfree_ptr = 0; 3555} 3556 3557/* Allocate an object of the given size from the context's heap. */ 3558static void * 3559CCalloc(context_type *context, int size, jboolean zero) 3560{ 3561 3562 register char *p; 3563 /* Round CC to the size of a pointer */ 3564 size = (size + (sizeof(void *) - 1)) & ~(sizeof(void *) - 1); 3565 3566 if (context->CCfree_size < size) { 3567 struct CCpool *current = context->CCcurrent; 3568 struct CCpool *new; 3569 if (size > CCSegSize) { /* we need to allocate a special block */ 3570 new = (struct CCpool *)malloc(sizeof(struct CCpool) + 3571 (size - CCSegSize)); 3572 if (new == 0) { 3573 CCout_of_memory(context); 3574 } 3575 new->next = current->next; 3576 new->segSize = size; 3577 current->next = new; 3578 } else { 3579 new = current->next; 3580 if (new == NULL) { 3581 new = (struct CCpool *) malloc(sizeof(struct CCpool)); 3582 if (new == 0) { 3583 CCout_of_memory(context); 3584 } 3585 current->next = new; 3586 new->next = NULL; 3587 new->segSize = CCSegSize; 3588 } 3589 } 3590 context->CCcurrent = new; 3591 context->CCfree_ptr = &new->space[0]; 3592 context->CCfree_size = new->segSize; 3593 } 3594 p = context->CCfree_ptr; 3595 context->CCfree_ptr += size; 3596 context->CCfree_size -= size; 3597 if (zero) 3598 memset(p, 0, size); 3599 return p; 3600} 3601 3602/* Get the class associated with a particular field or method or class in the 3603 * constant pool. If is_field is true, we've got a field or method. If 3604 * false, we've got a class. 3605 */ 3606static fullinfo_type 3607cp_index_to_class_fullinfo(context_type *context, int cp_index, int kind) 3608{ 3609 JNIEnv *env = context->env; 3610 fullinfo_type result; 3611 const char *classname; 3612 switch (kind) { 3613 case JVM_CONSTANT_Class: 3614 classname = JVM_GetCPClassNameUTF(env, 3615 context->class, 3616 cp_index); 3617 break; 3618 case JVM_CONSTANT_Methodref: 3619 classname = JVM_GetCPMethodClassNameUTF(env, 3620 context->class, 3621 cp_index); 3622 break; 3623 case JVM_CONSTANT_Fieldref: 3624 classname = JVM_GetCPFieldClassNameUTF(env, 3625 context->class, 3626 cp_index); 3627 break; 3628 default: 3629 classname = NULL; 3630 CCerror(context, "Internal error #5"); 3631 } 3632 3633 check_and_push(context, classname, VM_STRING_UTF); 3634 if (classname[0] == JVM_SIGNATURE_ARRAY) { 3635 /* This make recursively call us, in case of a class array */ 3636 signature_to_fieldtype(context, &classname, &result); 3637 } else { 3638 result = make_class_info_from_name(context, classname); 3639 } 3640 pop_and_free(context); 3641 return result; 3642} 3643 3644 3645static int 3646print_CCerror_info(context_type *context) 3647{ 3648 JNIEnv *env = context->env; 3649 jclass cb = context->class; 3650 const char *classname = JVM_GetClassNameUTF(env, cb); 3651 const char *name = 0; 3652 const char *signature = 0; 3653 int n = 0; 3654 if (context->method_index != -1) { 3655 name = JVM_GetMethodIxNameUTF(env, cb, context->method_index); 3656 signature = 3657 JVM_GetMethodIxSignatureUTF(env, cb, context->method_index); 3658 n += jio_snprintf(context->message, context->message_buf_len, 3659 "(class: %s, method: %s signature: %s) ", 3660 (classname ? classname : ""), 3661 (name ? name : ""), 3662 (signature ? signature : "")); 3663 } else if (context->field_index != -1 ) { 3664 name = JVM_GetMethodIxNameUTF(env, cb, context->field_index); 3665 n += jio_snprintf(context->message, context->message_buf_len, 3666 "(class: %s, field: %s) ", 3667 (classname ? classname : 0), 3668 (name ? name : 0)); 3669 } else { 3670 n += jio_snprintf(context->message, context->message_buf_len, 3671 "(class: %s) ", classname ? classname : ""); 3672 } 3673 JVM_ReleaseUTF(classname); 3674 JVM_ReleaseUTF(name); 3675 JVM_ReleaseUTF(signature); 3676 return n; 3677} 3678 3679static void 3680CCerror (context_type *context, char *format, ...) 3681{ 3682 int n = print_CCerror_info(context); 3683 va_list args; 3684 if (n >= 0 && n < context->message_buf_len) { 3685 va_start(args, format); 3686 jio_vsnprintf(context->message + n, context->message_buf_len - n, 3687 format, args); 3688 va_end(args); 3689 } 3690 context->err_code = CC_VerifyError; 3691 longjmp(context->jump_buffer, 1); 3692} 3693 3694static void 3695CCout_of_memory(context_type *context) 3696{ 3697 int n = print_CCerror_info(context); 3698 context->err_code = CC_OutOfMemory; 3699 longjmp(context->jump_buffer, 1); 3700} 3701 3702static void 3703CFerror(context_type *context, char *format, ...) 3704{ 3705 int n = print_CCerror_info(context); 3706 va_list args; 3707 if (n >= 0 && n < context->message_buf_len) { 3708 va_start(args, format); 3709 jio_vsnprintf(context->message + n, context->message_buf_len - n, 3710 format, args); 3711 va_end(args); 3712 } 3713 context->err_code = CC_ClassFormatError; 3714 longjmp(context->jump_buffer, 1); 3715} 3716 3717/* 3718 * Need to scan the entire signature to find the result type because 3719 * types in the arg list and the result type could contain embedded ')'s. 3720 */ 3721static const char* get_result_signature(const char* signature) { 3722 const char *p; 3723 for (p = signature; *p != JVM_SIGNATURE_ENDFUNC; p++) { 3724 switch (*p) { 3725 case JVM_SIGNATURE_BOOLEAN: 3726 case JVM_SIGNATURE_BYTE: 3727 case JVM_SIGNATURE_CHAR: 3728 case JVM_SIGNATURE_SHORT: 3729 case JVM_SIGNATURE_INT: 3730 case JVM_SIGNATURE_FLOAT: 3731 case JVM_SIGNATURE_DOUBLE: 3732 case JVM_SIGNATURE_LONG: 3733 case JVM_SIGNATURE_FUNC: /* ignore initial (, if given */ 3734 break; 3735 case JVM_SIGNATURE_CLASS: 3736 while (*p != JVM_SIGNATURE_ENDCLASS) p++; 3737 break; 3738 case JVM_SIGNATURE_ARRAY: 3739 while (*p == JVM_SIGNATURE_ARRAY) p++; 3740 /* If an array of classes, skip over class name, too. */ 3741 if (*p == JVM_SIGNATURE_CLASS) { 3742 while (*p != JVM_SIGNATURE_ENDCLASS) p++; 3743 } 3744 break; 3745 default: 3746 /* Indicate an error. */ 3747 return NULL; 3748 } 3749 } 3750 return p++; /* skip over ')'. */ 3751} 3752 3753static char 3754signature_to_fieldtype(context_type *context, 3755 const char **signature_p, fullinfo_type *full_info_p) 3756{ 3757 const char *p = *signature_p; 3758 fullinfo_type full_info = MAKE_FULLINFO(ITEM_Bogus, 0, 0); 3759 char result; 3760 int array_depth = 0; 3761 3762 for (;;) { 3763 switch(*p++) { 3764 default: 3765 result = 0; 3766 break; 3767 3768 case JVM_SIGNATURE_BOOLEAN: 3769 full_info = (array_depth > 0) 3770 ? MAKE_FULLINFO(ITEM_Boolean, 0, 0) 3771 : MAKE_FULLINFO(ITEM_Integer, 0, 0); 3772 result = 'I'; 3773 break; 3774 3775 case JVM_SIGNATURE_BYTE: 3776 full_info = (array_depth > 0) 3777 ? MAKE_FULLINFO(ITEM_Byte, 0, 0) 3778 : MAKE_FULLINFO(ITEM_Integer, 0, 0); 3779 result = 'I'; 3780 break; 3781 3782 case JVM_SIGNATURE_CHAR: 3783 full_info = (array_depth > 0) 3784 ? MAKE_FULLINFO(ITEM_Char, 0, 0) 3785 : MAKE_FULLINFO(ITEM_Integer, 0, 0); 3786 result = 'I'; 3787 break; 3788 3789 case JVM_SIGNATURE_SHORT: 3790 full_info = (array_depth > 0) 3791 ? MAKE_FULLINFO(ITEM_Short, 0, 0) 3792 : MAKE_FULLINFO(ITEM_Integer, 0, 0); 3793 result = 'I'; 3794 break; 3795 3796 case JVM_SIGNATURE_INT: 3797 full_info = MAKE_FULLINFO(ITEM_Integer, 0, 0); 3798 result = 'I'; 3799 break; 3800 3801 case JVM_SIGNATURE_FLOAT: 3802 full_info = MAKE_FULLINFO(ITEM_Float, 0, 0); 3803 result = 'F'; 3804 break; 3805 3806 case JVM_SIGNATURE_DOUBLE: 3807 full_info = MAKE_FULLINFO(ITEM_Double, 0, 0); 3808 result = 'D'; 3809 break; 3810 3811 case JVM_SIGNATURE_LONG: 3812 full_info = MAKE_FULLINFO(ITEM_Long, 0, 0); 3813 result = 'L'; 3814 break; 3815 3816 case JVM_SIGNATURE_ARRAY: 3817 array_depth++; 3818 continue; /* only time we ever do the loop > 1 */ 3819 3820 case JVM_SIGNATURE_CLASS: { 3821 char buffer_space[256]; 3822 char *buffer = buffer_space; 3823 char *finish = strchr(p, JVM_SIGNATURE_ENDCLASS); 3824 int length; 3825 if (finish == NULL) { 3826 /* Signature must have ';' after the class name. 3827 * If it does not, return 0 and ITEM_Bogus in full_info. */ 3828 result = 0; 3829 break; 3830 } 3831 length = finish - p; 3832 if (length + 1 > (int)sizeof(buffer_space)) { 3833 buffer = malloc(length + 1); 3834 check_and_push(context, buffer, VM_MALLOC_BLK); 3835 } 3836 memcpy(buffer, p, length); 3837 buffer[length] = '\0'; 3838 full_info = make_class_info_from_name(context, buffer); 3839 result = 'A'; 3840 p = finish + 1; 3841 if (buffer != buffer_space) 3842 pop_and_free(context); 3843 break; 3844 } 3845 } /* end of switch */ 3846 break; 3847 } 3848 *signature_p = p; 3849 if (array_depth == 0 || result == 0) { 3850 /* either not an array, or result is bogus */ 3851 *full_info_p = full_info; 3852 return result; 3853 } else { 3854 if (array_depth > MAX_ARRAY_DIMENSIONS) 3855 CCerror(context, "Array with too many dimensions"); 3856 *full_info_p = MAKE_FULLINFO(GET_ITEM_TYPE(full_info), 3857 array_depth, 3858 GET_EXTRA_INFO(full_info)); 3859 return 'A'; 3860 } 3861} 3862 3863 3864/* Given an array type, create the type that has one less level of 3865 * indirection. 3866 */ 3867 3868static fullinfo_type 3869decrement_indirection(fullinfo_type array_info) 3870{ 3871 if (array_info == NULL_FULLINFO) { 3872 return NULL_FULLINFO; 3873 } else { 3874 int type = GET_ITEM_TYPE(array_info); 3875 int indirection = GET_INDIRECTION(array_info) - 1; 3876 int extra_info = GET_EXTRA_INFO(array_info); 3877 if ( (indirection == 0) 3878 && ((type == ITEM_Short || type == ITEM_Byte || type == ITEM_Boolean || type == ITEM_Char))) 3879 type = ITEM_Integer; 3880 return MAKE_FULLINFO(type, indirection, extra_info); 3881 } 3882} 3883 3884 3885/* See if we can assign an object of the "from" type to an object 3886 * of the "to" type. 3887 */ 3888 3889static jboolean isAssignableTo(context_type *context, 3890 fullinfo_type from, fullinfo_type to) 3891{ 3892 return (merge_fullinfo_types(context, from, to, JNI_TRUE) == to); 3893} 3894 3895/* Given two fullinfo_type's, find their lowest common denominator. If 3896 * the assignable_p argument is non-null, we're really just calling to find 3897 * out if "<target> := <value>" is a legitimate assignment. 3898 * 3899 * We treat all interfaces as if they were of type java/lang/Object, since the 3900 * runtime will do the full checking. 3901 */ 3902static fullinfo_type 3903merge_fullinfo_types(context_type *context, 3904 fullinfo_type value, fullinfo_type target, 3905 jboolean for_assignment) 3906{ 3907 JNIEnv *env = context->env; 3908 if (value == target) { 3909 /* If they're identical, clearly just return what we've got */ 3910 return value; 3911 } 3912 3913 /* Both must be either arrays or objects to go further */ 3914 if (GET_INDIRECTION(value) == 0 && GET_ITEM_TYPE(value) != ITEM_Object) 3915 return MAKE_FULLINFO(ITEM_Bogus, 0, 0); 3916 if (GET_INDIRECTION(target) == 0 && GET_ITEM_TYPE(target) != ITEM_Object) 3917 return MAKE_FULLINFO(ITEM_Bogus, 0, 0); 3918 3919 /* If either is NULL, return the other. */ 3920 if (value == NULL_FULLINFO) 3921 return target; 3922 else if (target == NULL_FULLINFO) 3923 return value; 3924 3925 /* If either is java/lang/Object, that's the result. */ 3926 if (target == context->object_info) 3927 return target; 3928 else if (value == context->object_info) { 3929 /* Minor hack. For assignments, Interface := Object, return Interface 3930 * rather than Object, so that isAssignableTo() will get the right 3931 * result. */ 3932 if (for_assignment && (WITH_ZERO_EXTRA_INFO(target) == 3933 MAKE_FULLINFO(ITEM_Object, 0, 0))) { 3934 jclass cb = object_fullinfo_to_classclass(context, 3935 target); 3936 int is_interface = cb && JVM_IsInterface(env, cb); 3937 if (is_interface) 3938 return target; 3939 } 3940 return value; 3941 } 3942 if (GET_INDIRECTION(value) > 0 || GET_INDIRECTION(target) > 0) { 3943 /* At least one is an array. Neither is java/lang/Object or NULL. 3944 * Moreover, the types are not identical. 3945 * The result must either be Object, or an array of some object type. 3946 */ 3947 fullinfo_type value_base, target_base; 3948 int dimen_value = GET_INDIRECTION(value); 3949 int dimen_target = GET_INDIRECTION(target); 3950 3951 if (target == context->cloneable_info || 3952 target == context->serializable_info) { 3953 return target; 3954 } 3955 3956 if (value == context->cloneable_info || 3957 value == context->serializable_info) { 3958 return value; 3959 } 3960 3961 /* First, if either item's base type isn't ITEM_Object, promote it up 3962 * to an object or array of object. If either is elemental, we can 3963 * punt. 3964 */ 3965 if (GET_ITEM_TYPE(value) != ITEM_Object) { 3966 if (dimen_value == 0) 3967 return MAKE_FULLINFO(ITEM_Bogus, 0, 0); 3968 dimen_value--; 3969 value = MAKE_Object_ARRAY(dimen_value); 3970 3971 } 3972 if (GET_ITEM_TYPE(target) != ITEM_Object) { 3973 if (dimen_target == 0) 3974 return MAKE_FULLINFO(ITEM_Bogus, 0, 0); 3975 dimen_target--; 3976 target = MAKE_Object_ARRAY(dimen_target); 3977 } 3978 /* Both are now objects or arrays of some sort of object type */ 3979 value_base = WITH_ZERO_INDIRECTION(value); 3980 target_base = WITH_ZERO_INDIRECTION(target); 3981 if (dimen_value == dimen_target) { 3982 /* Arrays of the same dimension. Merge their base types. */ 3983 fullinfo_type result_base = 3984 merge_fullinfo_types(context, value_base, target_base, 3985 for_assignment); 3986 if (result_base == MAKE_FULLINFO(ITEM_Bogus, 0, 0)) 3987 /* bogus in, bogus out */ 3988 return result_base; 3989 return MAKE_FULLINFO(ITEM_Object, dimen_value, 3990 GET_EXTRA_INFO(result_base)); 3991 } else { 3992 /* Arrays of different sizes. If the smaller dimension array's base 3993 * type is java/lang/Cloneable or java/io/Serializable, return it. 3994 * Otherwise return java/lang/Object with a dimension of the smaller 3995 * of the two */ 3996 if (dimen_value < dimen_target) { 3997 if (value_base == context->cloneable_info || 3998 value_base == context ->serializable_info) { 3999 return value; 4000 } 4001 return MAKE_Object_ARRAY(dimen_value); 4002 } else { 4003 if (target_base == context->cloneable_info || 4004 target_base == context->serializable_info) { 4005 return target; 4006 } 4007 return MAKE_Object_ARRAY(dimen_target); 4008 } 4009 } 4010 } else { 4011 /* Both are non-array objects. Neither is java/lang/Object or NULL */ 4012 jclass cb_value, cb_target, cb_super_value, cb_super_target; 4013 fullinfo_type result_info; 4014 4015 /* Let's get the classes corresponding to each of these. Treat 4016 * interfaces as if they were java/lang/Object. See hack note above. */ 4017 cb_target = object_fullinfo_to_classclass(context, target); 4018 if (cb_target == 0) 4019 return MAKE_FULLINFO(ITEM_Bogus, 0, 0); 4020 if (JVM_IsInterface(env, cb_target)) 4021 return for_assignment ? target : context->object_info; 4022 cb_value = object_fullinfo_to_classclass(context, value); 4023 if (cb_value == 0) 4024 return MAKE_FULLINFO(ITEM_Bogus, 0, 0); 4025 if (JVM_IsInterface(env, cb_value)) 4026 return context->object_info; 4027 4028 /* If this is for assignment of target := value, we just need to see if 4029 * cb_target is a superclass of cb_value. Save ourselves a lot of 4030 * work. 4031 */ 4032 if (for_assignment) { 4033 cb_super_value = (*env)->GetSuperclass(env, cb_value); 4034 while (cb_super_value != 0) { 4035 jclass tmp_cb; 4036 if ((*env)->IsSameObject(env, cb_super_value, cb_target)) { 4037 (*env)->DeleteLocalRef(env, cb_super_value); 4038 return target; 4039 } 4040 tmp_cb = (*env)->GetSuperclass(env, cb_super_value); 4041 (*env)->DeleteLocalRef(env, cb_super_value); 4042 cb_super_value = tmp_cb; 4043 } 4044 (*env)->DeleteLocalRef(env, cb_super_value); 4045 return context->object_info; 4046 } 4047 4048 /* Find out whether cb_value or cb_target is deeper in the class 4049 * tree by moving both toward the root, and seeing who gets there 4050 * first. */ 4051 cb_super_value = (*env)->GetSuperclass(env, cb_value); 4052 cb_super_target = (*env)->GetSuperclass(env, cb_target); 4053 while((cb_super_value != 0) && 4054 (cb_super_target != 0)) { 4055 jclass tmp_cb; 4056 /* Optimization. If either hits the other when going up looking 4057 * for a parent, then might as well return the parent immediately */ 4058 if ((*env)->IsSameObject(env, cb_super_value, cb_target)) { 4059 (*env)->DeleteLocalRef(env, cb_super_value); 4060 (*env)->DeleteLocalRef(env, cb_super_target); 4061 return target; 4062 } 4063 if ((*env)->IsSameObject(env, cb_super_target, cb_value)) { 4064 (*env)->DeleteLocalRef(env, cb_super_value); 4065 (*env)->DeleteLocalRef(env, cb_super_target); 4066 return value; 4067 } 4068 tmp_cb = (*env)->GetSuperclass(env, cb_super_value); 4069 (*env)->DeleteLocalRef(env, cb_super_value); 4070 cb_super_value = tmp_cb; 4071 4072 tmp_cb = (*env)->GetSuperclass(env, cb_super_target); 4073 (*env)->DeleteLocalRef(env, cb_super_target); 4074 cb_super_target = tmp_cb; 4075 } 4076 cb_value = (*env)->NewLocalRef(env, cb_value); 4077 cb_target = (*env)->NewLocalRef(env, cb_target); 4078 /* At most one of the following two while clauses will be executed. 4079 * Bring the deeper of cb_target and cb_value to the depth of the 4080 * shallower one. 4081 */ 4082 while (cb_super_value != 0) { 4083 /* cb_value is deeper */ 4084 jclass cb_tmp; 4085 4086 cb_tmp = (*env)->GetSuperclass(env, cb_super_value); 4087 (*env)->DeleteLocalRef(env, cb_super_value); 4088 cb_super_value = cb_tmp; 4089 4090 cb_tmp = (*env)->GetSuperclass(env, cb_value); 4091 (*env)->DeleteLocalRef(env, cb_value); 4092 cb_value = cb_tmp; 4093 } 4094 while (cb_super_target != 0) { 4095 /* cb_target is deeper */ 4096 jclass cb_tmp; 4097 4098 cb_tmp = (*env)->GetSuperclass(env, cb_super_target); 4099 (*env)->DeleteLocalRef(env, cb_super_target); 4100 cb_super_target = cb_tmp; 4101 4102 cb_tmp = (*env)->GetSuperclass(env, cb_target); 4103 (*env)->DeleteLocalRef(env, cb_target); 4104 cb_target = cb_tmp; 4105 } 4106 4107 /* Walk both up, maintaining equal depth, until a join is found. We 4108 * know that we will find one. */ 4109 while (!(*env)->IsSameObject(env, cb_value, cb_target)) { 4110 jclass cb_tmp; 4111 cb_tmp = (*env)->GetSuperclass(env, cb_value); 4112 (*env)->DeleteLocalRef(env, cb_value); 4113 cb_value = cb_tmp; 4114 cb_tmp = (*env)->GetSuperclass(env, cb_target); 4115 (*env)->DeleteLocalRef(env, cb_target); 4116 cb_target = cb_tmp; 4117 } 4118 result_info = make_class_info(context, cb_value); 4119 (*env)->DeleteLocalRef(env, cb_value); 4120 (*env)->DeleteLocalRef(env, cb_super_value); 4121 (*env)->DeleteLocalRef(env, cb_target); 4122 (*env)->DeleteLocalRef(env, cb_super_target); 4123 return result_info; 4124 } /* both items are classes */ 4125} 4126 4127 4128/* Given a fullinfo_type corresponding to an Object, return the jclass 4129 * of that type. 4130 * 4131 * This function always returns a global reference! 4132 */ 4133 4134static jclass 4135object_fullinfo_to_classclass(context_type *context, fullinfo_type classinfo) 4136{ 4137 unsigned short info = GET_EXTRA_INFO(classinfo); 4138 return ID_to_class(context, info); 4139} 4140 4141static void free_block(void *ptr, int kind) 4142{ 4143 switch (kind) { 4144 case VM_STRING_UTF: 4145 JVM_ReleaseUTF(ptr); 4146 break; 4147 case VM_MALLOC_BLK: 4148 free(ptr); 4149 break; 4150 } 4151} 4152 4153static void check_and_push(context_type *context, const void *ptr, int kind) 4154{ 4155 alloc_stack_type *p; 4156 if (ptr == 0) 4157 CCout_of_memory(context); 4158 if (context->alloc_stack_top < ALLOC_STACK_SIZE) 4159 p = &(context->alloc_stack[context->alloc_stack_top++]); 4160 else { 4161 /* Otherwise we have to malloc */ 4162 p = malloc(sizeof(alloc_stack_type)); 4163 if (p == 0) { 4164 /* Make sure we clean up. */ 4165 free_block((void *)ptr, kind); 4166 CCout_of_memory(context); 4167 } 4168 } 4169 p->kind = kind; 4170 p->ptr = (void *)ptr; 4171 p->next = context->allocated_memory; 4172 context->allocated_memory = p; 4173} 4174 4175static void pop_and_free(context_type *context) 4176{ 4177 alloc_stack_type *p = context->allocated_memory; 4178 context->allocated_memory = p->next; 4179 free_block(p->ptr, p->kind); 4180 if (p < context->alloc_stack + ALLOC_STACK_SIZE && 4181 p >= context->alloc_stack) 4182 context->alloc_stack_top--; 4183 else 4184 free(p); 4185} 4186 4187static int signature_to_args_size(const char *method_signature) 4188{ 4189 const char *p; 4190 int args_size = 0; 4191 for (p = method_signature; *p != JVM_SIGNATURE_ENDFUNC; p++) { 4192 switch (*p) { 4193 case JVM_SIGNATURE_BOOLEAN: 4194 case JVM_SIGNATURE_BYTE: 4195 case JVM_SIGNATURE_CHAR: 4196 case JVM_SIGNATURE_SHORT: 4197 case JVM_SIGNATURE_INT: 4198 case JVM_SIGNATURE_FLOAT: 4199 args_size += 1; 4200 break; 4201 case JVM_SIGNATURE_CLASS: 4202 args_size += 1; 4203 while (*p != JVM_SIGNATURE_ENDCLASS) p++; 4204 break; 4205 case JVM_SIGNATURE_ARRAY: 4206 args_size += 1; 4207 while ((*p == JVM_SIGNATURE_ARRAY)) p++; 4208 /* If an array of classes, skip over class name, too. */ 4209 if (*p == JVM_SIGNATURE_CLASS) { 4210 while (*p != JVM_SIGNATURE_ENDCLASS) 4211 p++; 4212 } 4213 break; 4214 case JVM_SIGNATURE_DOUBLE: 4215 case JVM_SIGNATURE_LONG: 4216 args_size += 2; 4217 break; 4218 case JVM_SIGNATURE_FUNC: /* ignore initial (, if given */ 4219 break; 4220 default: 4221 /* Indicate an error. */ 4222 return 0; 4223 } 4224 } 4225 return args_size; 4226} 4227 4228#ifdef DEBUG 4229 4230/* Below are for debugging. */ 4231 4232static void print_fullinfo_type(context_type *, fullinfo_type, jboolean); 4233 4234static void 4235print_stack(context_type *context, stack_info_type *stack_info) 4236{ 4237 stack_item_type *stack = stack_info->stack; 4238 if (stack_info->stack_size == UNKNOWN_STACK_SIZE) { 4239 jio_fprintf(stdout, "x"); 4240 } else { 4241 jio_fprintf(stdout, "("); 4242 for ( ; stack != 0; stack = stack->next) 4243 print_fullinfo_type(context, stack->item, 4244 (jboolean)(verify_verbose > 1 ? JNI_TRUE : JNI_FALSE)); 4245 jio_fprintf(stdout, ")"); 4246 } 4247} 4248 4249static void 4250print_registers(context_type *context, register_info_type *register_info) 4251{ 4252 int register_count = register_info->register_count; 4253 if (register_count == UNKNOWN_REGISTER_COUNT) { 4254 jio_fprintf(stdout, "x"); 4255 } else { 4256 fullinfo_type *registers = register_info->registers; 4257 int mask_count = register_info->mask_count; 4258 mask_type *masks = register_info->masks; 4259 int i, j; 4260 4261 jio_fprintf(stdout, "{"); 4262 for (i = 0; i < register_count; i++) 4263 print_fullinfo_type(context, registers[i], 4264 (jboolean)(verify_verbose > 1 ? JNI_TRUE : JNI_FALSE)); 4265 jio_fprintf(stdout, "}"); 4266 for (i = 0; i < mask_count; i++) { 4267 char *separator = ""; 4268 int *modifies = masks[i].modifies; 4269 jio_fprintf(stdout, "<%d: ", masks[i].entry); 4270 for (j = 0; 4271 j < JVM_GetMethodIxLocalsCount(context->env, 4272 context->class, 4273 context->method_index); 4274 j++) 4275 if (IS_BIT_SET(modifies, j)) { 4276 jio_fprintf(stdout, "%s%d", separator, j); 4277 separator = ","; 4278 } 4279 jio_fprintf(stdout, ">"); 4280 } 4281 } 4282} 4283 4284 4285static void 4286print_flags(context_type *context, flag_type and_flags, flag_type or_flags) 4287{ 4288 if (and_flags != ((flag_type)-1) || or_flags != 0) { 4289 jio_fprintf(stdout, "<%x %x>", and_flags, or_flags); 4290 } 4291} 4292 4293static void 4294print_fullinfo_type(context_type *context, fullinfo_type type, jboolean verbose) 4295{ 4296 int i; 4297 int indirection = GET_INDIRECTION(type); 4298 for (i = indirection; i-- > 0; ) 4299 jio_fprintf(stdout, "["); 4300 switch (GET_ITEM_TYPE(type)) { 4301 case ITEM_Integer: 4302 jio_fprintf(stdout, "I"); break; 4303 case ITEM_Float: 4304 jio_fprintf(stdout, "F"); break; 4305 case ITEM_Double: 4306 jio_fprintf(stdout, "D"); break; 4307 case ITEM_Double_2: 4308 jio_fprintf(stdout, "d"); break; 4309 case ITEM_Long: 4310 jio_fprintf(stdout, "L"); break; 4311 case ITEM_Long_2: 4312 jio_fprintf(stdout, "l"); break; 4313 case ITEM_ReturnAddress: 4314 jio_fprintf(stdout, "a"); break; 4315 case ITEM_Object: 4316 if (!verbose) { 4317 jio_fprintf(stdout, "A"); 4318 } else { 4319 unsigned short extra = GET_EXTRA_INFO(type); 4320 if (extra == 0) { 4321 jio_fprintf(stdout, "/Null/"); 4322 } else { 4323 const char *name = ID_to_class_name(context, extra); 4324 const char *name2 = strrchr(name, '/'); 4325 jio_fprintf(stdout, "/%s/", name2 ? name2 + 1 : name); 4326 } 4327 } 4328 break; 4329 case ITEM_Char: 4330 jio_fprintf(stdout, "C"); break; 4331 case ITEM_Short: 4332 jio_fprintf(stdout, "S"); break; 4333 case ITEM_Boolean: 4334 jio_fprintf(stdout, "Z"); break; 4335 case ITEM_Byte: 4336 jio_fprintf(stdout, "B"); break; 4337 case ITEM_NewObject: 4338 if (!verbose) { 4339 jio_fprintf(stdout, "@"); 4340 } else { 4341 int inum = GET_EXTRA_INFO(type); 4342 fullinfo_type real_type = 4343 context->instruction_data[inum].operand2.fi; 4344 jio_fprintf(stdout, ">"); 4345 print_fullinfo_type(context, real_type, JNI_TRUE); 4346 jio_fprintf(stdout, "<"); 4347 } 4348 break; 4349 case ITEM_InitObject: 4350 jio_fprintf(stdout, verbose ? ">/this/<" : "@"); 4351 break; 4352 4353 default: 4354 jio_fprintf(stdout, "?"); break; 4355 } 4356 for (i = indirection; i-- > 0; ) 4357 jio_fprintf(stdout, "]"); 4358} 4359 4360 4361static void 4362print_formatted_fieldname(context_type *context, int index) 4363{ 4364 JNIEnv *env = context->env; 4365 jclass cb = context->class; 4366 const char *classname = JVM_GetCPFieldClassNameUTF(env, cb, index); 4367 const char *fieldname = JVM_GetCPFieldNameUTF(env, cb, index); 4368 jio_fprintf(stdout, " <%s.%s>", 4369 classname ? classname : "", fieldname ? fieldname : ""); 4370 JVM_ReleaseUTF(classname); 4371 JVM_ReleaseUTF(fieldname); 4372} 4373 4374static void 4375print_formatted_methodname(context_type *context, int index) 4376{ 4377 JNIEnv *env = context->env; 4378 jclass cb = context->class; 4379 const char *classname = JVM_GetCPMethodClassNameUTF(env, cb, index); 4380 const char *methodname = JVM_GetCPMethodNameUTF(env, cb, index); 4381 jio_fprintf(stdout, " <%s.%s>", 4382 classname ? classname : "", methodname ? methodname : ""); 4383 JVM_ReleaseUTF(classname); 4384 JVM_ReleaseUTF(methodname); 4385} 4386 4387#endif /*DEBUG*/ 4388