src/vm/hook.hpp

   1 /* src/vm/hook.hpp - hook points inside the VM
   2
   3    Copyright (C) 2009, 2010
   4    CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
   5
   6    This file is part of CACAO.
   7
   8    This program is free software; you can redistribute it and/or
   9    modify it under the terms of the GNU General Public License as
  10    published by the Free Software Foundation; either version 2, or (at
  11    your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23 */
  24
  25
  26 #ifndef _HOOK_HPP
  27 #define _HOOK_HPP
  28
  29 #include "config.h"
  30 #include "vm/globals.hpp"
  31
  32 #if defined(ENABLE_OPAGENT)
  33 #include "vm/jit/oprofile-agent.hpp"
  34 #endif
  35
  36
  37 /**
  38  * Hook points are inline functions acting as probes scattered throughout
  39  * several VM subsystems. They can be used to implement event generation
  40  * or statistics gathering without polluting the source code. Hence all
  41  * compiler macro and runtime checks should be done in this file. One
  42  * example of where hooks are useful is JVMTI event firing.
  43  */
  44 namespace Hook {
  45         void breakpoint     (Breakpoint *bp);
  46         void class_linked   (classinfo *c);
  47         void class_loaded   (classinfo *c);
  48         void jit_generated  (methodinfo *m, codeinfo *code);
  49         void jit_recycled   (methodinfo *m, codeinfo *code);
  50         void method_enter   (methodinfo *m);
  51         void method_exit    (methodinfo *m);
  52         void method_unwind  (methodinfo *m);
  53         void native_resolved(methodinfo *m, void *symbol, void **symbolptr);
  54         void thread_start   (threadobject *t);
  55         void thread_end     (threadobject *t);
  56         void vm_init        ();
  57         void vm_preinit     ();
  58         void vm_shutdown    ();
  59 }
  60
  61
  62 inline void Hook::breakpoint(Breakpoint *bp)
  63 {
  64 #if defined(ENABLE_JVMTI)
  65         methodinfo* m = bp->method;
  66         int32_t     l = bp->location;
  67
  68         log_message_method("JVMTI: Reached breakpoint in method ", m);
  69         log_println("JVMTI: Reached breakpoint at location %d", l);
  70 #endif
  71 }
  72
  73 inline void Hook::class_linked(classinfo *c)
  74 {
  75         if (c == class_java_lang_String)
  76                 linker_initialize_deferred_strings();
  77 }
  78
  79 inline void Hook::class_loaded(classinfo *c)
  80 {
  81         /* nop */
  82 }
  83
  84 /**
  85  * Hook point just after code was generated. Note that one method can have
  86  * multiple code realizations, the hook is fired for each of them. The code
  87  * was not yet executed.
  88  *
  89  * @param m The method for which code was generated.
  90  * @param code The fully initialized codeinfo for the generated code.
  91  */
  92 inline void Hook::jit_generated(methodinfo *m, codeinfo *code)
  93 {
  94 #if defined(ENABLE_OPAGENT)
  95         if (opt_EnableOpagent)
  96                 OprofileAgent::newmethod(m);
  97 #endif
  98 }
  99
 100 inline void Hook::method_enter(methodinfo *m)
 101 {
 102         /* nop */
 103 }
 104
 105 inline void Hook::method_exit(methodinfo *m)
 106 {
 107         /* nop */
 108 }
 109
 110 inline void Hook::method_unwind(methodinfo *m)
 111 {
 112         /* nop */
 113 }
 114
 115 inline void Hook::native_resolved(methodinfo *m, void *symbol, void **symbolptr)
 116 {
 117         /* nop */
 118 }
 119
 120 inline void Hook::thread_start(threadobject *t)
 121 {
 122         /* nop */
 123 }
 124
 125 inline void Hook::thread_end(threadobject *t)
 126 {
 127         /* nop */
 128 }
 129
 130 /**
 131  * Hook point after the VM is initialized. At this point the VM is fully
 132  * operating and ready to execute Java code. Final intializations and thread
 133  * startup should be done here.
 134  */
 135 inline void Hook::vm_init()
 136 {
 137         /* nop */
 138 }
 139
 140 /**
 141  * Hook point before the VM is initialized. At this point the VM can not
 142  * yet execute Java code but some central native subsystems are initialized.
 143  * Only basic initialization steps should be done here.
 144  */
 145 inline void Hook::vm_preinit()
 146 {
 147 #if defined(ENABLE_OPAGENT)
 148         if (opt_EnableOpagent)
 149                 OprofileAgent::initialize();
 150 #endif
 151 }
 152
 153 /**
 154  * Hook point before the VM is actually destroyed. At this point the VM is
 155  * still running, but all non-daemon threads have terminated and resources
 156  * are ready to be reclaimed. Final cleanup tasks should be done here.
 157  */
 158 inline void Hook::vm_shutdown()
 159 {
 160 #if defined(ENABLE_OPAGENT)
 161         if (opt_EnableOpagent)
 162                 OprofileAgent::close();
 163 #endif
 164 }
 165
 166
 167 #endif /* _HOOK_HPP */
 168
 169
 170 /*
 171  * These are local overrides for various environment variables in Emacs.
 172  * Please do not remove this and leave it at the end of the file, where
 173  * Emacs will automagically detect them.
 174  * ---------------------------------------------------------------------
 175  * Local variables:
 176  * mode: c++
 177  * indent-tabs-mode: t
 178  * c-basic-offset: 4
 179  * tab-width: 4
 180  * End:
 181  * vim:noexpandtab:sw=4:ts=4:
 182  */