< prev index next >

src/share/vm/jvmci/jvmciJavaClasses.hpp

Print this page
rev 12906 : [mq]: gc_interface


  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 #ifndef SHARE_VM_JVMCI_JVMCIJAVACLASSES_HPP
  25 #define SHARE_VM_JVMCI_JVMCIJAVACLASSES_HPP
  26 
  27 #include "classfile/systemDictionary.hpp"
  28 #include "oops/instanceMirrorKlass.hpp"
  29 #include "oops/oop.inline.hpp"

  30 
  31 class JVMCIJavaClasses : AllStatic {
  32  public:
  33   static void compute_offsets(TRAPS);
  34 };
  35 
  36 /* This macro defines the structure of the JVMCI classes accessed from VM code.
  37  * It will generate classes with accessors similar to javaClasses.hpp, but with specializations for oops, Handles and jni handles.
  38  *
  39  * The public interface of these classes will look like this:
  40 
  41  * class StackSlot : AllStatic {
  42  * public:
  43  *   static Klass* klass();
  44  *   static jint  index(oop obj);
  45  *   static jint  index(Handle obj);
  46  *   static jint  index(jobject obj);
  47  *   static void set_index(oop obj, jint x);
  48  *   static void set_index(Handle obj, jint x);
  49  *   static void set_index(jobject obj, jint x);


 334     static void set_##name(Handle obj, type x)  { check(obj(), #name, _##name##_offset); obj->accessor##_put(_##name##_offset, x); }                                                \
 335     static void set_##name(jobject obj, type x) { check(JNIHandles::resolve(obj), #name, _##name##_offset); JNIHandles::resolve(obj)->accessor##_put(_##name##_offset, x); }
 336 
 337 #define EMPTY_CAST
 338 #define CHAR_FIELD(klass, name) FIELD(name, jchar, char_field, EMPTY_CAST)
 339 #define INT_FIELD(klass, name) FIELD(name, jint, int_field, EMPTY_CAST)
 340 #define BOOLEAN_FIELD(klass, name) FIELD(name, jboolean, bool_field, EMPTY_CAST)
 341 #define LONG_FIELD(klass, name) FIELD(name, jlong, long_field, EMPTY_CAST)
 342 #define FLOAT_FIELD(klass, name) FIELD(name, jfloat, float_field, EMPTY_CAST)
 343 #define OOP_FIELD(klass, name, signature) FIELD(name, oop, obj_field, EMPTY_CAST)
 344 #define OBJARRAYOOP_FIELD(klass, name, signature) FIELD(name, objArrayOop, obj_field, (objArrayOop))
 345 #define TYPEARRAYOOP_FIELD(klass, name, signature) FIELD(name, typeArrayOop, obj_field, (typeArrayOop))
 346 #define STATIC_OOP_FIELD(klassName, name, signature) STATIC_OOPISH_FIELD(klassName, name, oop, signature)
 347 #define STATIC_OBJARRAYOOP_FIELD(klassName, name, signature) STATIC_OOPISH_FIELD(klassName, name, objArrayOop, signature)
 348 #define STATIC_OOPISH_FIELD(klassName, name, type, signature)                                                  \
 349     static int _##name##_offset;                                                                               \
 350     static type name() {                                                                                       \
 351       assert(klassName::klass() != NULL && klassName::klass()->is_linked(), "Class not yet linked: " #klassName); \
 352       InstanceKlass* ik = klassName::klass();                                                                  \
 353       address addr = ik->static_field_addr(_##name##_offset - InstanceMirrorKlass::offset_of_static_fields()); \
 354       if (UseCompressedOops) {                                                                                 \
 355         return (type) oopDesc::load_decode_heap_oop((narrowOop *)addr);                                        \
 356       } else {                                                                                                 \
 357         return (type) oopDesc::load_decode_heap_oop((oop*)addr);                                               \
 358       }                                                                                                        \
 359     }                                                                                                          \
 360     static void set_##name(type x) {                                                                           \
 361       assert(klassName::klass() != NULL && klassName::klass()->is_linked(), "Class not yet linked: " #klassName); \
 362       assert(klassName::klass() != NULL, "Class not yet loaded: " #klassName);                                 \
 363       InstanceKlass* ik = klassName::klass();                                                                  \
 364       address addr = ik->static_field_addr(_##name##_offset - InstanceMirrorKlass::offset_of_static_fields()); \
 365       if (UseCompressedOops) {                                                                                 \
 366         oop_store((narrowOop *)addr, x);                                                                       \
 367       } else {                                                                                                 \
 368         oop_store((oop*)addr, x);                                                                              \
 369       }                                                                                                        \
 370     }
 371 #define STATIC_PRIMITIVE_FIELD(klassName, name, jtypename)                                                     \
 372     static int _##name##_offset;                                                                               \
 373     static jtypename name() {                                                                                  \
 374       assert(klassName::klass() != NULL && klassName::klass()->is_linked(), "Class not yet linked: " #klassName); \
 375       InstanceKlass* ik = klassName::klass();                                                                  \
 376       address addr = ik->static_field_addr(_##name##_offset - InstanceMirrorKlass::offset_of_static_fields()); \
 377       return *((jtypename *)addr);                                                                             \
 378     }                                                                                                          \
 379     static void set_##name(jtypename x) {                                                                      \
 380       assert(klassName::klass() != NULL && klassName::klass()->is_linked(), "Class not yet linked: " #klassName); \
 381       InstanceKlass* ik = klassName::klass();                                                                  \
 382       address addr = ik->static_field_addr(_##name##_offset - InstanceMirrorKlass::offset_of_static_fields()); \
 383       *((jtypename *)addr) = x;                                                                                \
 384     }
 385 
 386 #define STATIC_INT_FIELD(klassName, name) STATIC_PRIMITIVE_FIELD(klassName, name, jint)
 387 #define STATIC_BOOLEAN_FIELD(klassName, name) STATIC_PRIMITIVE_FIELD(klassName, name, jboolean)
 388 
 389 COMPILER_CLASSES_DO(START_CLASS, END_CLASS, CHAR_FIELD, INT_FIELD, BOOLEAN_FIELD, LONG_FIELD, FLOAT_FIELD, OOP_FIELD, TYPEARRAYOOP_FIELD, OBJARRAYOOP_FIELD, STATIC_OOP_FIELD, STATIC_OBJARRAYOOP_FIELD, STATIC_INT_FIELD, STATIC_BOOLEAN_FIELD)
 390 #undef START_CLASS
 391 #undef END_CLASS
 392 #undef FIELD
 393 #undef CHAR_FIELD
 394 #undef INT_FIELD
 395 #undef BOOLEAN_FIELD
 396 #undef LONG_FIELD
 397 #undef FLOAT_FIELD
 398 #undef OOP_FIELD
 399 #undef TYPEARRAYOOP_FIELD
 400 #undef OBJARRAYOOP_FIELD
 401 #undef STATIC_OOPISH_FIELD
 402 #undef STATIC_OOP_FIELD
 403 #undef STATIC_OBJARRAYOOP_FIELD


  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 #ifndef SHARE_VM_JVMCI_JVMCIJAVACLASSES_HPP
  25 #define SHARE_VM_JVMCI_JVMCIJAVACLASSES_HPP
  26 
  27 #include "classfile/systemDictionary.hpp"
  28 #include "oops/instanceMirrorKlass.hpp"
  29 #include "oops/oop.inline.hpp"
  30 #include "runtime/access.inline.hpp"
  31 
  32 class JVMCIJavaClasses : AllStatic {
  33  public:
  34   static void compute_offsets(TRAPS);
  35 };
  36 
  37 /* This macro defines the structure of the JVMCI classes accessed from VM code.
  38  * It will generate classes with accessors similar to javaClasses.hpp, but with specializations for oops, Handles and jni handles.
  39  *
  40  * The public interface of these classes will look like this:
  41 
  42  * class StackSlot : AllStatic {
  43  * public:
  44  *   static Klass* klass();
  45  *   static jint  index(oop obj);
  46  *   static jint  index(Handle obj);
  47  *   static jint  index(jobject obj);
  48  *   static void set_index(oop obj, jint x);
  49  *   static void set_index(Handle obj, jint x);
  50  *   static void set_index(jobject obj, jint x);


 335     static void set_##name(Handle obj, type x)  { check(obj(), #name, _##name##_offset); obj->accessor##_put(_##name##_offset, x); }                                                \
 336     static void set_##name(jobject obj, type x) { check(JNIHandles::resolve(obj), #name, _##name##_offset); JNIHandles::resolve(obj)->accessor##_put(_##name##_offset, x); }
 337 
 338 #define EMPTY_CAST
 339 #define CHAR_FIELD(klass, name) FIELD(name, jchar, char_field, EMPTY_CAST)
 340 #define INT_FIELD(klass, name) FIELD(name, jint, int_field, EMPTY_CAST)
 341 #define BOOLEAN_FIELD(klass, name) FIELD(name, jboolean, bool_field, EMPTY_CAST)
 342 #define LONG_FIELD(klass, name) FIELD(name, jlong, long_field, EMPTY_CAST)
 343 #define FLOAT_FIELD(klass, name) FIELD(name, jfloat, float_field, EMPTY_CAST)
 344 #define OOP_FIELD(klass, name, signature) FIELD(name, oop, obj_field, EMPTY_CAST)
 345 #define OBJARRAYOOP_FIELD(klass, name, signature) FIELD(name, objArrayOop, obj_field, (objArrayOop))
 346 #define TYPEARRAYOOP_FIELD(klass, name, signature) FIELD(name, typeArrayOop, obj_field, (typeArrayOop))
 347 #define STATIC_OOP_FIELD(klassName, name, signature) STATIC_OOPISH_FIELD(klassName, name, oop, signature)
 348 #define STATIC_OBJARRAYOOP_FIELD(klassName, name, signature) STATIC_OOPISH_FIELD(klassName, name, objArrayOop, signature)
 349 #define STATIC_OOPISH_FIELD(klassName, name, type, signature)                                                  \
 350     static int _##name##_offset;                                                                               \
 351     static type name() {                                                                                       \
 352       assert(klassName::klass() != NULL && klassName::klass()->is_linked(), "Class not yet linked: " #klassName); \
 353       InstanceKlass* ik = klassName::klass();                                                                  \
 354       address addr = ik->static_field_addr(_##name##_offset - InstanceMirrorKlass::offset_of_static_fields()); \
 355       return HeapAccess<>::oop_load((HeapWord*)addr);                     \




 356     }                                                                                                          \
 357     static void set_##name(type x) {                                                                           \
 358       assert(klassName::klass() != NULL && klassName::klass()->is_linked(), "Class not yet linked: " #klassName); \
 359       assert(klassName::klass() != NULL, "Class not yet loaded: " #klassName);                                 \
 360       InstanceKlass* ik = klassName::klass();                                                                  \
 361       address addr = ik->static_field_addr(_##name##_offset - InstanceMirrorKlass::offset_of_static_fields()); \
 362       HeapAccess<>::oop_store((HeapWord*)addr, x);                               \




 363     }
 364 #define STATIC_PRIMITIVE_FIELD(klassName, name, jtypename)                                                     \
 365     static int _##name##_offset;                                                                               \
 366     static jtypename name() {                                                                                  \
 367       assert(klassName::klass() != NULL && klassName::klass()->is_linked(), "Class not yet linked: " #klassName); \
 368       InstanceKlass* ik = klassName::klass();                                                                  \
 369       address addr = ik->static_field_addr(_##name##_offset - InstanceMirrorKlass::offset_of_static_fields()); \
 370       return HeapAccess<>::load((jtypename*)addr);                                \
 371     }                                                                                                          \
 372     static void set_##name(jtypename x) {                                                                      \
 373       assert(klassName::klass() != NULL && klassName::klass()->is_linked(), "Class not yet linked: " #klassName); \
 374       InstanceKlass* ik = klassName::klass();                                                                  \
 375       address addr = ik->static_field_addr(_##name##_offset - InstanceMirrorKlass::offset_of_static_fields()); \
 376       HeapAccess<>::store((jtypename*)addr, x);                                                                            \
 377     }
 378 
 379 #define STATIC_INT_FIELD(klassName, name) STATIC_PRIMITIVE_FIELD(klassName, name, jint)
 380 #define STATIC_BOOLEAN_FIELD(klassName, name) STATIC_PRIMITIVE_FIELD(klassName, name, jboolean)
 381 
 382 COMPILER_CLASSES_DO(START_CLASS, END_CLASS, CHAR_FIELD, INT_FIELD, BOOLEAN_FIELD, LONG_FIELD, FLOAT_FIELD, OOP_FIELD, TYPEARRAYOOP_FIELD, OBJARRAYOOP_FIELD, STATIC_OOP_FIELD, STATIC_OBJARRAYOOP_FIELD, STATIC_INT_FIELD, STATIC_BOOLEAN_FIELD)
 383 #undef START_CLASS
 384 #undef END_CLASS
 385 #undef FIELD
 386 #undef CHAR_FIELD
 387 #undef INT_FIELD
 388 #undef BOOLEAN_FIELD
 389 #undef LONG_FIELD
 390 #undef FLOAT_FIELD
 391 #undef OOP_FIELD
 392 #undef TYPEARRAYOOP_FIELD
 393 #undef OBJARRAYOOP_FIELD
 394 #undef STATIC_OOPISH_FIELD
 395 #undef STATIC_OOP_FIELD
 396 #undef STATIC_OBJARRAYOOP_FIELD
< prev index next >