Lines Matching refs:to
8 * particular file as subject to the "Classpath" exception as provided
18 * 2 along with this work; if not, write to the Free Software Foundation,
119 to super() */
161 /* JVM_OPC_invokespecial calls to <init> need to be treated special */
165 * Maps class names to unique 16 bit integers.
171 * row (256 buckets) at a time to minimize fragmentation. Rows are
197 * There are currently two types of resources that we need to keep
198 * track of (in addition to the CCalloc pool).
230 had a chance to free */
231 /* Store up to ALLOC_STACK_SIZE number of handles to allocated memory
232 blocks here, to save mallocs. */
257 int *code_data; /* offset to instruction number */
264 int bitmask_size; /* words needed to hold bitmap of arguments */
307 int i; /* operand to the opcode */
317 flag_type or_flags; /* true for at least one path to this inst */
319 flag_type and_flags; /* true for all paths to this instruction */
422 /* Because we can longjmp any time, we need to be very careful about
423 * remembering what needs to be freed. */
510 * and return a local reference to it.
523 * and return a global reference to it.
544 * is known to be capable of loading the class.
564 * so we're forced to load it in case it matches us.
631 * was not known to be loadable through the defining class loader
698 * 1: on success chosen to be consistent with previous VerifyClass
705 * because if it is the dynamic linker doesn't appear to be able to
889 * down the stack (due to class loading), which could end up rewriting
891 * don't want to see the rewritten bytecode, cache all the code and
951 /* not much to do for abstract and native methods */
1002 /* Allocate a structure to hold info about each instruction. */
1027 this_idata->changed = JNI_FALSE; /* no need to look at it yet. */
1028 this_idata->protected = JNI_FALSE; /* no need to look at it yet. */
1089 * Set the ip fields to 0 not the i fields because the ip fields
1108 /* Set the ->operand to be the instruction number of the target. */
1122 /* Set the ->operand to be the instruction number of the target. */
1135 /* Set the ->operand to be a table of possible instruction targets. */
1272 CCerror(context, "Illegal call to internal method");
1293 /* The optimizer make cause this to happen on local code */
1359 /* operand gets set to the "unitialized object". operand2 gets
1360 * set to what the value will be after it's initialized. */
1397 CCerror(context, "Bad type passed to newarray");
1403 /* Fudge iload_x, aload_x, etc to look like their generic cousin. */
1512 while loop is added to search up the superclass chain to make this
1559 * refer to a legal instruction.
1596 /* einfo.end_pc may point to one byte beyond the end of bytecodes. */
1623 /* Given a pointer to an instruction, return its length. Use the table
1776 /* Indicate that we need to look at the first instruction. */
1781 /* Run the data flow analysis, as long as there are things to change. */
1793 /* Run through the loop, until there is nothing left to do. */
1841 /* Add the new stack and register information to any
1958 break; /* nothing to do. */
2013 case JVM_OPC_invokeinit: /* invokespecial call to <init> */
2066 CCerror(context, "Unable to pop operand off an empty stack");
2071 CCerror(context, "Expecting to find integer on stack");
2076 CCerror(context, "Expecting to find float on stack");
2117 CCerror(context, "Expecting to find object/array on stack");
2121 case '@': { /* unitialized object, for call to <init> */
2125 "Expecting to find unitialized object on stack");
2132 CCerror(context, "Expecting to find object on stack");
2140 "Expecting to find object, array, or int on stack");
2145 CCerror(context, "Expecting to find double on stack");
2150 CCerror(context, "Expecting to find long on stack");
2161 "Expecting to find array of ints on stack");
2167 "Expecting to find array of longs on stack");
2173 "Expecting to find array of floats on stack");
2179 "Expecting to find array of doubles on stack");
2188 "Expecting to find array of objects or arrays "
2196 "Expecting to find array of bytes on stack");
2202 "Expecting to find array of chars on stack");
2208 "Expecting to find array of shorts on stack");
2214 "Expecting to find array on stack");
2234 "Attempt to split long or double on the stack");
2250 * need to go back and do a little bit more accurate testing. We can, of
2287 CCerror(context, "Bad access to protected data");
2308 /* We need to pass the information to the stack updater */
2343 CCerror(context, "Call to wrong initialization method");
2349 CCerror(context, "Bad access to protected data");
2355 CCerror(context, "Call to wrong initialization method");
2370 /* Make sure object argument is assignment compatible to current class */
2377 /* This is ugly. Special dispensation. Arrays pretend to
2390 CCerror(context, "Bad access to protected data");
2399 CCerror(context, "Incompatible argument to function");
2424 * we want to create. I can't image how this could possibly happen
2426 * result would be an unitialized object being able to masquerade
2488 /* We have a modification to the registers. Copy them if needed. */
2496 /* No changes have been made to the registers. */
2522 CCerror(context, "Recursive call to jsr entry");
2536 fullinfo_type to = context->swap_table[1];
2546 /* We have to change registers, and possibly a mask */
2554 new_registers[i] = to;
2628 * new_stack_size_p and new_stack_p point to the results after the pops have
2647 /* We need to look at all those opcodes in which either we can't tell the
2650 * to make sure that full_info is set to the right value.
2658 /* Look to constant pool to determine correct result. */
2704 /* Look to signature to determine correct result. */
2726 /* Look to signature to determine correct result. */
2819 /* If there are any instances of "from" on the stack, we need to
2820 * replace it with "to", since calling <init> initializes all versions
2826 fullinfo_type to = context->swap_table[1];
2829 if (ptr->item == from) ptr->item = to;
2905 * to 1 after any instruction that jsr's to that instruction.
2965 /* We need to be a little bit more careful with this
3027 /* All uninitialized objects are set to "bogus" when jsr and
3080 * that needs to get merged into the new instruction is a joining
3094 CCerror(context, "Multiple returns to single jsr");
3098 /* We don't want to handle the returned-to instruction until
3099 * we've dealt with the jsr instruction. When we get to the
3117 /* pop the masks down to the indicated one. Remember the mask
3292 * we need to merge new_masks into it. We want the entries on
3293 * the mask to be the longest common substring of the two.
3311 * weren't set for mask. If so, need to copy. */
3323 /* We need to make a copy for the new item, since either the
3444 * and I don't want to keep trace of when they become free. I sure wish that
3461 /* Set context->CCroot to 0 if new == 0 to tell CCdestroy to lay off */
3502 /* Round CC to the size of a pointer */
3508 if (size > CCSegSize) { /* we need to allocate a special block */
3781 /* See if we can assign an object of the "from" type to an object
3782 * of the "to" type.
3786 fullinfo_type from, fullinfo_type to)
3788 return (merge_fullinfo_types(context, from, to, JNI_TRUE) == to);
3792 * the assignable_p argument is non-null, we're really just calling to find
3809 /* Both must be either arrays or objects to go further */
3858 * to an object or array of object. If either is elemental, we can
3911 /* Let's get the classes corresponding to each of these. Treat
3924 /* If this is for assignment of target := value, we just need to see if
3975 * Bring the deeper of cb_target and cb_value to the depth of the
4024 /* Given a fullinfo_type corresponding to an Object, return the jclass
4057 /* Otherwise we have to malloc */