truffle: src/share/vm/oops/constantPoolOop.hpp comparison

comparison src/share/vm/oops/constantPoolOop.hpp @ 1339:09ac706c2623

Merge

author	asaha
date	Wed, 24 Mar 2010 17:16:33 -0700
parents	dd57230ba8fe
children	c18cbe5936b8 ab102d5d923e

comparison

equal deleted inserted replaced

-:f5dd08ad65df
+:09ac706c2623
 // marking thread before the tag was updated, redirty the card.
 oop_store_without_check((volatile oop *)obj_at_addr(which), str);
 }
 }
+void object_at_put(int which, oop str) {
+oop_store((volatile oop*) obj_at_addr(which), str);
+release_tag_at_put(which, JVM_CONSTANT_Object);
+if (UseConcMarkSweepGC) {
+// In case the earlier card-mark was consumed by a concurrent
+// marking thread before the tag was updated, redirty the card.
+oop_store_without_check((volatile oop*) obj_at_addr(which), str);
+}
+}
 // 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;
 }
 constantTag tag = tag_at(which);
 return tag.is_klass() ||
 tag.is_unresolved_klass() ||
 tag.is_symbol() ||
 tag.is_unresolved_string() ||
-tag.is_string();
+tag.is_string() ||
+tag.is_object();
 }
 // Fetching constants
 klassOop klass_at(int which, TRAPS) {
 }
 oop string_at(int which, TRAPS) {
 constantPoolHandle h_this(THREAD, this);
 return string_at_impl(h_this, which, CHECK_NULL);
+}
+oop object_at(int which) {
+assert(tag_at(which).is_object(), "Corrupted constant pool");
+return *obj_at_addr(which);
 }
 // A "pseudo-string" is an non-string oop that has found is way into
 // a String entry.
 // Under AnonymousClasses this can happen if the user patches a live
 assert(tag_at(which).is_name_and_type(), "Corrupted constant pool");
 return *int_at_addr(which);
 }
 // The following methods (name/signature/klass_ref_at, klass_ref_at_noresolve,
-// name_and_type_ref_index_at) all expect constant pool indices
+// name_and_type_ref_index_at) all expect to be passed indices obtained
-// from the bytecodes to be passed in, which are actually potentially byte-swapped
+// directly from the bytecode, and extracted according to java byte order.
-// or rewritten constant pool cache indices.  They all call map_instruction_operand_to_index.
+// If the indices are meant to refer to fields or methods, they are
-int map_instruction_operand_to_index(int operand);
+// actually potentially byte-swapped, rewritten constant pool cache indices.
+// The routine remap_instruction_operand_from_cache manages the adjustment
-// There are also "uncached" versions which do not map the operand index; see below.
+// of these values back to constant pool indices.
+// There are also "uncached" versions which do not adjust the operand index; see below.
 // Lookup for entries consisting of (klass_index, name_and_type index)
 klassOop klass_ref_at(int which, TRAPS);
 symbolOop klass_ref_at_noresolve(int which);
 symbolOop name_ref_at(int which)                { return impl_name_ref_at(which, false); }
 int name_and_type_ref_index_at(int which)       { return impl_name_and_type_ref_index_at(which, false); }
 // Lookup for entries consisting of (name_index, signature_index)
 int name_ref_index_at(int which_nt);            // ==  low-order jshort of name_and_type_at(which_nt)
 int signature_ref_index_at(int which_nt);       // == high-order jshort of name_and_type_at(which_nt)
-symbolOop nt_name_ref_at(int which_nt)          { return symbol_at(name_ref_index_at(which_nt)); }
-symbolOop nt_signature_ref_at(int which_nt)     { return symbol_at(signature_ref_index_at(which_nt)); }
 BasicType basic_type_for_signature_at(int which);
 // Resolve string constants (to prevent allocation during compilation)
 void resolve_string_constants(TRAPS) {
 symbolOop impl_name_ref_at(int which, bool uncached);
 symbolOop impl_signature_ref_at(int which, bool uncached);
 int       impl_klass_ref_index_at(int which, bool uncached);
 int       impl_name_and_type_ref_index_at(int which, bool uncached);
-// Takes either a constant pool cache index in possibly byte-swapped
+int remap_instruction_operand_from_cache(int operand);
-// byte order (which comes from the bytecodes after rewriting) or,
-// if "uncached" is true, a vanilla constant pool index
-jint field_or_method_at(int which, bool uncached) {
-int i = which;
-if (!uncached && cache() != NULL) {
-// change byte-ordering and go via cache
-i = map_instruction_operand_to_index(which);
-}
-assert(tag_at(i).is_field_or_method(), "Corrupted constant pool");
-return *int_at_addr(i);
-}
 // Used while constructing constant pool (only by ClassFileParser)
 jint klass_index_at(int which) {
 assert(tag_at(which).is_klass_index(), "Corrupted constant pool");
 return *int_at_addr(which);

Mercurial > hg > truffle

comparison src/share/vm/oops/constantPoolOop.hpp @ 1339:09ac706c2623