[lworld] RFR: 8249257 Rename ValueKlass to InlineKlass

Frederic Parain fparain at openjdk.java.net
Wed Jul 15 18:37:42 UTC 2020


On Wed, 15 Jul 2020 16:55:47 GMT, Harold Seigel <hseigel at openjdk.org> wrote:

> Please review this tedious change.  It renames class ValueKlass to InlineKlass and renames its fields and methods.  It
> does not rename ValueArrayKlass.  That will be a future change.
> Also, this change does not rename things defined in gc or jit source files.
> 
> The change was tested with tiers 1 and 2 on Mac, Windows, and Linux x64, and tiers 3-5 on Linux x64.
> 
> Thanks, Harold

Marked as reviewed by fparain (Committer).

src/hotspot/cpu/x86/macroAssembler_x86.hpp line 111:

> 110:   // The empty value oop, for the given InlineKlass ("empty" as in no instance fields)
> 111:   // get_default_value_oop with extra assertion for empty value klass
> 112:   void get_empty_value_oop(Register value_klass, Register temp_reg, Register obj);

empty value klass -> empty inline klass

src/hotspot/share/memory/oopFactory.cpp line 42:

> 41: #include "oops/typeArrayOop.inline.hpp"
> 42: #include "oops/inlineKlass.hpp"
> 43: #include "oops/valueArrayKlass.hpp"

Do we really need this include?
InlineKlass is not used directly in this file, ValueArrayKlass is used and valueArrayKlass.hpp includes inlineKlass.hpp.

src/hotspot/share/oops/inlineKlass.hpp line 190:

> 189:   // Use this to return the size of an instance in heap words
> 190:   // Implementation is currently simple because all inline types are allocated
> 191:   // in Java heap like Java objects.

This comment might need an update, because now, not all inline types are allocated in the Java heap.
May be just specifying this size only applies to heap allocated standalone instances.

src/hotspot/share/opto/escape.cpp line 3251:

> 3250:         assert(Metaspace::contains((void*)ptr), "should be klass");
> 3251:         assert(((InlineKlass*)ptr)->contains_oops(), "returned value type must contain a reference field");
> 3252:       } else {

returned value type -> returned inline type

src/hotspot/share/runtime/deoptimization.cpp line 1394:

> 1393:
> 1394: // restore fields of an eliminated value type array
> 1395: void Deoptimization::reassign_value_array_elements(frame* fr, RegisterMap* reg_map, ObjectValue* sv,
> valueArrayOop obj, ValueArrayKlass* vak, TRAPS) {

value type array -> inline type array

src/hotspot/share/runtime/deoptimization.cpp line 1397:

> 1396:   InlineKlass* vk = vak->element_klass();
> 1397:   assert(vk->flatten_array(), "should only be used for flattened value type arrays");
> 1398:   // Adjust offset to omit oop header

flattened value type array -> flattened inline type array

src/hotspot/share/runtime/sharedRuntime.cpp line 2836:

> 2835: void CompiledEntrySignature::compute_calling_conventions() {
> 2836:   // Get the (non-scalarized) signature and check for value type arguments
> 2837:   if (!_method->is_static()) {

value type arguments -> inline type arguments

src/hotspot/share/runtime/signature.hpp line 575:

> 574: // Used for adapter generation. One SigEntry is used per element of
> 575: // the signature of the method. Value type arguments are treated
> 576: // specially. See comment for InlineKlass::collect_fields().

Value type argument -> Inline type argument

-------------

PR: https://git.openjdk.java.net/valhalla/pull/109


More information about the valhalla-dev mailing list