* src/native/vm/gnu/java_lang_reflect_Constructor.c

[cacao.git] / src / vm / resolve.h

diff --git a/src/vm/resolve.h b/src/vm/resolve.h
index 43707f9b41964ff21485f078b1b5ffda7cfc728a..f828d3ac0c0a5a07dbbbb3cae4d8e2e8a76f1b46 100644 (file)
--- a/src/vm/resolve.h
+++ b/src/vm/resolve.h
@@ -1,6 +1,6 @@
-/* vm/resolve.h - resolving classes/interfaces/fields/methods
+/* src/vm/resolve.h - resolving classes/interfaces/fields/methods
 
-   Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
+   Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
    C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
    E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
    J. Wenninger, Institut f. Computersprachen - TU Wien
@@ -22,13 +22,7 @@
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
 
-   Contact: cacao@cacaojvm.org
-
-   Authors: Edwin Steiner
-
-   Changes:
-
-   $Id: resolve.h 4759 2006-04-12 18:07:05Z edwin $
+   $Id: resolve.h 7486 2007-03-08 13:50:07Z twisti $
 
 */
 
@@ -46,9 +40,17 @@ typedef struct unresolved_subtype_set unresolved_subtype_set;
 
 #include "config.h"
 #include "vm/types.h"
+
 #include "vm/global.h"
-#include "vm/references.h"
+
 #include "vm/jit/jit.h"
+#include "vm/jit/reg.h"
+#include "vm/jit/verify/typeinfo.h"
+
+#include "vmcore/class.h"
+#include "vmcore/field.h"
+#include "vmcore/method.h"
+#include "vmcore/references.h"
 
 
 /* constants ******************************************************************/
@@ -137,6 +139,8 @@ bool resolve_classref_or_classinfo(methodinfo *refmethod,
                                                          bool link,
                                                          classinfo **result);
 
+classinfo *resolve_classref_or_classinfo_eager(classref_or_classinfo cls, bool checkaccess);
+
 bool resolve_class_from_typedesc(typedesc *d,bool checkaccess,bool link,classinfo **result);
 
 #ifdef ENABLE_VERIFIER
@@ -146,6 +150,7 @@ bool resolve_class(unresolved_class *ref,
                          classinfo **result);
 
 classinfo * resolve_class_eager(unresolved_class *ref);
+classinfo * resolve_class_eager_no_access_check(unresolved_class *ref);
 #endif /* ENABLE_VERIFIER */
 
 bool resolve_field(unresolved_field *ref,
@@ -167,33 +172,84 @@ unresolved_class * create_unresolved_class(methodinfo *refmethod,
                                                typeinfo *valuetype);
 #endif
 
-unresolved_field * create_unresolved_field(classinfo *referer,methodinfo *refmethod,
-                                               instruction *iptr);
+unresolved_field *resolve_create_unresolved_field(classinfo *referer,
+                                                                                         methodinfo *refmethod,
+                                                                                         instruction *iptr);
 
-unresolved_method * create_unresolved_method(classinfo *referer,methodinfo *refmethod,
-                                                instruction *iptr);
+unresolved_method * resolve_create_unresolved_method(classinfo *referer,
+                                                                                                        methodinfo *refmethod,
+                                                                                                        constant_FMIref *methodref,
+                                                                                                        bool invokestatic,
+                                                                                                        bool invokespecial);
 
 void unresolved_class_free(unresolved_class *ref);
 void unresolved_field_free(unresolved_field *ref);
 void unresolved_method_free(unresolved_method *ref);
 
-resolve_result_t resolve_method_lazy(instruction *iptr,stackptr curstack,
-                                                                        methodinfo *refmethod);
-resolve_result_t resolve_field_lazy(instruction *iptr,stackptr curstack,
-                                                                       methodinfo *refmethod);
-
-#ifdef ENABLE_VERIFIER
-bool constrain_unresolved_field(unresolved_field *ref,
-                                                  classinfo *referer,methodinfo *refmethod,
-                                                  instruction *iptr,
-                                                  stackelement *stack);
-
-bool constrain_unresolved_method(unresolved_method *ref,
-                                                       classinfo *referer,methodinfo *refmethod,
-                                                       instruction *iptr,
-                                                       stackelement *stack);
-
-#endif
+resolve_result_t resolve_method_lazy(methodinfo *refmethod,
+                                                                        constant_FMIref *methodref,
+                                                                        bool invokespecial);
+
+resolve_result_t resolve_field_lazy(methodinfo *refmethod,
+                                                                       constant_FMIref *fieldref);
+
+#if defined(ENABLE_VERIFIER)
+resolve_result_t resolve_field_verifier_checks(methodinfo *refmethod,
+                                                                                          constant_FMIref *fieldref,
+                                                                                          classinfo *container,
+                                                                                          fieldinfo *fi,
+                                                                                          typeinfo *instanceti,
+                                                                                          typeinfo *valueti,
+                                                                                          bool isstatic,
+                                                                                          bool isput);
+
+bool resolve_constrain_unresolved_field(unresolved_field *ref,
+                                                                               classinfo *referer, 
+                                                                               methodinfo *refmethod,
+                                                                           typeinfo *instanceti,
+                                                                           typeinfo *valueti);
+
+resolve_result_t resolve_method_verifier_checks(methodinfo *refmethod,
+                                                                                               constant_FMIref *methodref,
+                                                                                               methodinfo *mi,
+                                                                                               bool invokestatic);
+
+resolve_result_t resolve_method_instance_type_checks(methodinfo *refmethod,
+                                                                                                        methodinfo *mi,
+                                                                                                        typeinfo *instanceti,
+                                                                                                        bool invokespecial);
+
+resolve_result_t resolve_method_param_type_checks(jitdata *jd, 
+                                                                                                 methodinfo *refmethod,
+                                                                                                 instruction *iptr, 
+                                                                                                 methodinfo *mi,
+                                                                                                 bool invokestatic);
+
+resolve_result_t resolve_method_param_type_checks_stackbased(
+               methodinfo *refmethod, 
+               methodinfo *mi,
+               bool invokestatic, 
+               typedescriptor *stack);
+
+bool resolve_method_loading_constraints(classinfo *referer,
+                                                                               methodinfo *mi);
+
+bool resolve_constrain_unresolved_method_instance(unresolved_method *ref,
+                                                                                                 methodinfo *refmethod,
+                                                                                                 typeinfo *instanceti,
+                                                                                                 bool invokespecial);
+
+bool resolve_constrain_unresolved_method_params(jitdata *jd,
+                                                                                               unresolved_method *ref,
+                                                                                               methodinfo *refmethod,
+                                                                                               instruction *iptr);
+
+bool resolve_constrain_unresolved_method_params_stackbased(
+               unresolved_method *ref,
+               methodinfo *refmethod,
+               typedescriptor *stack);
+
+#endif /* defined(ENABLE_VERIFIER) */
 
 #ifndef NDEBUG
 void unresolved_class_debug_dump(unresolved_class *ref,FILE *file);