Cross Reference: /dalvik/vm/analysis/CodeVerify.cpp

Lines Matching refs:method
76      * Array of RegisterLine structs, one per address in the method.  We only
84      * to the method's declared "registersSize" plus kExtraRegs.
593  * Is this method a constructor?
601  * Is this method a class initializer?
624      * that because the method is private.  So the compiler
625      * generates a package-scope <init>(parent,bogus) method that
627      * to distinguish the signature of the synthetic method).
770  * Set the register types for the first instruction in the method based on
771  * the method signature.
831              * verified) is if the current method is <init>, but in that
895      * method argument format is that 'V' is supported.
952  * Return the register type for the method.  We can't just use the
1064  * See if the method matches the MethodType.
1082  * Verify the arguments to a method.  We're executing in "method", making
1083  * a call to the method reference in vB.
1090  * For non-static method calls, this will verify that the method call is
1093  * The method reference is in vBBBB.  The "isRange" parameter determines
1100  * Returns the resolved method on success, NULL on failure (with *pFailure
1115      * Resolve the method.  This could be an abstract or concrete method
1139             ALOGI("Could not find method %s.%s, referenced from method %s.%s",
1144         LOG_VFY("VFY: unable to resolve %s method %u: %s.%s %s",
1154      * Only time you can explicitly call a method starting with '<' is when
1167      * See if the method type implied by the invoke instruction matches the
1168      * access flags for the target method.
1171         LOG_VFY("VFY: invoke type does not match method type of %s.%s",
1177      * If we're using invoke-super(method), make sure that the executing
1178      * method's class' superclass has a vtable entry for the target method.
1198      * might be calling through an abstract method definition (which doesn't
1220      * that declared the method.  For an interface class, we don't do the
1250      * Process the target method's signature.  This signature may or may not
1458  * Get the "this" pointer from a non-static method invocation.  This
1718  * appropriate <init> method is invoked -- all copies of the reference
1779  * Find the register line for the specified instruction in the current method.
2682  * allow it to be uninitialized if this is an "<init>" method and the field
2715      * the <init> method for the object and the field in question is
3020  * allocations we have to perform per method verified.
3025     const Method* meth = vdata->method;
3297     case OP_INVOKE_VIRTUAL:             // insn[1] == method ref, 3 bytes
3449  * Entry point for the detailed code-flow analysis of a single method.
3454     const Method* meth = vdata->method;
3467     /* TODO: move this elsewhere -- we don't need to do this for every method */
3472             "VFY: warning: method is huge (regs=%d insnsSize=%d)",
3474         /* might be bogus data, might be some huge generated method */
3517      * method arguments.  We can determine this from the method signature.
3583  * instruction.  If the method uses monitor-enter, we need extra data
3608     const Method* meth = vdata->method;
3818      *     unconditional branches, method returns, and exception throws.
3899      * with the results from the last method invocation.  In practice we
3950             /* check the method signature */
3982             /* check the method signature */
4014              * method is declared to return an interface, then any
5356              * this method (which implies that we're in <init> ourselves).
5489              * concrete method.  However, all of the type information is
5490              * in the abstract method, so we're good.
5735      * discarded the original field/method information.  The byte offsets
5740      * null to it, and then issues a virtual method call on it, we
5741      * cannot evaluate the method call during verification.  This situation
5744      * depends on the result of the method call is inaccessible, so the
5749      * which involve a null reference.  We can completely verify the method
5752      * virtual method invocation through a null ref, we have to skip the
5753      * method checks and have the method return a "wildcard" type (which
5974      * control transfers out of the method.)
6028      * If we're returning from the method, make sure our monitor stack
6083     const Method* meth = vdata->method;