graal-compiler: src/share/vm/oops/constantPool.hpp comparison

comparison src/share/vm/oops/constantPool.hpp @ 8124:5fc51c1ecdeb

Merge.

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Tue, 05 Mar 2013 23:44:54 +0100
parents	3ac7d10a6572 f16e75e0cf11
children	836a62f43af9

comparison

equal deleted inserted replaced

-:a413bcd552a4
+:5fc51c1ecdeb
 assert(is_resolved(), "bad call");
 return (Klass*)_ptr;
 }
 };
+class KlassSizeStats;
 class ConstantPool : public Metadata {
 friend class VMStructs;
 friend class BytecodeInterpreter;  // Directly extracts an oop in the pool for fast instanceof/checkcast
 friend class Universe;             // For null constructor
 private:
 // Array of resolved objects from the constant pool and map from resolved
 // object index to original constant pool index
 jobject              _resolved_references;
 Array<u2>*           _reference_map;
-int                  _flags;         // a few header bits to describe contents for GC
+enum {
+_has_preresolution = 1,           // Flags
+_on_stack          = 2
+};
+int                  _flags;  // old fashioned bit twiddling
 int                  _length; // number of elements in the array
-bool                 _on_stack;     // Redefined method still executing refers to this constant pool.
 union {
 // set for CDS to restore resolved references
 int                _resolved_reference_length;
 // keeps version number for redefined classes (used in backtrace)
 void tag_at_put(int which, jbyte t)          { tags()->at_put(which, t); }
 void release_tag_at_put(int which, jbyte t)  { tags()->release_at_put(which, t); }
 void set_operands(Array<u2>* operands)       { _operands = operands; }
-enum FlagBit {
+int flags() const                            { return _flags; }
-FB_has_invokedynamic = 1,
+void set_flags(int f)                        { _flags = f; }
-FB_has_pseudo_string = 2,
-FB_has_preresolution = 3
-};
-int flags() const                         { return _flags; }
-void set_flags(int f)                     { _flags = f; }
-bool flag_at(FlagBit fb) const            { return (_flags & (1 << (int)fb)) != 0; }
-void set_flag_at(FlagBit fb);
-// no clear_flag_at function; they only increase
 private:
 intptr_t* base() const { return (intptr_t*) (((char*) this) + sizeof(ConstantPool)); }
 CPSlot slot_at(int which) {
 bool is_constantPool() const volatile     { return true; }
 Array<u1>* tags() const                   { return _tags; }
 Array<u2>* operands() const               { return _operands; }
-bool has_pseudo_string() const            { return flag_at(FB_has_pseudo_string); }
+bool has_preresolution() const            { return (_flags & _has_preresolution) != 0; }
-bool has_invokedynamic() const            { return flag_at(FB_has_invokedynamic); }
+void set_has_preresolution()              { _flags |= _has_preresolution; }
-bool has_preresolution() const            { return flag_at(FB_has_preresolution); }
-void set_pseudo_string()                  {    set_flag_at(FB_has_pseudo_string); }
-void set_invokedynamic()                  {    set_flag_at(FB_has_invokedynamic); }
-void set_preresolution()                  {    set_flag_at(FB_has_preresolution); }
 // Redefine classes support.  If a method refering to this constant pool
 // is on the executing stack, or as a handle in vm code, this constant pool
 // can't be removed from the set of previous versions saved in the instance
 // class.
-bool on_stack() const                     { return _on_stack; }
+bool on_stack() const                      { return (_flags &_on_stack) != 0; }
 void set_on_stack(const bool value);
 // Klass holding pool
 InstanceKlass* pool_holder() const      { return _pool_holder; }
 void set_pool_holder(InstanceKlass* k)  { _pool_holder = k; }
 void string_at_put(int which, int obj_index, oop str) {
 resolved_references()->obj_at_put(obj_index, str);
 }
-void set_object_tag_at(int which) {
-release_tag_at_put(which, JVM_CONSTANT_Object);
-}
-void object_at_put(int which, oop obj) {
-resolved_references()->obj_at_put(cp_to_object_index(which), obj);
-}
 // For temporary use while constructing constant pool
 void string_index_at_put(int which, int string_index) {
 tag_at_put(which, JVM_CONSTANT_StringIndex);
 *int_at_addr(which) = string_index;
 }
 }
 // Version that can be used before string oop array is created.
 oop uncached_string_at(int which, TRAPS);
-oop object_at(int which) {
-assert(tag_at(which).is_object(), "Corrupted constant pool");
-int obj_index = cp_to_object_index(which);
-return resolved_references()->obj_at(obj_index);
-}
 // A "pseudo-string" is an non-string oop that has found is way into
 // a String entry.
 // Under EnableInvokeDynamic this can happen if the user patches a live
 // object into a CONSTANT_String entry of an anonymous class.
 // Method oops internally created for method handles may also
 assert(unresolved_string_at(which) == NULL, "shouldn't have symbol");
 oop s = resolved_references()->obj_at(obj_index);
 return s;
 }
+oop pseudo_string_at(int which) {
+assert(tag_at(which).is_string(), "Corrupted constant pool");
+assert(unresolved_string_at(which) == NULL, "shouldn't have symbol");
+int obj_index = cp_to_object_index(which);
+oop s = resolved_references()->obj_at(obj_index);
+return s;
+}
 void pseudo_string_at_put(int which, int obj_index, oop x) {
 assert(EnableInvokeDynamic, "");
-set_pseudo_string();        // mark header
 assert(tag_at(which).is_string(), "Corrupted constant pool");
+unresolved_string_at_put(which, NULL); // indicates patched string
 string_at_put(which, obj_index, x);    // this works just fine
 }
 // only called when we are sure a string entry is already resolved (via an
 // earlier string_at call.
 // Tells whether index is within bounds.
 bool is_within_bounds(int index) const {
 return 0 <= index && index < length();
 }
+// Sizing (in words)
 static int header_size()             { return sizeof(ConstantPool)/HeapWordSize; }
 static int size(int length)          { return align_object_size(header_size() + length); }
 int size() const                     { return size(length()); }
+#if INCLUDE_SERVICES
+void collect_statistics(KlassSizeStats *sz) const;
+#endif
 friend class ClassFileParser;
 friend class SystemDictionary;
 // Used by compiler to prevent classloading.
 constantPoolHandle h_this(THREAD, this);
 copy_cp_to_impl(h_this, start_i, end_i, to_cp, to_i, THREAD);
 }
 static void copy_cp_to_impl(constantPoolHandle from_cp, int start_i, int end_i, constantPoolHandle to_cp, int to_i, TRAPS);
 static void copy_entry_to(constantPoolHandle from_cp, int from_i, constantPoolHandle to_cp, int to_i, TRAPS);
+static void copy_operands(constantPoolHandle from_cp, constantPoolHandle to_cp, TRAPS);
 int  find_matching_entry(int pattern_i, constantPoolHandle search_cp, TRAPS);
 int  version() const                    { return _saved._version; }
 void set_version(int version)           { _saved._version = version; }
 void increment_and_save_version(int version) {
 _saved._version = version >= 0 ? (version + 1) : version;  // keep overflow

Mercurial > hg > graal-compiler

comparison src/share/vm/oops/constantPool.hpp @ 8124:5fc51c1ecdeb