* src/vm/jit/replace.c: Only recompile if necessary. Count
[cacao.git] / src / vm / method.h
index c5a55a825c0351443caaf0f0b49245a96489c7d9..ec57352af4ee9dbf5442075f55c255007a598b1e 100644 (file)
@@ -1,9 +1,9 @@
 /* src/vm/method.h - method functions header
 
-   Copyright (C) 1996-2005 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
+   Copyright (C) 1996-2005, 2006 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
 
    This file is part of CACAO.
 
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-   02111-1307, USA.
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301, USA.
 
-   Contact: cacao@complang.tuwien.ac.at
+   Contact: cacao@cacaojvm.org
 
    Authors: Reinhard Grafl
+            Christian Thalinger
+            Edwin Steiner
 
-   Changes: Christian Thalinger
-
-   $Id: method.h 3969 2005-12-21 00:07:23Z twisti $
+   $Id: method.h 6012 2006-11-16 19:45:15Z twisti $
 */
 
 
 
 /* forward typedefs ***********************************************************/
 
-typedef struct methodinfo methodinfo; 
-typedef struct exceptiontable exceptiontable;
-typedef struct lineinfo lineinfo; 
+typedef struct methodinfo          methodinfo; 
+typedef struct raw_exception_entry raw_exception_entry;
+typedef struct lineinfo            lineinfo; 
+typedef struct method_assumption   method_assumption;
+typedef struct method_worklist     method_worklist;
 
 #include "config.h"
 #include "vm/types.h"
 
+#include "vm/descriptor.h"
 #include "vm/global.h"
-#include "vm/utf8.h"
+#include "vm/linker.h"
 #include "vm/references.h"
-#include "vm/descriptor.h"
+#include "vm/utf8.h"
+#include "vm/jit/code.h"
 #include "vm/jit/jit.h"
-#include "vm/jit/inline/parseXTA.h"
 
 
 /* methodinfo *****************************************************************/
 
 struct methodinfo {                 /* method structure                       */
        java_objectheader header;       /* we need this in jit's monitorenter     */
-       s4          flags;              /* ACC flags                              */
-       utf        *name;               /* name of method                         */
-       utf        *descriptor;         /* JavaVM descriptor string of method     */
-       methoddesc *parseddesc;         /* parsed descriptor                      */
+       s4            flags;            /* ACC flags                              */
+       utf          *name;             /* name of method                         */
+       utf          *descriptor;       /* JavaVM descriptor string of method     */
+       utf          *signature;        /* Signature attribute string             */
+       methoddesc   *parseddesc;       /* parsed descriptor                      */
+                            
+       classinfo    *class;            /* class, the method belongs to           */
+       s4            vftblindex;       /* index of method in virtual function    */
+                                       /* table (if it is a virtual method)      */
+       s4            maxstack;         /* maximum stack depth of method          */
+       s4            maxlocals;        /* maximum number of local variables      */
+       s4            jcodelength;      /* length of JavaVM code                  */
+       u1           *jcode;            /* pointer to JavaVM code                 */
 
-       s4          returntype;         /* only temporary valid, return type      */
-       classinfo  *returnclass;        /* pointer to classinfo for the rtn type  */ /*XTA*/ 
+       s4            rawexceptiontablelength;  /* exceptiontable length          */
+       raw_exception_entry *rawexceptiontable; /* the exceptiontable             */
 
-       s4          paramcount;         /* only temporary valid, parameter count  */
-       u1         *paramtypes;         /* only temporary valid, parameter types  */
-       classinfo **paramclass;         /* pointer to classinfo for a parameter   */ /*XTA*/
+       u2            thrownexceptionscount; /* number of exceptions attribute    */
+       classref_or_classinfo *thrownexceptions; /* except. a method may throw    */
 
-       bool        isleafmethod;       /* does method call subroutines           */
+       u2            linenumbercount;  /* number of linenumber attributes        */
+       lineinfo     *linenumbers;      /* array of lineinfo items                */
 
-       classinfo  *class;              /* class, the method belongs to           */
-       s4          vftblindex;         /* index of method in virtual function    */
-                                       /* table (if it is a virtual method)      */
-       s4          maxstack;           /* maximum stack depth of method          */
-       s4          maxlocals;          /* maximum number of local variables      */
-       s4          jcodelength;        /* length of JavaVM code                  */
-       u1         *jcode;              /* pointer to JavaVM code                 */
+       u1           *stubroutine;      /* stub for compiling or calling natives  */
+       codeinfo     *code;             /* current code of this method            */
 
-       s4          basicblockcount;    /* number of basic blocks                 */
-       basicblock *basicblocks;        /* points to basic block array            */
-       s4         *basicblockindex;    /* a table which contains for every byte  */
-                                       /* of JavaVM code a basic block index if  */
-                                       /* at this byte is the start of a basic   */
-                                       /* block                                  */
-
-       s4          instructioncount;   /* number of JavaVM instructions          */
-       instruction *instructions;      /* points to intermediate code instr.     */
+#if defined(ENABLE_LSRA)
+       s4            maxlifetimes;     /* helper for lsra                        */
+#endif
 
-       s4          stackcount;         /* number of stack elements               */
-       stackelement *stack;            /* points to intermediate code instr.     */
+       methodinfo   *overwrites;       /* method that is directly overwritten    */
+       method_assumption *assumptions; /* list of assumptions about this method  */
+};
 
-       s4          exceptiontablelength;/* exceptiontable length                 */
-       exceptiontable *exceptiontable; /* the exceptiontable                     */
 
-       u2          thrownexceptionscount;/* number of exceptions attribute       */
-       classref_or_classinfo *thrownexceptions; /* except. a method may throw    */
+/* method_assumption ***********************************************************
 
-       u2          linenumbercount;    /* number of linenumber attributes        */
-       lineinfo   *linenumbers;        /* array of lineinfo items                */
+   This struct is used for registering assumptions about methods.
 
-       int       c_debug_nr;           /* a counter to number all BB with an     */
-                                       /* unique value                           */
+*******************************************************************************/
 
-       u1         *stubroutine;        /* stub for compiling or calling natives  */
-       s4          mcodelength;        /* legth of generated machine code        */
-       u1         *mcode;              /* pointer to machine code                */
-       u1         *entrypoint;         /* entry point in machine code            */
+struct method_assumption {
+       method_assumption *next;
+       methodinfo        *context;
+};
 
-       /*rtainfo   rta;*/
-       xtainfo    *xta;
 
-       bool        methodXTAparsed;    /*  true if xta parsed */
-       s4          methodUsed;         /* marked (might be used later) /not used /used */
-       s4          monoPoly;           /* call is mono or poly or unknown        */ /*RT stats */
-        /* should # method def'd and used be kept after static parse (will it be used?) */
-       s4              subRedefs;
-       s4              subRedefsUsed;
-       s4              nativelyoverloaded; /* used in header.c and only valid there  */
+/* method_worklist *************************************************************
 
-#if defined(ENABLE_LSRA)
-       s4          maxlifetimes;           /* helper for lsra                        */
-#endif
-};
+   List node used for method worklists.
 
+*******************************************************************************/
 
-/* exceptiontable *************************************************************/
+struct method_worklist {
+       method_worklist *next;
+       methodinfo      *m;
+};
 
-struct exceptiontable {         /* exceptiontable entry in a method           */
-       s4              startpc;    /* start pc of guarded area (inclusive)       */
-       basicblock     *start;
 
-       s4              endpc;      /* end pc of guarded area (exklusive)         */
-       basicblock     *end;
+/* raw_exception_entry ********************************************************/
 
-       s4              handlerpc;  /* pc of exception handler                    */
-       basicblock     *handler;
+/* exception table entry read by the loader */
 
-       classref_or_classinfo catchtype; /* catchtype of exc. (NULL == catchall)  */
-       exceptiontable *next;       /* used to build a list of exception when     */
-                                   /* loops are copied */
-       exceptiontable *down;       /* instead of the old array, a list is used   */
+struct raw_exception_entry {    /* exceptiontable entry in a method           */
+       classref_or_classinfo catchtype; /* catchtype of exc. (0 == catchall)     */
+       u2              startpc;    /* start pc of guarded area (inclusive)       */
+       u2              endpc;      /* end pc of guarded area (exklusive)         */
+       u2              handlerpc;  /* pc of exception handler                    */
 };
 
 
@@ -157,10 +143,18 @@ struct lineinfo {
 void method_free(methodinfo *m);
 bool method_canoverwrite(methodinfo *m, methodinfo *old);
 
-void method_display(methodinfo *m);
-void method_display_w_class(methodinfo *m);
+methodinfo *method_vftbl_lookup(vftbl_t *vftbl, methodinfo* m);
 
-void method_descriptor2types(methodinfo *m);
+void method_add_assumption_monomorphic(methodinfo *m, methodinfo *caller);
+void method_break_assumption_monomorphic(methodinfo *m, method_worklist **wl);
+
+#if !defined(NDEBUG)
+void method_printflags(methodinfo *m);
+void method_print(methodinfo *m);
+void method_println(methodinfo *m);
+void method_methodref_print(constant_FMIref *mr);
+void method_methodref_println(constant_FMIref *mr);
+#endif
 
 #endif /* _METHOD_H */
 
@@ -176,4 +170,5 @@ void method_descriptor2types(methodinfo *m);
  * c-basic-offset: 4
  * tab-width: 4
  * End:
+ * vim:noexpandtab:sw=4:ts=4:
  */