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.
110 static bool isInitMethod(const Method* meth);
116 static bool verifyInstruction(const Method* meth, InsnFlags* insnFlags,\
421 UninitInstanceMap* dvmCreateUninitInstanceMap(const Method* meth,
593 * Is this method a constructor?
595 static bool isInitMethod(const Method* meth)
601 * Is this method a class initializer?
604 static bool isClassInitMethod(const Method* meth)
615 static ClassObject* lookupClassByDescriptor(const Method* meth,
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).
702 static ClassObject* lookupSignatureClass(const Method* meth, const char** pSig,
737 static ClassObject* lookupSignatureArrayClass(const Method* meth,
770 * Set the register types for the first instruction in the method based on
771 * the method signature.
777 static bool setTypesFromSignature(const Method* meth, RegType* regTypes,
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
960 static RegType getMethodReturnType(const Method* meth)
1064 * See if the method matches the MethodType.
1066 static bool isCorrectInvokeKind(MethodType methodType, Method* resMethod)
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
1103 static Method* verifyInvocationArgs(const Method* meth,
1108 Method* resMethod;
1115 * Resolve the method. This could be an abstract or concrete method
1139 LOGI("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
1377 static ClassObject* getFieldClass(const Method* meth, const Field* field)
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.
2580 static bool updateRegisters(const Method* meth, InsnFlags* insnFlags,
2682 * allow it to be uninitialized if this is an "<init>" method and the field
2688 static InstField* getInstField(const Method* meth,
2715 * the <init> method for the object and the field in question is
2759 static StaticField* getStaticField(const Method* meth, int fieldIdx,
2788 static void checkFinalFieldAccess(const Method* meth, const Field* field,
2831 static void checkArrayIndexType(const Method* meth, RegType regType,
2861 static bool checkConstructorReturn(const Method* meth,
2889 static bool checkMoveException(const Method* meth, int insnIdx,
2912 static ClassObject* getCaughtExceptionType(const Method* meth, int insnIdx,
3020 * allocations we have to perform per method verified.
3025 const Method* meth = vdata->method;
3181 static void verifyFilledNewArrayRegs(const Method* meth,
3242 static bool replaceFailingInstruction(const Method* meth, InsnFlags* insnFlags,
3335 case OP_INVOKE_VIRTUAL: // insn[1] == method ref, 3 bytes
3345 case OP_INVOKE_VIRTUAL_JUMBO: // insn[1/2] == method ref, 5 bytes
3509 * Entry point for the detailed code-flow analysis of a single method.
3514 const Method* meth = vdata->method;
3527 /* TODO: move this elsewhere -- we don't need to do this for every method */
3532 "VFY: warning: method is huge (regs=%d insnsSize=%d)",
3534 /* might be bogus data, might be some huge generated method */
3577 * method arguments. We can determine this from the method signature.
3596 * Tuck it into the Method struct. It will either get used
3600 dvmSetRegisterMap((Method*)meth, pMap);
3643 * instruction. If the method uses monitor-enter, we need extra data
3668 const Method* meth = vdata->method;
3856 static bool verifyInstruction(const Method* meth, InsnFlags* insnFlags,
3878 * unconditional branches, method returns, and exception throws.
3959 * with the results from the last method invocation. In practice we
4010 /* check the method signature */
4042 /* check the method signature */
4074 * method is declared to return an interface, then any
5407 Method* calledMethod;
5435 Method* calledMethod;
5453 * this method (which implies that we're in <init> ourselves).
5516 Method* calledMethod;
5537 Method* absMethod;
5590 * concrete method. However, all of the type information is
5591 * in the abstract method, so we're good.
5837 * discarded the original field/method information. The byte offsets
5842 * null to it, and then issues a virtual method call on it, we
5843 * cannot evaluate the method call during verification. This situation
5846 * depends on the result of the method call is inaccessible, so the
5851 * which involve a null reference. We can completely verify the method
5854 * virtual method invocation through a null ref, we have to skip the
5855 * method checks and have the method return a "wildcard" type (which
6292 * control transfers out of the method.)
6346 * If we're returning from the method, make sure our monitor stack
6401 const Method* meth = vdata->method;
