stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge

Browse Source
This commit is contained in:
Rickard Bäckman 2012-10-09 07:41:27 +02:00
commit 25e07fb041
91 changed files with 575 additions and 499 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ArrayKlass.java
View File

@ -44,7 +44,7 @@ public class ArrayKlass extends Klass {
}
private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
Type type = db.lookupType("arrayKlass");
Type type = db.lookupType("ArrayKlass");
dimension = new CIntField(type.getCIntegerField("_dimension"), 0);
higherDimension = new MetadataField(type.getAddressField("_higher_dimension"), 0);
lowerDimension = new MetadataField(type.getAddressField("_lower_dimension"), 0);

4
hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Klass.java
View File

@ -188,11 +188,11 @@ public class Klass extends Metadata implements ClassConstants {
public Klass arrayKlassOrNull() { return arrayKlassImpl(true); }
public Klass arrayKlassImpl(boolean orNull, int rank) {
throw new RuntimeException("array_klass should be dispatched to InstanceKlass, objArrayKlass or typeArrayKlass");
throw new RuntimeException("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass");
}
public Klass arrayKlassImpl(boolean orNull) {
throw new RuntimeException("array_klass should be dispatched to InstanceKlass, objArrayKlass or typeArrayKlass");
throw new RuntimeException("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass");
}
// This returns the name in the form java/lang/String which isn't really a signature

4
hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Metadata.java
View File

@ -55,8 +55,8 @@ abstract public class Metadata extends VMObject {
metadataConstructor.addMapping("InstanceMirrorKlass", InstanceMirrorKlass.class);
metadataConstructor.addMapping("InstanceRefKlass", InstanceRefKlass.class);
metadataConstructor.addMapping("InstanceClassLoaderKlass", InstanceClassLoaderKlass.class);
metadataConstructor.addMapping("typeArrayKlass", TypeArrayKlass.class);
metadataConstructor.addMapping("objArrayKlass", ObjArrayKlass.class);
metadataConstructor.addMapping("TypeArrayKlass", TypeArrayKlass.class);
metadataConstructor.addMapping("ObjArrayKlass", ObjArrayKlass.class);
metadataConstructor.addMapping("Method", Method.class);
metadataConstructor.addMapping("MethodData", MethodData.class);
metadataConstructor.addMapping("ConstMethod", ConstMethod.class);

2
hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ObjArrayKlass.java
View File

@ -43,7 +43,7 @@ public class ObjArrayKlass extends ArrayKlass {
}
private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
Type type = db.lookupType("objArrayKlass");
Type type = db.lookupType("ObjArrayKlass");
elementKlass = new MetadataField(type.getAddressField("_element_klass"), 0);
bottomKlass = new MetadataField(type.getAddressField("_bottom_klass"), 0);
}

4
hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/TypeArrayKlass.java
View File

@ -31,7 +31,7 @@ import sun.jvm.hotspot.runtime.*;
import sun.jvm.hotspot.types.*;
import sun.jvm.hotspot.utilities.*;
// TypeArrayKlass is a proxy for typeArrayKlass in the JVM
// TypeArrayKlass is a proxy for TypeArrayKlass in the JVM
public class TypeArrayKlass extends ArrayKlass {
static {
@ -43,7 +43,7 @@ public class TypeArrayKlass extends ArrayKlass {
}
private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
Type t = db.lookupType("typeArrayKlass");
Type t = db.lookupType("TypeArrayKlass");
maxLength = new CIntField(t.getCIntegerField("_max_length"), 0);
}

9
hotspot/agent/src/share/classes/sun/jvm/hotspot/tools/jcore/ClassWriter.java
View File

@ -354,15 +354,14 @@ public class ClassWriter implements /* imports */ ClassConstants
}
protected void writeFields() throws IOException {
U2Array fields = klass.getFields();
final int length = (int) fields.length();
final int javaFieldsCount = klass.getJavaFieldsCount();
// write number of fields
dos.writeShort((short) length);
dos.writeShort((short) javaFieldsCount);
if (DEBUG) debugMessage("number of fields = " + length);
if (DEBUG) debugMessage("number of fields = " + javaFieldsCount);
for (int index = 0; index < length; index++) {
for (int index = 0; index < javaFieldsCount; index++) {
short accessFlags = klass.getFieldAccessFlags(index);
dos.writeShort(accessFlags & (short) JVM_RECOGNIZED_FIELD_MODIFIERS);

2
hotspot/agent/src/share/native/sadis.c
View File

@ -46,7 +46,7 @@
#else
#include <strings.h>
#include <string.h>
#include <dlfcn.h>
#include <link.h>

8
hotspot/make/bsd/makefiles/buildtree.make
View File

@ -163,6 +163,13 @@ ifndef HOTSPOT_VM_DISTRO
endif
endif
# if hotspot-only build and/or OPENJDK isn't passed down, need to set OPENJDK
ifndef OPENJDK
ifneq ($(call if-has-altsrc,$(HS_COMMON_SRC)/,true,false),true)
OPENJDK=true
endif
endif
BUILDTREE_VARS += HOTSPOT_RELEASE_VERSION=$(HS_BUILD_VER) HOTSPOT_BUILD_VERSION= JRE_RELEASE_VERSION=$(JRE_RELEASE_VERSION)
BUILDTREE = \
@ -205,6 +212,7 @@ flags.make: $(BUILDTREE_MAKE) ../shared_dirs.lst
echo "SA_BUILD_VERSION = $(HS_BUILD_VER)"; \
echo "HOTSPOT_BUILD_USER = $(HOTSPOT_BUILD_USER)"; \
echo "HOTSPOT_VM_DISTRO = $(HOTSPOT_VM_DISTRO)"; \
echo "OPENJDK = $(OPENJDK)"; \
echo; \
echo "# Used for platform dispatching"; \
echo "TARGET_DEFINES = -DTARGET_OS_FAMILY_\$$(Platform_os_family)"; \

8
hotspot/make/linux/makefiles/buildtree.make
View File

@ -156,6 +156,13 @@ ifndef HOTSPOT_VM_DISTRO
endif
endif
# if hotspot-only build and/or OPENJDK isn't passed down, need to set OPENJDK
ifndef OPENJDK
ifneq ($(call if-has-altsrc,$(HS_COMMON_SRC)/,true,false),true)
OPENJDK=true
endif
endif
BUILDTREE_VARS += HOTSPOT_RELEASE_VERSION=$(HS_BUILD_VER) HOTSPOT_BUILD_VERSION= JRE_RELEASE_VERSION=$(JRE_RELEASE_VERSION)
BUILDTREE = \
@ -198,6 +205,7 @@ flags.make: $(BUILDTREE_MAKE) ../shared_dirs.lst
echo "SA_BUILD_VERSION = $(HS_BUILD_VER)"; \
echo "HOTSPOT_BUILD_USER = $(HOTSPOT_BUILD_USER)"; \
echo "HOTSPOT_VM_DISTRO = $(HOTSPOT_VM_DISTRO)"; \
echo "OPENJDK = $(OPENJDK)"; \
echo; \
echo "# Used for platform dispatching"; \
echo "TARGET_DEFINES = -DTARGET_OS_FAMILY_\$$(Platform_os_family)"; \

40
hotspot/make/linux/makefiles/dtrace.make
View File

@ -1,5 +1,6 @@
#
# Copyright (c) 2005, 2008, Oracle and/or its affiliates. All rights reserved.
# Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved.
# Copyright (c) 2012 Red Hat, Inc.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@ -25,3 +26,40 @@
# Linux does not build jvm_db
LIBJVM_DB =
# Only OPENJDK builds test and support SDT probes currently.
ifndef OPENJDK
REASON = "This JDK does not support SDT probes"
else
# We need a recent GCC for the default
ifeq "$(shell expr \( $(CC_VER_MAJOR) \>= 4 \) \& \( $(CC_VER_MINOR) \>= 4 \) )" "0"
REASON = "gcc version is too old"
else
# But it does have a SystemTap dtrace compatible sys/sdt.h
ifneq ($(ALT_SDT_H),)
SDT_H_FILE = $(ALT_SDT_H)
else
SDT_H_FILE = /usr/include/sys/sdt.h
endif
DTRACE_ENABLED = $(shell test -f $(SDT_H_FILE) && echo $(SDT_H_FILE))
REASON = "$(SDT_H_FILE) not found"
ifneq ($(DTRACE_ENABLED),)
CFLAGS += -DDTRACE_ENABLED
endif
endif
endif
# Phony target used in vm.make build target to check whether enabled.
.PHONY: dtraceCheck
ifeq ($(DTRACE_ENABLED),)
dtraceCheck:
$(QUIETLY) echo "**NOTICE** Dtrace support disabled: $(REASON)"
else
dtraceCheck:
endif
# It doesn't support HAVE_DTRACE_H though.

2
hotspot/make/linux/makefiles/vm.make
View File

@ -387,7 +387,7 @@ include $(MAKEFILES_DIR)/wb.make
#----------------------------------------------------------------------
build: $(LIBJVM) $(LAUNCHER) $(LIBJSIG) $(LIBJVM_DB) $(BUILDLIBSAPROC) $(WB_JAR)
build: $(LIBJVM) $(LAUNCHER) $(LIBJSIG) $(LIBJVM_DB) $(BUILDLIBSAPROC) dtraceCheck $(WB_JAR)
install: install_jvm install_jsig install_saproc

8
hotspot/make/solaris/makefiles/buildtree.make
View File

@ -148,6 +148,13 @@ ifndef HOTSPOT_VM_DISTRO
endif
endif
# if hotspot-only build and/or OPENJDK isn't passed down, need to set OPENJDK
ifndef OPENJDK
ifneq ($(call if-has-altsrc,$(HS_COMMON_SRC)/,true,false),true)
OPENJDK=true
endif
endif
BUILDTREE_VARS += HOTSPOT_RELEASE_VERSION=$(HS_BUILD_VER) HOTSPOT_BUILD_VERSION= JRE_RELEASE_VERSION=$(JRE_RELEASE_VERSION)
BUILDTREE = \
@ -190,6 +197,7 @@ flags.make: $(BUILDTREE_MAKE) ../shared_dirs.lst
echo "SA_BUILD_VERSION = $(HS_BUILD_VER)"; \
echo "HOTSPOT_BUILD_USER = $(HOTSPOT_BUILD_USER)"; \
echo "HOTSPOT_VM_DISTRO = $(HOTSPOT_VM_DISTRO)"; \
echo "OPENJDK = $(OPENJDK)"; \
echo "$(LP64_SETTING/$(DATA_MODE))"; \
echo; \
echo "# Used for platform dispatching"; \

4
hotspot/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp
View File

@ -2290,7 +2290,7 @@ void LIR_Assembler::emit_arraycopy(LIR_OpArrayCopy* op) {
__ mov(length, len);
__ load_klass(dst, tmp);
int ek_offset = in_bytes(objArrayKlass::element_klass_offset());
int ek_offset = in_bytes(ObjArrayKlass::element_klass_offset());
__ ld_ptr(tmp, ek_offset, super_k);
int sco_offset = in_bytes(Klass::super_check_offset_offset());
@ -2781,7 +2781,7 @@ void LIR_Assembler::emit_opTypeCheck(LIR_OpTypeCheck* op) {
__ load_klass(value, klass_RInfo);
// get instance klass
__ ld_ptr(Address(k_RInfo, objArrayKlass::element_klass_offset()), k_RInfo);
__ ld_ptr(Address(k_RInfo, ObjArrayKlass::element_klass_offset()), k_RInfo);
// perform the fast part of the checking logic
__ check_klass_subtype_fast_path(klass_RInfo, k_RInfo, Rtmp1, O7, success_target, failure_target, NULL);

8
hotspot/src/cpu/sparc/vm/stubGenerator_sparc.cpp
View File

@ -3091,7 +3091,7 @@ class StubGenerator: public StubCodeGenerator {
arraycopy_range_checks(src, src_pos, dst, dst_pos, length,
O5_temp, G4_dst_klass, L_failed);
// typeArrayKlass
// TypeArrayKlass
//
// src_addr = (src + array_header_in_bytes()) + (src_pos << log2elemsize);
// dst_addr = (dst + array_header_in_bytes()) + (dst_pos << log2elemsize);
@ -3142,7 +3142,7 @@ class StubGenerator: public StubCodeGenerator {
__ br(Assembler::always, false, Assembler::pt, entry_jlong_arraycopy);
__ delayed()->signx(length, count); // length
// objArrayKlass
// ObjArrayKlass
__ BIND(L_objArray);
// live at this point: G3_src_klass, G4_dst_klass, src[_pos], dst[_pos], length
@ -3198,8 +3198,8 @@ class StubGenerator: public StubCodeGenerator {
generate_type_check(G3_src_klass, sco_temp, G4_dst_klass,
O5_temp, L_plain_copy);
// Fetch destination element klass from the objArrayKlass header.
int ek_offset = in_bytes(objArrayKlass::element_klass_offset());
// Fetch destination element klass from the ObjArrayKlass header.
int ek_offset = in_bytes(ObjArrayKlass::element_klass_offset());
// the checkcast_copy loop needs two extra arguments:
__ ld_ptr(G4_dst_klass, ek_offset, O4); // dest elem klass

2
hotspot/src/cpu/sparc/vm/templateTable_sparc.cpp
View File

@ -867,7 +867,7 @@ void TemplateTable::aastore() {
// do fast instanceof cache test
__ ld_ptr(O4, in_bytes(objArrayKlass::element_klass_offset()), O4);
__ ld_ptr(O4, in_bytes(ObjArrayKlass::element_klass_offset()), O4);
assert(Otos_i == O0, "just checking");

34
hotspot/src/cpu/x86/vm/assembler_x86.cpp
View File

@ -1170,26 +1170,11 @@ void Assembler::cmpw(Address dst, int imm16) {
// and stores reg into adr if so; otherwise, the value at adr is loaded into rax,.
// The ZF is set if the compared values were equal, and cleared otherwise.
void Assembler::cmpxchgl(Register reg, Address adr) { // cmpxchg
if (Atomics & 2) {
// caveat: no instructionmark, so this isn't relocatable.
// Emit a synthetic, non-atomic, CAS equivalent.
// Beware. The synthetic form sets all ICCs, not just ZF.
// cmpxchg r,[m] is equivalent to rax, = CAS (m, rax, r)
cmpl(rax, adr);
movl(rax, adr);
if (reg != rax) {
Label L ;
jcc(Assembler::notEqual, L);
movl(adr, reg);
bind(L);
}
} else {
InstructionMark im(this);
prefix(adr, reg);
emit_byte(0x0F);
emit_byte(0xB1);
emit_operand(reg, adr);
}
InstructionMark im(this);
prefix(adr, reg);
emit_byte(0x0F);
emit_byte(0xB1);
emit_operand(reg, adr);
}
void Assembler::comisd(XMMRegister dst, Address src) {
@ -1513,12 +1498,7 @@ void Assembler::leal(Register dst, Address src) {
}
void Assembler::lock() {
if (Atomics & 1) {
// Emit either nothing, a NOP, or a NOP: prefix
emit_byte(0x90) ;
} else {
emit_byte(0xF0);
}
emit_byte(0xF0);
}
void Assembler::lzcntl(Register dst, Register src) {
@ -10616,7 +10596,7 @@ void MacroAssembler::string_indexof(Register str1, Register str2,
// Array header size is 12 bytes in 32-bit VM
// + 6 bytes for 3 chars == 18 bytes,
// enough space to load vec and shift.
assert(HeapWordSize*typeArrayKlass::header_size() >= 12,"sanity");
assert(HeapWordSize*TypeArrayKlass::header_size() >= 12,"sanity");
movdqu(vec, Address(str2, (int_cnt2*2)-16));
psrldq(vec, 16-(int_cnt2*2));
}

8
hotspot/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp
View File

@ -1881,7 +1881,7 @@ void LIR_Assembler::emit_opTypeCheck(LIR_OpTypeCheck* op) {
__ load_klass(klass_RInfo, value);
// get instance klass (it's already uncompressed)
__ movptr(k_RInfo, Address(k_RInfo, objArrayKlass::element_klass_offset()));
__ movptr(k_RInfo, Address(k_RInfo, ObjArrayKlass::element_klass_offset()));
// perform the fast part of the checking logic
__ check_klass_subtype_fast_path(klass_RInfo, k_RInfo, Rtmp1, success_target, failure_target, NULL);
// call out-of-line instance of __ check_klass_subtype_slow_path(...):
@ -3349,7 +3349,7 @@ void LIR_Assembler::emit_arraycopy(LIR_OpArrayCopy* op) {
#ifndef _LP64
__ movptr(tmp, dst_klass_addr);
__ movptr(tmp, Address(tmp, objArrayKlass::element_klass_offset()));
__ movptr(tmp, Address(tmp, ObjArrayKlass::element_klass_offset()));
__ push(tmp);
__ movl(tmp, Address(tmp, Klass::super_check_offset_offset()));
__ push(tmp);
@ -3375,14 +3375,14 @@ void LIR_Assembler::emit_arraycopy(LIR_OpArrayCopy* op) {
// Allocate abi space for args but be sure to keep stack aligned
__ subptr(rsp, 6*wordSize);
__ load_klass(c_rarg3, dst);
__ movptr(c_rarg3, Address(c_rarg3, objArrayKlass::element_klass_offset()));
__ movptr(c_rarg3, Address(c_rarg3, ObjArrayKlass::element_klass_offset()));
store_parameter(c_rarg3, 4);
__ movl(c_rarg3, Address(c_rarg3, Klass::super_check_offset_offset()));
__ call(RuntimeAddress(copyfunc_addr));
__ addptr(rsp, 6*wordSize);
#else
__ load_klass(c_rarg4, dst);
__ movptr(c_rarg4, Address(c_rarg4, objArrayKlass::element_klass_offset()));
__ movptr(c_rarg4, Address(c_rarg4, ObjArrayKlass::element_klass_offset()));
__ movl(c_rarg3, Address(c_rarg4, Klass::super_check_offset_offset()));
__ call(RuntimeAddress(copyfunc_addr));
#endif

6
hotspot/src/cpu/x86/vm/stubGenerator_x86_32.cpp
View File

@ -1801,7 +1801,7 @@ class StubGenerator: public StubCodeGenerator {
assert_different_registers(src, src_pos, dst, dst_pos, rcx_lh);
arraycopy_range_checks(src, src_pos, dst, dst_pos, LENGTH, L_failed);
// typeArrayKlass
// TypeArrayKlass
//
// src_addr = (src + array_header_in_bytes()) + (src_pos << log2elemsize);
// dst_addr = (dst + array_header_in_bytes()) + (dst_pos << log2elemsize);
@ -1864,7 +1864,7 @@ class StubGenerator: public StubCodeGenerator {
__ leave(); // required for proper stackwalking of RuntimeStub frame
__ ret(0);
// objArrayKlass
// ObjArrayKlass
__ BIND(L_objArray);
// live at this point: rcx_src_klass, src[_pos], dst[_pos]
@ -1894,7 +1894,7 @@ class StubGenerator: public StubCodeGenerator {
// live at this point: rcx_src_klass, dst[_pos], src[_pos]
{
// Handy offsets:
int ek_offset = in_bytes(objArrayKlass::element_klass_offset());
int ek_offset = in_bytes(ObjArrayKlass::element_klass_offset());
int sco_offset = in_bytes(Klass::super_check_offset_offset());
Register rsi_dst_klass = rsi;

8
hotspot/src/cpu/x86/vm/stubGenerator_x86_64.cpp
View File

@ -2604,7 +2604,7 @@ class StubGenerator: public StubCodeGenerator {
arraycopy_range_checks(src, src_pos, dst, dst_pos, r11_length,
r10, L_failed);
// typeArrayKlass
// TypeArrayKlass
//
// src_addr = (src + array_header_in_bytes()) + (src_pos << log2elemsize);
// dst_addr = (dst + array_header_in_bytes()) + (dst_pos << log2elemsize);
@ -2670,7 +2670,7 @@ class StubGenerator: public StubCodeGenerator {
__ movl2ptr(count, r11_length); // length
__ jump(RuntimeAddress(long_copy_entry));
// objArrayKlass
// ObjArrayKlass
__ BIND(L_objArray);
// live at this point: r10_src_klass, r11_length, src[_pos], dst[_pos]
@ -2723,8 +2723,8 @@ class StubGenerator: public StubCodeGenerator {
assert_clean_int(sco_temp, rax);
generate_type_check(r10_src_klass, sco_temp, r11_dst_klass, L_plain_copy);
// Fetch destination element klass from the objArrayKlass header.
int ek_offset = in_bytes(objArrayKlass::element_klass_offset());
// Fetch destination element klass from the ObjArrayKlass header.
int ek_offset = in_bytes(ObjArrayKlass::element_klass_offset());
__ movptr(r11_dst_klass, Address(r11_dst_klass, ek_offset));
__ movl( sco_temp, Address(r11_dst_klass, sco_offset));
assert_clean_int(sco_temp, rax);

2
hotspot/src/cpu/x86/vm/templateTable_x86_32.cpp
View File

@ -949,7 +949,7 @@ void TemplateTable::aastore() {
__ load_klass(rbx, rax);
// Move superklass into EAX
__ load_klass(rax, rdx);
__ movptr(rax, Address(rax, objArrayKlass::element_klass_offset()));
__ movptr(rax, Address(rax, ObjArrayKlass::element_klass_offset()));
// Compress array+index*wordSize+12 into a single register. Frees ECX.
__ lea(rdx, element_address);

2
hotspot/src/cpu/x86/vm/templateTable_x86_64.cpp
View File

@ -970,7 +970,7 @@ void TemplateTable::aastore() {
// Move superklass into rax
__ load_klass(rax, rdx);
__ movptr(rax, Address(rax,
objArrayKlass::element_klass_offset()));
ObjArrayKlass::element_klass_offset()));
// Compress array + index*oopSize + 12 into a single register. Frees rcx.
__ lea(rdx, element_address);

8
hotspot/src/cpu/x86/vm/x86_32.ad
View File

@ -12145,8 +12145,8 @@ instruct partialSubtypeCheck( eDIRegP result, eSIRegP sub, eAXRegP super, eCXReg
ins_cost(1100); // slightly larger than the next version
format %{ "MOV EDI,[$sub+Klass::secondary_supers]\n\t"
"MOV ECX,[EDI+arrayKlass::length]\t# length to scan\n\t"
"ADD EDI,arrayKlass::base_offset\t# Skip to start of data; set NZ in case count is zero\n\t"
"MOV ECX,[EDI+ArrayKlass::length]\t# length to scan\n\t"
"ADD EDI,ArrayKlass::base_offset\t# Skip to start of data; set NZ in case count is zero\n\t"
"REPNE SCASD\t# Scan *EDI++ for a match with EAX while CX-- != 0\n\t"
"JNE,s miss\t\t# Missed: EDI not-zero\n\t"
"MOV [$sub+Klass::secondary_super_cache],$super\t# Hit: update cache\n\t"
@ -12164,8 +12164,8 @@ instruct partialSubtypeCheck_vs_Zero( eFlagsReg cr, eSIRegP sub, eAXRegP super,
ins_cost(1000);
format %{ "MOV EDI,[$sub+Klass::secondary_supers]\n\t"
"MOV ECX,[EDI+arrayKlass::length]\t# length to scan\n\t"
"ADD EDI,arrayKlass::base_offset\t# Skip to start of data; set NZ in case count is zero\n\t"
"MOV ECX,[EDI+ArrayKlass::length]\t# length to scan\n\t"
"ADD EDI,ArrayKlass::base_offset\t# Skip to start of data; set NZ in case count is zero\n\t"
"REPNE SCASD\t# Scan *EDI++ for a match with EAX while CX-- != 0\n\t"
"JNE,s miss\t\t# Missed: flags NZ\n\t"
"MOV [$sub+Klass::secondary_super_cache],$super\t# Hit: update cache, flags Z\n\t"

9
hotspot/src/os/windows/vm/jvm_windows.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -61,8 +61,6 @@ typedef struct _MODULEINFO {
typedef int socklen_t;
// #include "jni.h"
#define JNI_ONLOAD_SYMBOLS {"_JNI_OnLoad@8", "JNI_OnLoad"}
#define JNI_ONUNLOAD_SYMBOLS {"_JNI_OnUnload@8", "JNI_OnUnload"}
#define JVM_ONLOAD_SYMBOLS {"_JVM_OnLoad@12", "JVM_OnLoad"}
@ -108,10 +106,7 @@ JVM_GetThreadInterruptEvent();
* File I/O
*/
// #include <sys/types.h>
// #include <sys/stat.h>
// #include <fcntl.h>
// #include <errno.h>
#include <sys/stat.h>
/* O Flags */

12
hotspot/src/share/vm/c1/c1_Runtime1.cpp
View File

@ -327,7 +327,7 @@ JRT_ENTRY(void, Runtime1::new_type_array(JavaThread* thread, Klass* klass, jint
// anymore after new_typeArray() and no GC can happen before.
// (This may have to change if this code changes!)
assert(klass->is_klass(), "not a class");
BasicType elt_type = typeArrayKlass::cast(klass)->element_type();
BasicType elt_type = TypeArrayKlass::cast(klass)->element_type();
oop obj = oopFactory::new_typeArray(elt_type, length, CHECK);
thread->set_vm_result(obj);
// This is pretty rare but this runtime patch is stressful to deoptimization
@ -346,7 +346,7 @@ JRT_ENTRY(void, Runtime1::new_object_array(JavaThread* thread, Klass* array_klas
// anymore after new_objArray() and no GC can happen before.
// (This may have to change if this code changes!)
assert(array_klass->is_klass(), "not a class");
Klass* elem_klass = objArrayKlass::cast(array_klass)->element_klass();
Klass* elem_klass = ObjArrayKlass::cast(array_klass)->element_klass();
objArrayOop obj = oopFactory::new_objArray(elem_klass, length, CHECK);
thread->set_vm_result(obj);
// This is pretty rare but this runtime patch is stressful to deoptimization
@ -362,7 +362,7 @@ JRT_ENTRY(void, Runtime1::new_multi_array(JavaThread* thread, Klass* klass, int
assert(klass->is_klass(), "not a class");
assert(rank >= 1, "rank must be nonzero");
oop obj = arrayKlass::cast(klass)->multi_allocate(rank, dims, CHECK);
oop obj = ArrayKlass::cast(klass)->multi_allocate(rank, dims, CHECK);
thread->set_vm_result(obj);
JRT_END
@ -1234,8 +1234,8 @@ template <class T> int obj_arraycopy_work(oopDesc* src, T* src_addr,
bs->write_ref_array((HeapWord*)dst_addr, length);
return ac_ok;
} else {
Klass* bound = objArrayKlass::cast(dst->klass())->element_klass();
Klass* stype = objArrayKlass::cast(src->klass())->element_klass();
Klass* bound = ObjArrayKlass::cast(dst->klass())->element_klass();
Klass* stype = ObjArrayKlass::cast(src->klass())->element_klass();
if (stype == bound || Klass::cast(stype)->is_subtype_of(bound)) {
// Elements are guaranteed to be subtypes, so no check necessary
bs->write_ref_array_pre(dst_addr, length);
@ -1263,7 +1263,7 @@ JRT_LEAF(int, Runtime1::arraycopy(oopDesc* src, int src_pos, oopDesc* dst, int d
if (src->is_typeArray()) {
Klass* const klass_oop = src->klass();
if (klass_oop != dst->klass()) return ac_failed;
typeArrayKlass* klass = typeArrayKlass::cast(klass_oop);
TypeArrayKlass* klass = TypeArrayKlass::cast(klass_oop);
const int l2es = klass->log2_element_size();
const int ihs = klass->array_header_in_bytes() / wordSize;
char* src_addr = (char*) ((oopDesc**)src + ihs) + (src_pos << l2es);

4
hotspot/src/share/vm/ci/ciArrayKlass.cpp
View File

@ -31,7 +31,7 @@
// ciArrayKlass
//
// This class represents a Klass* in the HotSpot virtual machine
// whose Klass part in an arrayKlass.
// whose Klass part in an ArrayKlass.
// ------------------------------------------------------------------
// ciArrayKlass::ciArrayKlass
@ -39,7 +39,7 @@
// Loaded array klass.
ciArrayKlass::ciArrayKlass(KlassHandle h_k) : ciKlass(h_k) {
assert(get_Klass()->oop_is_array(), "wrong type");
_dimension = get_arrayKlass()->dimension();
_dimension = get_ArrayKlass()->dimension();
}
// ------------------------------------------------------------------

8
hotspot/src/share/vm/ci/ciArrayKlass.hpp
View File

@ -30,7 +30,7 @@
// ciArrayKlass
//
// This class, and its subclasses represent Klass*s in the
// HotSpot virtual machine whose Klass part is an arrayKlass.
// HotSpot virtual machine whose Klass part is an ArrayKlass.
class ciArrayKlass : public ciKlass {
CI_PACKAGE_ACCESS
private:
@ -40,8 +40,8 @@ protected:
ciArrayKlass(KlassHandle h_k);
ciArrayKlass(ciSymbol* name, int dimension, BasicType bt);
arrayKlass* get_arrayKlass() {
return (arrayKlass*)get_Klass();
ArrayKlass* get_ArrayKlass() {
return (ArrayKlass*)get_Klass();
}
const char* type_string() { return "ciArrayKlass"; }
@ -53,7 +53,7 @@ public:
bool is_leaf_type(); // No subtypes of this array type.
ciInstance* component_mirror() {
// This is a real field in arrayKlass, but we derive it from element_type.
// This is a real field in ArrayKlass, but we derive it from element_type.
return element_type()->java_mirror();
}

2
hotspot/src/share/vm/ci/ciEnv.cpp
View File

@ -326,7 +326,7 @@ bool ciEnv::check_klass_accessibility(ciKlass* accessing_klass,
if (resolved_klass->oop_is_objArray()) {
// Find the element klass, if this is an array.
resolved_klass = objArrayKlass::cast(resolved_klass)->bottom_klass();
resolved_klass = ObjArrayKlass::cast(resolved_klass)->bottom_klass();
}
if (resolved_klass->oop_is_instance()) {
return Reflection::verify_class_access(accessing_klass->get_Klass(),

2
hotspot/src/share/vm/ci/ciKlass.hpp
View File

@ -33,7 +33,7 @@
// HotSpot virtual machine. In the vm, each Klass* contains an
// embedded Klass object. ciKlass is subclassed to explicitly
// represent the kind of Klass embedded in the Klass*. For
// example, a Klass* with an embedded objArrayKlass object is
// example, a Klass* with an embedded ObjArrayKlass object is
// represented in the ciObject hierarchy by the class
// ciObjArrayKlass.
class ciKlass : public ciType {

6
hotspot/src/share/vm/ci/ciObjArrayKlass.cpp
View File

@ -32,7 +32,7 @@
// ciObjArrayKlass
//
// This class represents a Klass* in the HotSpot virtual machine
// whose Klass part is an objArrayKlass.
// whose Klass part is an ObjArrayKlass.
// ------------------------------------------------------------------
// ciObjArrayKlass::ciObjArrayKlass
@ -40,7 +40,7 @@
// Constructor for loaded object array klasses.
ciObjArrayKlass::ciObjArrayKlass(KlassHandle h_k) : ciArrayKlass(h_k) {
assert(get_Klass()->oop_is_objArray(), "wrong type");
Klass* element_Klass = get_objArrayKlass()->bottom_klass();
Klass* element_Klass = get_ObjArrayKlass()->bottom_klass();
_base_element_klass = CURRENT_ENV->get_klass(element_Klass);
assert(_base_element_klass->is_instance_klass() ||
_base_element_klass->is_type_array_klass(), "bad base klass");
@ -83,7 +83,7 @@ ciKlass* ciObjArrayKlass::element_klass() {
// Produce the element klass.
if (is_loaded()) {
VM_ENTRY_MARK;
Klass* element_Klass = get_objArrayKlass()->element_klass();
Klass* element_Klass = get_ObjArrayKlass()->element_klass();
_element_klass = CURRENT_THREAD_ENV->get_klass(element_Klass);
} else {
VM_ENTRY_MARK;

6
hotspot/src/share/vm/ci/ciObjArrayKlass.hpp
View File

@ -30,7 +30,7 @@
// ciObjArrayKlass
//
// This class represents a Klass* in the HotSpot virtual machine
// whose Klass part is an objArrayKlass.
// whose Klass part is an ObjArrayKlass.
class ciObjArrayKlass : public ciArrayKlass {
CI_PACKAGE_ACCESS
friend class ciEnv;
@ -45,8 +45,8 @@ protected:
ciKlass* base_element_klass,
int dimension);
objArrayKlass* get_objArrayKlass() {
return (objArrayKlass*)get_Klass();
ObjArrayKlass* get_ObjArrayKlass() {
return (ObjArrayKlass*)get_Klass();
}
static ciObjArrayKlass* make_impl(ciKlass* element_klass);

6
hotspot/src/share/vm/ci/ciObjectFactory.cpp
View File

@ -174,7 +174,7 @@ void ciObjectFactory::init_shared_objects() {
}
ciEnv::_unloaded_cisymbol = ciObjectFactory::get_symbol(vmSymbols::dummy_symbol());
// Create dummy InstanceKlass and objArrayKlass object and assign them idents
// Create dummy InstanceKlass and ObjArrayKlass object and assign them idents
ciEnv::_unloaded_ciinstance_klass = new (_arena) ciInstanceKlass(ciEnv::_unloaded_cisymbol, NULL, NULL);
init_ident_of(ciEnv::_unloaded_ciinstance_klass);
ciEnv::_unloaded_ciobjarrayklass = new (_arena) ciObjArrayKlass(ciEnv::_unloaded_cisymbol, ciEnv::_unloaded_ciinstance_klass, 1);
@ -454,7 +454,7 @@ ciKlass* ciObjectFactory::get_unloaded_klass(ciKlass* accessing_klass,
// the cache.
ciKlass* new_klass = NULL;
// Two cases: this is an unloaded objArrayKlass or an
// Two cases: this is an unloaded ObjArrayKlass or an
// unloaded InstanceKlass. Deal with both.
if (name->byte_at(0) == '[') {
// Decompose the name.'
@ -480,7 +480,7 @@ ciKlass* ciObjectFactory::get_unloaded_klass(ciKlass* accessing_klass,
// The type array itself takes care of one of the dimensions.
dimension--;
// The element klass is a typeArrayKlass.
// The element klass is a TypeArrayKlass.
element_klass = ciTypeArrayKlass::make(element_type);
}
new_klass = new (arena()) ciObjArrayKlass(name, element_klass, dimension);

2
hotspot/src/share/vm/ci/ciTypeArrayKlass.cpp
View File

@ -35,7 +35,7 @@
// ciTypeArrayKlass::ciTypeArrayKlass
ciTypeArrayKlass::ciTypeArrayKlass(KlassHandle h_k) : ciArrayKlass(h_k) {
assert(get_Klass()->oop_is_typeArray(), "wrong type");
assert(element_type() == get_typeArrayKlass()->element_type(), "");
assert(element_type() == get_TypeArrayKlass()->element_type(), "");
}
// ------------------------------------------------------------------

4
hotspot/src/share/vm/ci/ciTypeArrayKlass.hpp
View File

@ -37,8 +37,8 @@ class ciTypeArrayKlass : public ciArrayKlass {
protected:
ciTypeArrayKlass(KlassHandle h_k);
typeArrayKlass* get_typeArrayKlass() {
return (typeArrayKlass*)get_Klass();
TypeArrayKlass* get_TypeArrayKlass() {
return (TypeArrayKlass*)get_Klass();
}
const char* type_string() { return "ciTypeArrayKlass"; }

113
hotspot/src/share/vm/classfile/classFileParser.cpp
View File

@ -782,7 +782,7 @@ bool put_after_lookup(Symbol* name, Symbol* sig, NameSigHash** table) {
Array<Klass*>* ClassFileParser::parse_interfaces(constantPoolHandle cp,
int length,
ClassLoaderData* loader_data,
ClassLoaderData* loader_data,
Handle protection_domain,
Symbol* class_name,
TRAPS) {
@ -1072,10 +1072,11 @@ class FieldAllocationCount: public ResourceObj {
Array<u2>* ClassFileParser::parse_fields(ClassLoaderData* loader_data,
Symbol* class_name,
constantPoolHandle cp, bool is_interface,
FieldAllocationCount *fac,
constantPoolHandle cp,
bool is_interface,
FieldAllocationCount *fac,
Array<AnnotationArray*>** fields_annotations,
u2* java_fields_count_ptr, TRAPS) {
u2* java_fields_count_ptr, TRAPS) {
ClassFileStream* cfs = stream();
cfs->guarantee_more(2, CHECK_NULL); // length
u2 length = cfs->get_u2_fast();
@ -2169,14 +2170,12 @@ methodHandle ClassFileParser::parse_method(ClassLoaderData* loader_data,
}
// All sizing information for a Method* is finally available, now create it
Method* m = Method::allocate(loader_data,
code_length,
access_flags,
linenumber_table_length,
total_lvt_length,
exception_table_length,
checked_exceptions_length,
CHECK_(nullHandle));
Method* m = Method::allocate(loader_data, code_length, access_flags,
linenumber_table_length,
total_lvt_length,
exception_table_length,
checked_exceptions_length,
CHECK_(nullHandle));
ClassLoadingService::add_class_method_size(m->size()*HeapWordSize);
@ -2351,14 +2350,14 @@ methodHandle ClassFileParser::parse_method(ClassLoaderData* loader_data,
// are added to klass's access_flags.
Array<Method*>* ClassFileParser::parse_methods(ClassLoaderData* loader_data,
constantPoolHandle cp,
bool is_interface,
AccessFlags* promoted_flags,
bool* has_final_method,
Array<AnnotationArray*>** methods_annotations,
Array<AnnotationArray*>** methods_parameter_annotations,
Array<AnnotationArray*>** methods_default_annotations,
TRAPS) {
constantPoolHandle cp,
bool is_interface,
AccessFlags* promoted_flags,
bool* has_final_method,
Array<AnnotationArray*>** methods_annotations,
Array<AnnotationArray*>** methods_parameter_annotations,
Array<AnnotationArray*>** methods_default_annotations,
TRAPS) {
ClassFileStream* cfs = stream();
AnnotationArray* method_annotations = NULL;
AnnotationArray* method_parameter_annotations = NULL;
@ -2450,10 +2449,9 @@ Array<int>* ClassFileParser::sort_methods(ClassLoaderData* loader_data,
}
// Sort method array by ascending method name (for faster lookups & vtable construction)
// Note that the ordering is not alphabetical, see Symbol::fast_compare
Method::sort_methods(methods,
methods_annotations,
methods_parameter_annotations,
methods_default_annotations);
Method::sort_methods(methods, methods_annotations,
methods_parameter_annotations,
methods_default_annotations);
// If JVMTI original method ordering or sharing is enabled construct int
// array remembering the original ordering
@ -2835,10 +2833,10 @@ void ClassFileParser::parse_classfile_attributes(ClassLoaderData* loader_data,
}
AnnotationArray* annotations = assemble_annotations(loader_data,
runtime_visible_annotations,
runtime_visible_annotations_length,
runtime_invisible_annotations,
runtime_invisible_annotations_length,
CHECK);
runtime_visible_annotations_length,
runtime_invisible_annotations,
runtime_invisible_annotations_length,
CHECK);
set_class_annotations(annotations);
if (parsed_innerclasses_attribute || parsed_enclosingmethod_attribute) {
@ -2884,9 +2882,9 @@ void ClassFileParser::apply_parsed_class_attributes(instanceKlassHandle k) {
AnnotationArray* ClassFileParser::assemble_annotations(ClassLoaderData* loader_data,
u1* runtime_visible_annotations,
int runtime_visible_annotations_length,
u1* runtime_invisible_annotations,
int runtime_invisible_annotations_length, TRAPS) {
int runtime_visible_annotations_length,
u1* runtime_invisible_annotations,
int runtime_invisible_annotations_length, TRAPS) {
AnnotationArray* annotations = NULL;
if (runtime_visible_annotations != NULL ||
runtime_invisible_annotations != NULL) {
@ -3161,13 +3159,13 @@ instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
Array<AnnotationArray*>* methods_parameter_annotations = NULL;
Array<AnnotationArray*>* methods_default_annotations = NULL;
Array<Method*>* methods = parse_methods(loader_data,
cp, access_flags.is_interface(),
&promoted_flags,
&has_final_method,
&methods_annotations,
&methods_parameter_annotations,
&methods_default_annotations,
CHECK_(nullHandle));
cp, access_flags.is_interface(),
&promoted_flags,
&has_final_method,
&methods_annotations,
&methods_parameter_annotations,
&methods_default_annotations,
CHECK_(nullHandle));
// Additional attributes
ClassAnnotationCollector parsed_annotations;
@ -3186,12 +3184,11 @@ instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
"Interfaces must have java.lang.Object as superclass in class file %s",
CHECK_(nullHandle));
}
Klass* k = SystemDictionary::resolve_super_or_fail(class_name,
sk,
class_loader,
protection_domain,
true,
CHECK_(nullHandle));
Klass* k = SystemDictionary::resolve_super_or_fail(class_name, sk,
class_loader,
protection_domain,
true,
CHECK_(nullHandle));
KlassHandle kh (THREAD, k);
super_klass = instanceKlassHandle(THREAD, kh());
@ -3222,10 +3219,10 @@ instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
// sort methods
Array<int>* method_ordering = sort_methods(loader_data,
methods,
methods_annotations,
methods_parameter_annotations,
methods_default_annotations,
CHECK_(nullHandle));
methods_annotations,
methods_parameter_annotations,
methods_default_annotations,
CHECK_(nullHandle));
// promote flags from parse_methods() to the klass' flags
access_flags.add_promoted_flags(promoted_flags.as_int());
@ -3591,16 +3588,16 @@ instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
InstanceKlass::nonstatic_oop_map_size(total_oop_map_count);
Klass* ik = InstanceKlass::allocate_instance_klass(loader_data,
vtable_size,
itable_size,
static_field_size,
total_oop_map_size2,
rt,
access_flags,
name,
super_klass(),
host_klass,
CHECK_(nullHandle));
vtable_size,
itable_size,
static_field_size,
total_oop_map_size2,
rt,
access_flags,
name,
super_klass(),
host_klass,
CHECK_(nullHandle));
// Add all classes to our internal class loader list here,
// including classes in the bootstrap (NULL) class loader.

28
hotspot/src/share/vm/classfile/classFileParser.hpp
View File

@ -148,7 +148,7 @@ class ClassFileParser VALUE_OBJ_CLASS_SPEC {
// Interface parsing
Array<Klass*>* parse_interfaces(constantPoolHandle cp,
int length,
ClassLoaderData* loader_data,
ClassLoaderData* loader_data,
Handle protection_domain,
Symbol* class_name,
TRAPS);
@ -166,10 +166,10 @@ class ClassFileParser VALUE_OBJ_CLASS_SPEC {
TRAPS);
Array<u2>* parse_fields(ClassLoaderData* loader_data,
Symbol* class_name,
constantPoolHandle cp, bool is_interface,
FieldAllocationCount *fac,
constantPoolHandle cp, bool is_interface,
FieldAllocationCount *fac,
Array<AnnotationArray*>** fields_annotations,
u2* java_fields_count_ptr, TRAPS);
u2* java_fields_count_ptr, TRAPS);
// Method parsing
methodHandle parse_method(ClassLoaderData* loader_data,
@ -181,13 +181,13 @@ class ClassFileParser VALUE_OBJ_CLASS_SPEC {
AnnotationArray** method_default_annotations,
TRAPS);
Array<Method*>* parse_methods(ClassLoaderData* loader_data,
constantPoolHandle cp,
bool is_interface,
constantPoolHandle cp,
bool is_interface,
AccessFlags* promoted_flags,
bool* has_final_method,
Array<AnnotationArray*>** methods_annotations,
Array<AnnotationArray*>** methods_parameter_annotations,
Array<AnnotationArray*>** methods_default_annotations,
Array<AnnotationArray*>** methods_annotations,
Array<AnnotationArray*>** methods_parameter_annotations,
Array<AnnotationArray*>** methods_default_annotations,
TRAPS);
Array<int>* sort_methods(ClassLoaderData* loader_data,
Array<Method*>* methods,
@ -232,9 +232,9 @@ class ClassFileParser VALUE_OBJ_CLASS_SPEC {
// Annotations handling
AnnotationArray* assemble_annotations(ClassLoaderData* loader_data,
u1* runtime_visible_annotations,
int runtime_visible_annotations_length,
u1* runtime_invisible_annotations,
int runtime_invisible_annotations_length, TRAPS);
int runtime_visible_annotations_length,
u1* runtime_invisible_annotations,
int runtime_invisible_annotations_length, TRAPS);
int skip_annotation(u1* buffer, int limit, int index);
int skip_annotation_value(u1* buffer, int limit, int index);
void parse_annotations(u1* buffer, int limit, constantPoolHandle cp,
@ -252,8 +252,8 @@ class ClassFileParser VALUE_OBJ_CLASS_SPEC {
unsigned int* nonstatic_oop_counts);
void set_precomputed_flags(instanceKlassHandle k);
Array<Klass*>* compute_transitive_interfaces(ClassLoaderData* loader_data,
instanceKlassHandle super,
Array<Klass*>* local_ifs, TRAPS);
instanceKlassHandle super,
Array<Klass*>* local_ifs, TRAPS);
// Format checker methods
void classfile_parse_error(const char* msg, TRAPS);

12
hotspot/src/share/vm/classfile/javaClasses.cpp
View File

@ -540,18 +540,18 @@ oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) {
if (k->oop_is_array()) {
Handle comp_mirror;
if (k->oop_is_typeArray()) {
BasicType type = typeArrayKlass::cast(k())->element_type();
BasicType type = TypeArrayKlass::cast(k())->element_type();
comp_mirror = Universe::java_mirror(type);
} else {
assert(k->oop_is_objArray(), "Must be");
Klass* element_klass = objArrayKlass::cast(k())->element_klass();
Klass* element_klass = ObjArrayKlass::cast(k())->element_klass();
assert(element_klass != NULL, "Must have an element klass");
comp_mirror = Klass::cast(element_klass)->java_mirror();
}
assert(comp_mirror.not_null(), "must have a mirror");
// Two-way link between the array klass and its component mirror:
arrayKlass::cast(k())->set_component_mirror(comp_mirror());
ArrayKlass::cast(k())->set_component_mirror(comp_mirror());
set_array_klass(comp_mirror(), k());
} else {
assert(k->oop_is_instance(), "Must be");
@ -704,7 +704,7 @@ bool java_lang_Class::is_primitive(oop java_class) {
#ifdef ASSERT
if (is_primitive) {
Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset));
assert(k == NULL || is_java_primitive(arrayKlass::cast(k)->element_type()),
assert(k == NULL || is_java_primitive(ArrayKlass::cast(k)->element_type()),
"Should be either the T_VOID primitive or a java primitive");
}
#endif
@ -719,7 +719,7 @@ BasicType java_lang_Class::primitive_type(oop java_class) {
BasicType type = T_VOID;
if (ak != NULL) {
// Note: create_basic_type_mirror above initializes ak to a non-null value.
type = arrayKlass::cast(ak)->element_type();
type = ArrayKlass::cast(ak)->element_type();
} else {
assert(java_class == Universe::void_mirror(), "only valid non-array primitive");
}
@ -846,7 +846,7 @@ void java_lang_Thread::set_thread(oop java_thread, JavaThread* thread) {
typeArrayOop java_lang_Thread::name(oop java_thread) {
oop name = java_thread->obj_field(_name_offset);
assert(name == NULL || (name->is_typeArray() && typeArrayKlass::cast(name->klass())->element_type() == T_CHAR), "just checking");
assert(name == NULL || (name->is_typeArray() && TypeArrayKlass::cast(name->klass())->element_type() == T_CHAR), "just checking");
return typeArrayOop(name);
}

34
hotspot/src/share/vm/classfile/systemDictionary.cpp
View File

@ -244,7 +244,7 @@ Klass* SystemDictionary::resolve_array_class_or_null(Symbol* class_name,
}
} else {
k = Universe::typeArrayKlassObj(t);
k = typeArrayKlass::cast(k)->array_klass(fd.dimension(), CHECK_NULL);
k = TypeArrayKlass::cast(k)->array_klass(fd.dimension(), CHECK_NULL);
}
return k;
}
@ -920,9 +920,9 @@ Klass* SystemDictionary::find(Symbol* class_name,
// Look for a loaded instance or array klass by name. Do not do any loading.
// return NULL in case of error.
Klass* SystemDictionary::find_instance_or_array_klass(Symbol* class_name,
Handle class_loader,
Handle protection_domain,
TRAPS) {
Handle class_loader,
Handle protection_domain,
TRAPS) {
Klass* k = NULL;
assert(class_name != NULL, "class name must be non NULL");
@ -990,12 +990,12 @@ Klass* SystemDictionary::find_well_known_klass(Symbol* class_name) {
// updates no supplemental data structures.
// TODO consolidate the two methods with a helper routine?
Klass* SystemDictionary::parse_stream(Symbol* class_name,
Handle class_loader,
Handle protection_domain,
ClassFileStream* st,
KlassHandle host_klass,
GrowableArray<Handle>* cp_patches,
TRAPS) {
Handle class_loader,
Handle protection_domain,
ClassFileStream* st,
KlassHandle host_klass,
GrowableArray<Handle>* cp_patches,
TRAPS) {
TempNewSymbol parsed_name = NULL;
// Parse the stream. Note that we do this even though this klass might
@ -1076,11 +1076,11 @@ Klass* SystemDictionary::parse_stream(Symbol* class_name,
// the class until we have parsed the stream.
Klass* SystemDictionary::resolve_from_stream(Symbol* class_name,
Handle class_loader,
Handle protection_domain,
ClassFileStream* st,
bool verify,
TRAPS) {
Handle class_loader,
Handle protection_domain,
ClassFileStream* st,
bool verify,
TRAPS) {
// Classloaders that support parallelism, e.g. bootstrap classloader,
// or all classloaders with UnsyncloadClass do not acquire lock here
@ -2187,7 +2187,7 @@ Klass* SystemDictionary::find_constrained_instance_or_array_klass(
// Force the protection domain to be null. (This removes protection checks.)
Handle no_protection_domain;
Klass* klass = find_instance_or_array_klass(class_name, class_loader,
no_protection_domain, CHECK_NULL);
no_protection_domain, CHECK_NULL);
if (klass != NULL)
return klass;
@ -2525,7 +2525,7 @@ Handle SystemDictionary::find_method_handle_type(Symbol* signature,
mirror = NULL; // safety
// Emulate ConstantPool::verify_constant_pool_resolve.
if (Klass::cast(sel_klass)->oop_is_objArray())
sel_klass = objArrayKlass::cast(sel_klass)->bottom_klass();
sel_klass = ObjArrayKlass::cast(sel_klass)->bottom_klass();
if (Klass::cast(sel_klass)->oop_is_instance()) {
KlassHandle sel_kh(THREAD, sel_klass);
LinkResolver::check_klass_accessability(accessing_klass, sel_kh, CHECK_(empty));

2
hotspot/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp
View File

@ -204,7 +204,7 @@ void StealMarkingTask::do_it(GCTaskManager* manager, uint which) {
int random_seed = 17;
do {
while (ParCompactionManager::steal_objarray(which, &random_seed, task)) {
objArrayKlass* const k = (objArrayKlass*)task.obj()->klass();
ObjArrayKlass* const k = (ObjArrayKlass*)task.obj()->klass();
k->oop_follow_contents(cm, task.obj(), task.index());
cm->follow_marking_stacks();
}

4
hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp
View File

@ -188,10 +188,10 @@ void ParCompactionManager::follow_marking_stacks() {
// Process ObjArrays one at a time to avoid marking stack bloat.
ObjArrayTask task;
if (_objarray_stack.pop_overflow(task)) {
objArrayKlass* const k = (objArrayKlass*)task.obj()->klass();
ObjArrayKlass* const k = (ObjArrayKlass*)task.obj()->klass();
k->oop_follow_contents(this, task.obj(), task.index());
} else if (_objarray_stack.pop_local(task)) {
objArrayKlass* const k = (objArrayKlass*)task.obj()->klass();
ObjArrayKlass* const k = (ObjArrayKlass*)task.obj()->klass();
k->oop_follow_contents(this, task.obj(), task.index());
}
} while (!marking_stacks_empty());

2
hotspot/src/share/vm/gc_implementation/shared/markSweep.cpp
View File

@ -115,7 +115,7 @@ void MarkSweep::follow_stack() {
// Process ObjArrays one at a time to avoid marking stack bloat.
if (!_objarray_stack.is_empty()) {
ObjArrayTask task = _objarray_stack.pop();
objArrayKlass* const k = (objArrayKlass*)task.obj()->klass();
ObjArrayKlass* const k = (ObjArrayKlass*)task.obj()->klass();
k->oop_follow_contents(task.obj(), task.index());
}
} while (!_marking_stack.is_empty() || !_objarray_stack.is_empty());

2
hotspot/src/share/vm/interpreter/bytecodeInterpreter.cpp
View File

@ -1626,7 +1626,7 @@ run:
if (rhsObject != NULL) {
/* Check assignability of rhsObject into arrObj */
Klass* rhsKlassOop = rhsObject->klass(); // EBX (subclass)
Klass* elemKlassOop = objArrayKlass::cast(arrObj->klass())->element_klass(); // superklass EAX
Klass* elemKlassOop = ObjArrayKlass::cast(arrObj->klass())->element_klass(); // superklass EAX
//
// Check for compatibilty. This check must not GC!!
// Seems way more expensive now that we must dispatch

2
hotspot/src/share/vm/interpreter/interpreterRuntime.cpp
View File

@ -211,7 +211,7 @@ IRT_ENTRY(void, InterpreterRuntime::multianewarray(JavaThread* thread, jint* fir
int n = Interpreter::local_offset_in_bytes(index)/jintSize;
dims[index] = first_size_address[n];
}
oop obj = arrayKlass::cast(klass)->multi_allocate(nof_dims, dims, CHECK);
oop obj = ArrayKlass::cast(klass)->multi_allocate(nof_dims, dims, CHECK);
thread->set_vm_result(obj);
IRT_END

10
hotspot/src/share/vm/memory/oopFactory.cpp
View File

@ -47,12 +47,12 @@ typeArrayOop oopFactory::new_charArray(const char* utf8_str, TRAPS) {
}
typeArrayOop oopFactory::new_tenured_charArray(int length, TRAPS) {
return typeArrayKlass::cast(Universe::charArrayKlassObj())->allocate(length, THREAD);
return TypeArrayKlass::cast(Universe::charArrayKlassObj())->allocate(length, THREAD);
}
typeArrayOop oopFactory::new_typeArray(BasicType type, int length, TRAPS) {
Klass* type_asKlassOop = Universe::typeArrayKlassObj(type);
typeArrayKlass* type_asArrayKlass = typeArrayKlass::cast(type_asKlassOop);
TypeArrayKlass* type_asArrayKlass = TypeArrayKlass::cast(type_asKlassOop);
typeArrayOop result = type_asArrayKlass->allocate(length, THREAD);
return result;
}
@ -66,14 +66,14 @@ typeArrayOop oopFactory::new_typeArray(BasicType type, int length, TRAPS) {
typeArrayOop oopFactory::new_metaDataArray(int length, TRAPS) {
BasicType type = LP64_ONLY(T_LONG) NOT_LP64(T_INT);
Klass* type_asKlassOop = Universe::typeArrayKlassObj(type);
typeArrayKlass* type_asArrayKlass = typeArrayKlass::cast(type_asKlassOop);
TypeArrayKlass* type_asArrayKlass = TypeArrayKlass::cast(type_asKlassOop);
typeArrayOop result = type_asArrayKlass->allocate_common(length, true, THREAD);
return result;
}
typeArrayOop oopFactory::new_typeArray_nozero(BasicType type, int length, TRAPS) {
Klass* type_asKlassOop = Universe::typeArrayKlassObj(type);
typeArrayKlass* type_asArrayKlass = typeArrayKlass::cast(type_asKlassOop);
TypeArrayKlass* type_asArrayKlass = TypeArrayKlass::cast(type_asKlassOop);
typeArrayOop result = type_asArrayKlass->allocate_common(length, false, THREAD);
return result;
}
@ -82,7 +82,7 @@ typeArrayOop oopFactory::new_typeArray_nozero(BasicType type, int length, TRAPS)
objArrayOop oopFactory::new_objArray(Klass* klass, int length, TRAPS) {
assert(klass->is_klass(), "must be instance class");
if (klass->oop_is_array()) {
return ((arrayKlass*)klass)->allocate_arrayArray(1, length, THREAD);
return ((ArrayKlass*)klass)->allocate_arrayArray(1, length, THREAD);
} else {
assert (klass->oop_is_instance(), "new object array with klass not an InstanceKlass");
return ((InstanceKlass*)klass)->allocate_objArray(1, length, THREAD);

18
hotspot/src/share/vm/memory/oopFactory.hpp
View File

@ -40,19 +40,19 @@ class vframeArray;
class oopFactory: AllStatic {
public:
// Basic type leaf array allocation
static typeArrayOop new_boolArray (int length, TRAPS) { return typeArrayKlass::cast(Universe::boolArrayKlassObj ())->allocate(length, CHECK_NULL); }
static typeArrayOop new_charArray (int length, TRAPS) { return typeArrayKlass::cast(Universe::charArrayKlassObj ())->allocate(length, CHECK_NULL); }
static typeArrayOop new_singleArray(int length, TRAPS) { return typeArrayKlass::cast(Universe::singleArrayKlassObj())->allocate(length, CHECK_NULL); }
static typeArrayOop new_doubleArray(int length, TRAPS) { return typeArrayKlass::cast(Universe::doubleArrayKlassObj())->allocate(length, CHECK_NULL); }
static typeArrayOop new_byteArray (int length, TRAPS) { return typeArrayKlass::cast(Universe::byteArrayKlassObj ())->allocate(length, CHECK_NULL); }
static typeArrayOop new_shortArray (int length, TRAPS) { return typeArrayKlass::cast(Universe::shortArrayKlassObj ())->allocate(length, CHECK_NULL); }
static typeArrayOop new_intArray (int length, TRAPS) { return typeArrayKlass::cast(Universe::intArrayKlassObj ())->allocate(length, CHECK_NULL); }
static typeArrayOop new_longArray (int length, TRAPS) { return typeArrayKlass::cast(Universe::longArrayKlassObj ())->allocate(length, CHECK_NULL); }
static typeArrayOop new_boolArray (int length, TRAPS) { return TypeArrayKlass::cast(Universe::boolArrayKlassObj ())->allocate(length, CHECK_NULL); }
static typeArrayOop new_charArray (int length, TRAPS) { return TypeArrayKlass::cast(Universe::charArrayKlassObj ())->allocate(length, CHECK_NULL); }
static typeArrayOop new_singleArray(int length, TRAPS) { return TypeArrayKlass::cast(Universe::singleArrayKlassObj())->allocate(length, CHECK_NULL); }
static typeArrayOop new_doubleArray(int length, TRAPS) { return TypeArrayKlass::cast(Universe::doubleArrayKlassObj())->allocate(length, CHECK_NULL); }
static typeArrayOop new_byteArray (int length, TRAPS) { return TypeArrayKlass::cast(Universe::byteArrayKlassObj ())->allocate(length, CHECK_NULL); }
static typeArrayOop new_shortArray (int length, TRAPS) { return TypeArrayKlass::cast(Universe::shortArrayKlassObj ())->allocate(length, CHECK_NULL); }
static typeArrayOop new_intArray (int length, TRAPS) { return TypeArrayKlass::cast(Universe::intArrayKlassObj ())->allocate(length, CHECK_NULL); }
static typeArrayOop new_longArray (int length, TRAPS) { return TypeArrayKlass::cast(Universe::longArrayKlassObj ())->allocate(length, CHECK_NULL); }
// create java.lang.Object[]
static objArrayOop new_objectArray(int length, TRAPS) {
assert(Universe::objectArrayKlassObj() != NULL, "Too early?");
return objArrayKlass::
return ObjArrayKlass::
cast(Universe::objectArrayKlassObj())->allocate(length, CHECK_NULL);
}

2
hotspot/src/share/vm/memory/specialized_oop_closures.hpp
View File

@ -200,7 +200,7 @@ public:
enum Kind {
ik, // InstanceKlass
irk, // InstanceRefKlass
oa, // objArrayKlass
oa, // ObjArrayKlass
NUM_Kinds
};

20
hotspot/src/share/vm/memory/universe.cpp
View File

@ -265,14 +265,14 @@ void Universe::genesis(TRAPS) {
compute_base_vtable_size();
if (!UseSharedSpaces) {
_boolArrayKlassObj = typeArrayKlass::create_klass(T_BOOLEAN, sizeof(jboolean), CHECK);
_charArrayKlassObj = typeArrayKlass::create_klass(T_CHAR, sizeof(jchar), CHECK);
_singleArrayKlassObj = typeArrayKlass::create_klass(T_FLOAT, sizeof(jfloat), CHECK);
_doubleArrayKlassObj = typeArrayKlass::create_klass(T_DOUBLE, sizeof(jdouble), CHECK);
_byteArrayKlassObj = typeArrayKlass::create_klass(T_BYTE, sizeof(jbyte), CHECK);
_shortArrayKlassObj = typeArrayKlass::create_klass(T_SHORT, sizeof(jshort), CHECK);
_intArrayKlassObj = typeArrayKlass::create_klass(T_INT, sizeof(jint), CHECK);
_longArrayKlassObj = typeArrayKlass::create_klass(T_LONG, sizeof(jlong), CHECK);
_boolArrayKlassObj = TypeArrayKlass::create_klass(T_BOOLEAN, sizeof(jboolean), CHECK);
_charArrayKlassObj = TypeArrayKlass::create_klass(T_CHAR, sizeof(jchar), CHECK);
_singleArrayKlassObj = TypeArrayKlass::create_klass(T_FLOAT, sizeof(jfloat), CHECK);
_doubleArrayKlassObj = TypeArrayKlass::create_klass(T_DOUBLE, sizeof(jdouble), CHECK);
_byteArrayKlassObj = TypeArrayKlass::create_klass(T_BYTE, sizeof(jbyte), CHECK);
_shortArrayKlassObj = TypeArrayKlass::create_klass(T_SHORT, sizeof(jshort), CHECK);
_intArrayKlassObj = TypeArrayKlass::create_klass(T_INT, sizeof(jint), CHECK);
_longArrayKlassObj = TypeArrayKlass::create_klass(T_LONG, sizeof(jlong), CHECK);
_typeArrayKlassObjs[T_BOOLEAN] = _boolArrayKlassObj;
_typeArrayKlassObjs[T_CHAR] = _charArrayKlassObj;
@ -440,8 +440,8 @@ void Universe::init_self_patching_vtbl_list(void** list, int count) {
{ InstanceClassLoaderKlass o; add_vtable(list, &n, &o, count); }
{ InstanceMirrorKlass o; add_vtable(list, &n, &o, count); }
{ InstanceRefKlass o; add_vtable(list, &n, &o, count); }
{ typeArrayKlass o; add_vtable(list, &n, &o, count); }
{ objArrayKlass o; add_vtable(list, &n, &o, count); }
{ TypeArrayKlass o; add_vtable(list, &n, &o, count); }
{ ObjArrayKlass o; add_vtable(list, &n, &o, count); }
{ Method o; add_vtable(list, &n, &o, count); }
{ ConstantPool o; add_vtable(list, &n, &o, count); }
}

56
hotspot/src/share/vm/oops/arrayKlass.cpp
View File

@ -36,7 +36,7 @@
#include "oops/objArrayOop.hpp"
#include "oops/oop.inline.hpp"
int arrayKlass::static_size(int header_size) {
int ArrayKlass::static_size(int header_size) {
// size of an array klass object
assert(header_size <= InstanceKlass::header_size(), "bad header size");
// If this assert fails, see comments in base_create_array_klass.
@ -51,7 +51,7 @@ int arrayKlass::static_size(int header_size) {
}
Klass* arrayKlass::java_super() const {
Klass* ArrayKlass::java_super() const {
if (super() == NULL) return NULL; // bootstrap case
// Array klasses have primary supertypes which are not reported to Java.
// Example super chain: String[][] -> Object[][] -> Object[] -> Object
@ -59,18 +59,18 @@ Klass* arrayKlass::java_super() const {
}
oop arrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
oop ArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
ShouldNotReachHere();
return NULL;
}
Method* arrayKlass::uncached_lookup_method(Symbol* name, Symbol* signature) const {
Method* ArrayKlass::uncached_lookup_method(Symbol* name, Symbol* signature) const {
// There are no methods in an array klass but the super class (Object) has some
assert(super(), "super klass must be present");
return Klass::cast(super())->uncached_lookup_method(name, signature);
}
arrayKlass::arrayKlass(Symbol* name) {
ArrayKlass::ArrayKlass(Symbol* name) {
set_alloc_size(0);
set_name(name);
@ -89,15 +89,15 @@ arrayKlass::arrayKlass(Symbol* name) {
// Initialization of vtables and mirror object is done separatly from base_create_array_klass,
// since a GC can happen. At this point all instance variables of the arrayKlass must be setup.
void arrayKlass::complete_create_array_klass(arrayKlass* k, KlassHandle super_klass, TRAPS) {
// since a GC can happen. At this point all instance variables of the ArrayKlass must be setup.
void ArrayKlass::complete_create_array_klass(ArrayKlass* k, KlassHandle super_klass, TRAPS) {
ResourceMark rm(THREAD);
k->initialize_supers(super_klass(), CHECK);
k->vtable()->initialize_vtable(false, CHECK);
java_lang_Class::create_mirror(k, CHECK);
}
GrowableArray<Klass*>* arrayKlass::compute_secondary_supers(int num_extra_slots) {
GrowableArray<Klass*>* ArrayKlass::compute_secondary_supers(int num_extra_slots) {
// interfaces = { cloneable_klass, serializable_klass };
assert(num_extra_slots == 0, "sanity of primitive array type");
// Must share this for correct bootstrapping!
@ -105,7 +105,7 @@ GrowableArray<Klass*>* arrayKlass::compute_secondary_supers(int num_extra_slots)
return NULL;
}
bool arrayKlass::compute_is_subtype_of(Klass* k) {
bool ArrayKlass::compute_is_subtype_of(Klass* k) {
// An array is a subtype of Serializable, Clonable, and Object
return k == SystemDictionary::Object_klass()
|| k == SystemDictionary::Cloneable_klass()
@ -113,19 +113,19 @@ bool arrayKlass::compute_is_subtype_of(Klass* k) {
}
inline intptr_t* arrayKlass::start_of_vtable() const {
inline intptr_t* ArrayKlass::start_of_vtable() const {
// all vtables start at the same place, that's why we use InstanceKlass::header_size here
return ((intptr_t*)this) + InstanceKlass::header_size();
}
klassVtable* arrayKlass::vtable() const {
klassVtable* ArrayKlass::vtable() const {
KlassHandle kh(Thread::current(), this);
return new klassVtable(kh, start_of_vtable(), vtable_length() / vtableEntry::size());
}
objArrayOop arrayKlass::allocate_arrayArray(int n, int length, TRAPS) {
objArrayOop ArrayKlass::allocate_arrayArray(int n, int length, TRAPS) {
if (length < 0) {
THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
}
@ -136,40 +136,40 @@ objArrayOop arrayKlass::allocate_arrayArray(int n, int length, TRAPS) {
}
int size = objArrayOopDesc::object_size(length);
Klass* k = array_klass(n+dimension(), CHECK_0);
arrayKlass* ak = arrayKlass::cast(k);
ArrayKlass* ak = ArrayKlass::cast(k);
objArrayOop o =
(objArrayOop)CollectedHeap::array_allocate(ak, size, length, CHECK_0);
// initialization to NULL not necessary, area already cleared
return o;
}
void arrayKlass::array_klasses_do(void f(Klass* k, TRAPS), TRAPS) {
void ArrayKlass::array_klasses_do(void f(Klass* k, TRAPS), TRAPS) {
Klass* k = this;
// Iterate over this array klass and all higher dimensions
while (k != NULL) {
f(k, CHECK);
k = arrayKlass::cast(k)->higher_dimension();
k = ArrayKlass::cast(k)->higher_dimension();
}
}
void arrayKlass::array_klasses_do(void f(Klass* k)) {
void ArrayKlass::array_klasses_do(void f(Klass* k)) {
Klass* k = this;
// Iterate over this array klass and all higher dimensions
while (k != NULL) {
f(k);
k = arrayKlass::cast(k)->higher_dimension();
k = ArrayKlass::cast(k)->higher_dimension();
}
}
void arrayKlass::with_array_klasses_do(void f(Klass* k)) {
void ArrayKlass::with_array_klasses_do(void f(Klass* k)) {
array_klasses_do(f);
}
// GC support
void arrayKlass::oops_do(OopClosure* cl) {
void ArrayKlass::oops_do(OopClosure* cl) {
Klass::oops_do(cl);
cl->do_oop(adr_component_mirror());
@ -177,42 +177,42 @@ void arrayKlass::oops_do(OopClosure* cl) {
// JVM support
jint arrayKlass::compute_modifier_flags(TRAPS) const {
jint ArrayKlass::compute_modifier_flags(TRAPS) const {
return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;
}
// JVMTI support
jint arrayKlass::jvmti_class_status() const {
jint ArrayKlass::jvmti_class_status() const {
return JVMTI_CLASS_STATUS_ARRAY;
}
void arrayKlass::remove_unshareable_info() {
void ArrayKlass::remove_unshareable_info() {
Klass::remove_unshareable_info();
// Clear the java mirror
set_component_mirror(NULL);
}
void arrayKlass::restore_unshareable_info(TRAPS) {
void ArrayKlass::restore_unshareable_info(TRAPS) {
Klass::restore_unshareable_info(CHECK);
// Klass recreates the component mirror also
}
// Printing
void arrayKlass::print_on(outputStream* st) const {
void ArrayKlass::print_on(outputStream* st) const {
assert(is_klass(), "must be klass");
Klass::print_on(st);
}
void arrayKlass::print_value_on(outputStream* st) const {
void ArrayKlass::print_value_on(outputStream* st) const {
assert(is_klass(), "must be klass");
for(int index = 0; index < dimension(); index++) {
st->print("[]");
}
}
void arrayKlass::oop_print_on(oop obj, outputStream* st) {
void ArrayKlass::oop_print_on(oop obj, outputStream* st) {
assert(obj->is_array(), "must be array");
Klass::oop_print_on(obj, st);
st->print_cr(" - length: %d", arrayOop(obj)->length());
@ -221,7 +221,7 @@ void arrayKlass::oop_print_on(oop obj, outputStream* st) {
// Verification
void arrayKlass::verify_on(outputStream* st) {
void ArrayKlass::verify_on(outputStream* st) {
Klass::verify_on(st);
if (component_mirror() != NULL) {
@ -229,7 +229,7 @@ void arrayKlass::verify_on(outputStream* st) {
}
}
void arrayKlass::oop_verify_on(oop obj, outputStream* st) {
void ArrayKlass::oop_verify_on(oop obj, outputStream* st) {
guarantee(obj->is_array(), "must be array");
arrayOop a = arrayOop(obj);
guarantee(a->length() >= 0, "array with negative length?");

20
hotspot/src/share/vm/oops/arrayKlass.hpp
View File

@ -30,9 +30,9 @@
class klassVtable;
// arrayKlass is the abstract baseclass for all array classes
// ArrayKlass is the abstract baseclass for all array classes
class arrayKlass: public Klass {
class ArrayKlass: public Klass {
friend class VMStructs;
private:
int _dimension; // This is n'th-dimensional array.
@ -46,8 +46,8 @@ class arrayKlass: public Klass {
// Constructors
// The constructor with the Symbol argument does the real array
// initialization, the other is a dummy
arrayKlass(Symbol* name);
arrayKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for cds"); }
ArrayKlass(Symbol* name);
ArrayKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for cds"); }
public:
// Testing operation
@ -80,7 +80,7 @@ class arrayKlass: public Klass {
oop* adr_component_mirror() { return (oop*)&this->_component_mirror;}
// Compiler/Interpreter offset
static ByteSize component_mirror_offset() { return in_ByteSize(offset_of(arrayKlass, _component_mirror)); }
static ByteSize component_mirror_offset() { return in_ByteSize(offset_of(ArrayKlass, _component_mirror)); }
virtual Klass* java_super() const;//{ return SystemDictionary::Object_klass(); }
@ -94,16 +94,16 @@ class arrayKlass: public Klass {
Method* uncached_lookup_method(Symbol* name, Symbol* signature) const;
// Casting from Klass*
static arrayKlass* cast(Klass* k) {
assert(k->oop_is_array(), "cast to arrayKlass");
return (arrayKlass*) k;
static ArrayKlass* cast(Klass* k) {
assert(k->oop_is_array(), "cast to ArrayKlass");
return (ArrayKlass*) k;
}
GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots);
bool compute_is_subtype_of(Klass* k);
// Sizing
static int header_size() { return sizeof(arrayKlass)/HeapWordSize; }
static int header_size() { return sizeof(ArrayKlass)/HeapWordSize; }
static int static_size(int header_size);
// Java vtable
@ -124,7 +124,7 @@ class arrayKlass: public Klass {
virtual void oops_do(OopClosure* cl);
// Return a handle.
static void complete_create_array_klass(arrayKlass* k, KlassHandle super_klass, TRAPS);
static void complete_create_array_klass(ArrayKlass* k, KlassHandle super_klass, TRAPS);
// jvm support

2
hotspot/src/share/vm/oops/constantPool.cpp
View File

@ -533,7 +533,7 @@ int ConstantPool::remap_instruction_operand_from_cache(int operand) {
void ConstantPool::verify_constant_pool_resolve(constantPoolHandle this_oop, KlassHandle k, TRAPS) {
if (k->oop_is_instance() || k->oop_is_objArray()) {
instanceKlassHandle holder (THREAD, this_oop->pool_holder());
Klass* elem_oop = k->oop_is_instance() ? k() : objArrayKlass::cast(k())->bottom_klass();
Klass* elem_oop = k->oop_is_instance() ? k() : ObjArrayKlass::cast(k())->bottom_klass();
KlassHandle element (THREAD, elem_oop);
// The element type could be a typeArray - we only need the access check if it is

2
hotspot/src/share/vm/oops/constantPool.hpp
View File

@ -468,7 +468,7 @@ class ConstantPool : public Metadata {
assert(tag_at(which).is_string(), "Corrupted constant pool");
// Must do an acquire here in case another thread resolved the klass
// behind our back, lest we later load stale values thru the oop.
// we might want a volatile_obj_at in objArrayKlass.
// we might want a volatile_obj_at in ObjArrayKlass.
int obj_index = cp_to_object_index(which);
return resolved_references()->obj_at(obj_index);
}

10
hotspot/src/share/vm/oops/instanceKlass.cpp
View File

@ -989,13 +989,13 @@ Klass* InstanceKlass::array_klass_impl(instanceKlassHandle this_oop, bool or_nul
// Check if update has already taken place
if (this_oop->array_klasses() == NULL) {
Klass* k = objArrayKlass::allocate_objArray_klass(this_oop->class_loader_data(), 1, this_oop, CHECK_NULL);
Klass* k = ObjArrayKlass::allocate_objArray_klass(this_oop->class_loader_data(), 1, this_oop, CHECK_NULL);
this_oop->set_array_klasses(k);
}
}
}
// _this will always be set at this point
objArrayKlass* oak = (objArrayKlass*)this_oop->array_klasses();
ObjArrayKlass* oak = (ObjArrayKlass*)this_oop->array_klasses();
if (or_null) {
return oak->array_klass_or_null(n);
}
@ -1224,12 +1224,12 @@ void InstanceKlass::do_nonstatic_fields(FieldClosure* cl) {
void InstanceKlass::array_klasses_do(void f(Klass* k, TRAPS), TRAPS) {
if (array_klasses() != NULL)
arrayKlass::cast(array_klasses())->array_klasses_do(f, THREAD);
ArrayKlass::cast(array_klasses())->array_klasses_do(f, THREAD);
}
void InstanceKlass::array_klasses_do(void f(Klass* k)) {
if (array_klasses() != NULL)
arrayKlass::cast(array_klasses())->array_klasses_do(f);
ArrayKlass::cast(array_klasses())->array_klasses_do(f);
}
@ -2310,7 +2310,7 @@ bool InstanceKlass::is_same_class_package(Klass* class2) {
Symbol* classname1 = Klass::cast(class1)->name();
if (Klass::cast(class2)->oop_is_objArray()) {
class2 = objArrayKlass::cast(class2)->bottom_klass();
class2 = ObjArrayKlass::cast(class2)->bottom_klass();
}
oop classloader2;
if (Klass::cast(class2)->oop_is_instance()) {

6
hotspot/src/share/vm/oops/klass.cpp
View File

@ -532,13 +532,13 @@ Klass* Klass::array_klass_or_null() {
Klass* Klass::array_klass_impl(bool or_null, int rank, TRAPS) {
fatal("array_klass should be dispatched to InstanceKlass, objArrayKlass or typeArrayKlass");
fatal("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass");
return NULL;
}
Klass* Klass::array_klass_impl(bool or_null, TRAPS) {
fatal("array_klass should be dispatched to InstanceKlass, objArrayKlass or typeArrayKlass");
fatal("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass");
return NULL;
}
@ -674,7 +674,7 @@ void Klass::verify_vtable_index(int i) {
assert(i>=0 && i<((InstanceKlass*)this)->vtable_length()/vtableEntry::size(), "index out of bounds");
} else {
assert(oop_is_array(), "Must be");
assert(i>=0 && i<((arrayKlass*)this)->vtable_length()/vtableEntry::size(), "index out of bounds");
assert(i>=0 && i<((ArrayKlass*)this)->vtable_length()/vtableEntry::size(), "index out of bounds");
}
}

2
hotspot/src/share/vm/oops/klassVtable.cpp
View File

@ -1096,7 +1096,7 @@ class VtableStats : AllStatic {
SystemDictionary::classes_do(do_class);
fixed = no_klasses * oopSize; // vtable length
// filler size is a conservative approximation
filler = oopSize * (no_klasses - no_instance_klasses) * (sizeof(InstanceKlass) - sizeof(arrayKlass) - 1);
filler = oopSize * (no_klasses - no_instance_klasses) * (sizeof(InstanceKlass) - sizeof(ArrayKlass) - 1);
entries = sizeof(vtableEntry) * sum_of_vtable_len;
array_entries = sizeof(vtableEntry) * sum_of_array_vtable_len;
}

2
hotspot/src/share/vm/oops/klassVtable.hpp
View File

@ -31,7 +31,7 @@
#include "utilities/growableArray.hpp"
// A klassVtable abstracts the variable-length vtable that is embedded in InstanceKlass
// and arrayKlass. klassVtable objects are used just as convenient transient accessors to the vtable,
// and ArrayKlass. klassVtable objects are used just as convenient transient accessors to the vtable,
// not to actually hold the vtable data.
// Note: the klassVtable should not be accessed before the class has been verified
// (until that point, the vtable is uninitialized).

2
hotspot/src/share/vm/oops/method.cpp
View File

@ -1065,7 +1065,7 @@ methodHandle Method::make_method_handle_intrinsic(vmIntrinsics::ID iid,
Klass* Method::check_non_bcp_klass(Klass* klass) {
if (klass != NULL && Klass::cast(klass)->class_loader() != NULL) {
if (Klass::cast(klass)->oop_is_objArray())
klass = objArrayKlass::cast(klass)->bottom_klass();
klass = ObjArrayKlass::cast(klass)->bottom_klass();
return klass;
}
return NULL;

98
hotspot/src/share/vm/oops/objArrayKlass.cpp
View File

@ -56,16 +56,16 @@
#include "oops/oop.pcgc.inline.hpp"
#endif
objArrayKlass* objArrayKlass::allocate(ClassLoaderData* loader_data, int n, KlassHandle klass_handle, Symbol* name, TRAPS) {
assert(objArrayKlass::header_size() <= InstanceKlass::header_size(),
ObjArrayKlass* ObjArrayKlass::allocate(ClassLoaderData* loader_data, int n, KlassHandle klass_handle, Symbol* name, TRAPS) {
assert(ObjArrayKlass::header_size() <= InstanceKlass::header_size(),
"array klasses must be same size as InstanceKlass");
int size = arrayKlass::static_size(objArrayKlass::header_size());
int size = ArrayKlass::static_size(ObjArrayKlass::header_size());
return new (loader_data, size, THREAD) objArrayKlass(n, klass_handle, name);
return new (loader_data, size, THREAD) ObjArrayKlass(n, klass_handle, name);
}
Klass* objArrayKlass::allocate_objArray_klass(ClassLoaderData* loader_data,
Klass* ObjArrayKlass::allocate_objArray_klass(ClassLoaderData* loader_data,
int n, KlassHandle element_klass, TRAPS) {
// Eagerly allocate the direct array supertype.
@ -145,7 +145,7 @@ Klass* objArrayKlass::allocate_objArray_klass(ClassLoaderData* loader_data,
}
// Initialize instance variables
objArrayKlass* oak = objArrayKlass::allocate(loader_data, n, element_klass, name, CHECK_0);
ObjArrayKlass* oak = ObjArrayKlass::allocate(loader_data, n, element_klass, name, CHECK_0);
// Add all classes to our internal class loader list here,
// including classes in the bootstrap (NULL) class loader.
@ -153,12 +153,12 @@ Klass* objArrayKlass::allocate_objArray_klass(ClassLoaderData* loader_data,
loader_data->add_class(oak);
// Call complete_create_array_klass after all instance variables has been initialized.
arrayKlass::complete_create_array_klass(oak, super_klass, CHECK_0);
ArrayKlass::complete_create_array_klass(oak, super_klass, CHECK_0);
return oak;
}
objArrayKlass::objArrayKlass(int n, KlassHandle element_klass, Symbol* name) : arrayKlass(name) {
ObjArrayKlass::ObjArrayKlass(int n, KlassHandle element_klass, Symbol* name) : ArrayKlass(name) {
this->set_dimension(n);
this->set_element_klass(element_klass());
// decrement refcount because object arrays are not explicitly freed. The
@ -168,7 +168,7 @@ objArrayKlass::objArrayKlass(int n, KlassHandle element_klass, Symbol* name) : a
Klass* bk;
if (element_klass->oop_is_objArray()) {
bk = objArrayKlass::cast(element_klass())->bottom_klass();
bk = ObjArrayKlass::cast(element_klass())->bottom_klass();
} else {
bk = element_klass();
}
@ -181,12 +181,12 @@ objArrayKlass::objArrayKlass(int n, KlassHandle element_klass, Symbol* name) : a
assert(this->oop_is_objArray(), "sanity");
}
int objArrayKlass::oop_size(oop obj) const {
int ObjArrayKlass::oop_size(oop obj) const {
assert(obj->is_objArray(), "must be object array");
return objArrayOop(obj)->object_size();
}
objArrayOop objArrayKlass::allocate(int length, TRAPS) {
objArrayOop ObjArrayKlass::allocate(int length, TRAPS) {
if (length >= 0) {
if (length <= arrayOopDesc::max_array_length(T_OBJECT)) {
int size = objArrayOopDesc::object_size(length);
@ -204,7 +204,7 @@ objArrayOop objArrayKlass::allocate(int length, TRAPS) {
static int multi_alloc_counter = 0;
oop objArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
oop ObjArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
int length = *sizes;
// Call to lower_dimension uses this pointer, so most be called before a
// possible GC
@ -215,7 +215,7 @@ oop objArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
if (rank > 1) {
if (length != 0) {
for (int index = 0; index < length; index++) {
arrayKlass* ak = arrayKlass::cast(h_lower_dimension());
ArrayKlass* ak = ArrayKlass::cast(h_lower_dimension());
oop sub_array = ak->multi_allocate(rank-1, &sizes[1], CHECK_NULL);
h_array->obj_at_put(index, sub_array);
}
@ -235,7 +235,7 @@ oop objArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
}
// Either oop or narrowOop depending on UseCompressedOops.
template <class T> void objArrayKlass::do_copy(arrayOop s, T* src,
template <class T> void ObjArrayKlass::do_copy(arrayOop s, T* src,
arrayOop d, T* dst, int length, TRAPS) {
BarrierSet* bs = Universe::heap()->barrier_set();
@ -252,8 +252,8 @@ template <class T> void objArrayKlass::do_copy(arrayOop s, T* src,
Copy::conjoint_oops_atomic(src, dst, length);
} else {
// We have to make sure all elements conform to the destination array
Klass* bound = objArrayKlass::cast(d->klass())->element_klass();
Klass* stype = objArrayKlass::cast(s->klass())->element_klass();
Klass* bound = ObjArrayKlass::cast(d->klass())->element_klass();
Klass* stype = ObjArrayKlass::cast(s->klass())->element_klass();
if (stype == bound || Klass::cast(stype)->is_subtype_of(bound)) {
// elements are guaranteed to be subtypes, so no check necessary
bs->write_ref_array_pre(dst, length);
@ -290,7 +290,7 @@ template <class T> void objArrayKlass::do_copy(arrayOop s, T* src,
bs->write_ref_array((HeapWord*)dst, length);
}
void objArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d,
void ObjArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d,
int dst_pos, int length, TRAPS) {
assert(s->is_objArray(), "must be obj array");
@ -327,7 +327,7 @@ void objArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d,
}
Klass* objArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
Klass* ObjArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
assert(dimension() <= n, "check order of chain");
int dim = dimension();
@ -348,30 +348,30 @@ Klass* objArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
// Create multi-dim klass object and link them together
Klass* k =
objArrayKlass::allocate_objArray_klass(class_loader_data(), dim + 1, this, CHECK_NULL);
objArrayKlass* ak = objArrayKlass::cast(k);
ObjArrayKlass::allocate_objArray_klass(class_loader_data(), dim + 1, this, CHECK_NULL);
ObjArrayKlass* ak = ObjArrayKlass::cast(k);
ak->set_lower_dimension(this);
OrderAccess::storestore();
set_higher_dimension(ak);
assert(ak->oop_is_objArray(), "incorrect initialization of objArrayKlass");
assert(ak->oop_is_objArray(), "incorrect initialization of ObjArrayKlass");
}
}
} else {
CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
}
objArrayKlass *ak = objArrayKlass::cast(higher_dimension());
ObjArrayKlass *ak = ObjArrayKlass::cast(higher_dimension());
if (or_null) {
return ak->array_klass_or_null(n);
}
return ak->array_klass(n, CHECK_NULL);
}
Klass* objArrayKlass::array_klass_impl(bool or_null, TRAPS) {
Klass* ObjArrayKlass::array_klass_impl(bool or_null, TRAPS) {
return array_klass_impl(or_null, dimension() + 1, CHECK_NULL);
}
bool objArrayKlass::can_be_primary_super_slow() const {
bool ObjArrayKlass::can_be_primary_super_slow() const {
if (!bottom_klass()->can_be_primary_super())
// array of interfaces
return false;
@ -379,7 +379,7 @@ bool objArrayKlass::can_be_primary_super_slow() const {
return Klass::can_be_primary_super_slow();
}
GrowableArray<Klass*>* objArrayKlass::compute_secondary_supers(int num_extra_slots) {
GrowableArray<Klass*>* ObjArrayKlass::compute_secondary_supers(int num_extra_slots) {
// interfaces = { cloneable_klass, serializable_klass, elemSuper[], ... };
Array<Klass*>* elem_supers = Klass::cast(element_klass())->secondary_supers();
int num_elem_supers = elem_supers == NULL ? 0 : elem_supers->length();
@ -402,16 +402,16 @@ GrowableArray<Klass*>* objArrayKlass::compute_secondary_supers(int num_extra_slo
}
}
bool objArrayKlass::compute_is_subtype_of(Klass* k) {
bool ObjArrayKlass::compute_is_subtype_of(Klass* k) {
if (!k->oop_is_objArray())
return arrayKlass::compute_is_subtype_of(k);
return ArrayKlass::compute_is_subtype_of(k);
objArrayKlass* oak = objArrayKlass::cast(k);
ObjArrayKlass* oak = ObjArrayKlass::cast(k);
return element_klass()->is_subtype_of(oak->element_klass());
}
void objArrayKlass::initialize(TRAPS) {
Klass::cast(bottom_klass())->initialize(THREAD); // dispatches to either InstanceKlass or typeArrayKlass
void ObjArrayKlass::initialize(TRAPS) {
Klass::cast(bottom_klass())->initialize(THREAD); // dispatches to either InstanceKlass or TypeArrayKlass
}
#define ObjArrayKlass_SPECIALIZED_OOP_ITERATE(T, a, p, do_oop) \
@ -456,7 +456,7 @@ void objArrayKlass::initialize(TRAPS) {
a, p, low, high, do_oop) \
}
void objArrayKlass::oop_follow_contents(oop obj) {
void ObjArrayKlass::oop_follow_contents(oop obj) {
assert (obj->is_array(), "obj must be array");
MarkSweep::follow_klass(obj->klass());
if (UseCompressedOops) {
@ -467,7 +467,7 @@ void objArrayKlass::oop_follow_contents(oop obj) {
}
#ifndef SERIALGC
void objArrayKlass::oop_follow_contents(ParCompactionManager* cm,
void ObjArrayKlass::oop_follow_contents(ParCompactionManager* cm,
oop obj) {
assert(obj->is_array(), "obj must be array");
PSParallelCompact::follow_klass(cm, obj->klass());
@ -487,7 +487,7 @@ void objArrayKlass::oop_follow_contents(ParCompactionManager* cm,
#define ObjArrayKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
\
int objArrayKlass::oop_oop_iterate##nv_suffix(oop obj, \
int ObjArrayKlass::oop_oop_iterate##nv_suffix(oop obj, \
OopClosureType* closure) { \
SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
assert (obj->is_array(), "obj must be array"); \
@ -504,7 +504,7 @@ int objArrayKlass::oop_oop_iterate##nv_suffix(oop obj,
#define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \
\
int objArrayKlass::oop_oop_iterate##nv_suffix##_m(oop obj, \
int ObjArrayKlass::oop_oop_iterate##nv_suffix##_m(oop obj, \
OopClosureType* closure, \
MemRegion mr) { \
SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
@ -526,7 +526,7 @@ int objArrayKlass::oop_oop_iterate##nv_suffix##_m(oop obj,
// for objArrayOops.
#define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r(OopClosureType, nv_suffix) \
\
int objArrayKlass::oop_oop_iterate_range##nv_suffix(oop obj, \
int ObjArrayKlass::oop_oop_iterate_range##nv_suffix(oop obj, \
OopClosureType* closure, \
int start, int end) { \
SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
@ -567,7 +567,7 @@ ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m)
ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r)
ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r)
int objArrayKlass::oop_adjust_pointers(oop obj) {
int ObjArrayKlass::oop_adjust_pointers(oop obj) {
assert(obj->is_objArray(), "obj must be obj array");
objArrayOop a = objArrayOop(obj);
// Get size before changing pointers.
@ -579,7 +579,7 @@ int objArrayKlass::oop_adjust_pointers(oop obj) {
}
#ifndef SERIALGC
void objArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
void ObjArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
assert(obj->is_objArray(), "obj must be obj array");
ObjArrayKlass_OOP_ITERATE( \
objArrayOop(obj), p, \
@ -588,7 +588,7 @@ void objArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
})
}
int objArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
int ObjArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
assert (obj->is_objArray(), "obj must be obj array");
objArrayOop a = objArrayOop(obj);
int size = a->object_size();
@ -600,7 +600,7 @@ int objArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
// JVM support
jint objArrayKlass::compute_modifier_flags(TRAPS) const {
jint ObjArrayKlass::compute_modifier_flags(TRAPS) const {
// The modifier for an objectArray is the same as its element
if (element_klass() == NULL) {
assert(Universe::is_bootstrapping(), "partial objArray only at startup");
@ -616,7 +616,7 @@ jint objArrayKlass::compute_modifier_flags(TRAPS) const {
// Printing
void objArrayKlass::print_on(outputStream* st) const {
void ObjArrayKlass::print_on(outputStream* st) const {
#ifndef PRODUCT
Klass::print_on(st);
st->print(" - instance klass: ");
@ -625,7 +625,7 @@ void objArrayKlass::print_on(outputStream* st) const {
#endif //PRODUCT
}
void objArrayKlass::print_value_on(outputStream* st) const {
void ObjArrayKlass::print_value_on(outputStream* st) const {
assert(is_klass(), "must be klass");
element_klass()->print_value_on(st);
@ -634,8 +634,8 @@ void objArrayKlass::print_value_on(outputStream* st) const {
#ifndef PRODUCT
void objArrayKlass::oop_print_on(oop obj, outputStream* st) {
arrayKlass::oop_print_on(obj, st);
void ObjArrayKlass::oop_print_on(oop obj, outputStream* st) {
ArrayKlass::oop_print_on(obj, st);
assert(obj->is_objArray(), "must be objArray");
objArrayOop oa = objArrayOop(obj);
int print_len = MIN2((intx) oa->length(), MaxElementPrintSize);
@ -654,7 +654,7 @@ void objArrayKlass::oop_print_on(oop obj, outputStream* st) {
static int max_objArray_print_length = 4;
void objArrayKlass::oop_print_value_on(oop obj, outputStream* st) {
void ObjArrayKlass::oop_print_value_on(oop obj, outputStream* st) {
assert(obj->is_objArray(), "must be objArray");
st->print("a ");
element_klass()->print_value_on(st);
@ -673,15 +673,15 @@ void objArrayKlass::oop_print_value_on(oop obj, outputStream* st) {
}
}
const char* objArrayKlass::internal_name() const {
const char* ObjArrayKlass::internal_name() const {
return external_name();
}
// Verification
void objArrayKlass::verify_on(outputStream* st) {
arrayKlass::verify_on(st);
void ObjArrayKlass::verify_on(outputStream* st) {
ArrayKlass::verify_on(st);
guarantee(element_klass()->is_metadata(), "should be in metaspace");
guarantee(element_klass()->is_klass(), "should be klass");
guarantee(bottom_klass()->is_metadata(), "should be in metaspace");
@ -690,8 +690,8 @@ void objArrayKlass::verify_on(outputStream* st) {
guarantee(bk->oop_is_instance() || bk->oop_is_typeArray(), "invalid bottom klass");
}
void objArrayKlass::oop_verify_on(oop obj, outputStream* st) {
arrayKlass::oop_verify_on(obj, st);
void ObjArrayKlass::oop_verify_on(oop obj, outputStream* st) {
ArrayKlass::oop_verify_on(obj, st);
guarantee(obj->is_objArray(), "must be objArray");
objArrayOop oa = objArrayOop(obj);
for(int index = 0; index < oa->length(); index++) {

28
hotspot/src/share/vm/oops/objArrayKlass.hpp
View File

@ -29,20 +29,20 @@
#include "memory/specialized_oop_closures.hpp"
#include "oops/arrayKlass.hpp"
// objArrayKlass is the klass for objArrays
// ObjArrayKlass is the klass for objArrays
class objArrayKlass : public arrayKlass {
class ObjArrayKlass : public ArrayKlass {
friend class VMStructs;
private:
Klass* _element_klass; // The klass of the elements of this array type
Klass* _bottom_klass; // The one-dimensional type (InstanceKlass or typeArrayKlass)
Klass* _bottom_klass; // The one-dimensional type (InstanceKlass or TypeArrayKlass)
// Constructor
objArrayKlass(int n, KlassHandle element_klass, Symbol* name);
static objArrayKlass* allocate(ClassLoaderData* loader_data, int n, KlassHandle klass_handle, Symbol* name, TRAPS);
ObjArrayKlass(int n, KlassHandle element_klass, Symbol* name);
static ObjArrayKlass* allocate(ClassLoaderData* loader_data, int n, KlassHandle klass_handle, Symbol* name, TRAPS);
public:
// For dummy objects
objArrayKlass() {}
ObjArrayKlass() {}
// Instance variables
Klass* element_klass() const { return _element_klass; }
@ -54,7 +54,7 @@ class objArrayKlass : public arrayKlass {
Klass** bottom_klass_addr() { return &_bottom_klass; }
// Compiler/Interpreter offset
static ByteSize element_klass_offset() { return in_ByteSize(offset_of(objArrayKlass, _element_klass)); }
static ByteSize element_klass_offset() { return in_ByteSize(offset_of(ObjArrayKlass, _element_klass)); }
// Dispatched operation
bool can_be_primary_super_slow() const;
@ -78,11 +78,11 @@ class objArrayKlass : public arrayKlass {
private:
// Either oop or narrowOop depending on UseCompressedOops.
// must be called from within objArrayKlass.cpp
// must be called from within ObjArrayKlass.cpp
template <class T> void do_copy(arrayOop s, T* src, arrayOop d,
T* dst, int length, TRAPS);
protected:
// Returns the objArrayKlass for n'th dimension.
// Returns the ObjArrayKlass for n'th dimension.
virtual Klass* array_klass_impl(bool or_null, int n, TRAPS);
// Returns the array class with this class as element type.
@ -90,14 +90,14 @@ class objArrayKlass : public arrayKlass {
public:
// Casting from Klass*
static objArrayKlass* cast(Klass* k) {
assert(k->oop_is_objArray(), "cast to objArrayKlass");
return (objArrayKlass*) k;
static ObjArrayKlass* cast(Klass* k) {
assert(k->oop_is_objArray(), "cast to ObjArrayKlass");
return (ObjArrayKlass*) k;
}
// Sizing
static int header_size() { return sizeof(objArrayKlass)/HeapWordSize; }
int size() const { return arrayKlass::static_size(header_size()); }
static int header_size() { return sizeof(ObjArrayKlass)/HeapWordSize; }
int size() const { return ArrayKlass::static_size(header_size()); }
// Initialization (virtual from Klass)
void initialize(TRAPS);

8
hotspot/src/share/vm/oops/objArrayKlass.inline.hpp
View File

@ -32,7 +32,7 @@
#include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
#endif
void objArrayKlass::oop_follow_contents(oop obj, int index) {
void ObjArrayKlass::oop_follow_contents(oop obj, int index) {
if (UseCompressedOops) {
objarray_follow_contents<narrowOop>(obj, index);
} else {
@ -41,7 +41,7 @@ void objArrayKlass::oop_follow_contents(oop obj, int index) {
}
template <class T>
void objArrayKlass::objarray_follow_contents(oop obj, int index) {
void ObjArrayKlass::objarray_follow_contents(oop obj, int index) {
objArrayOop a = objArrayOop(obj);
const size_t len = size_t(a->length());
const size_t beg_index = size_t(index);
@ -64,7 +64,7 @@ void objArrayKlass::objarray_follow_contents(oop obj, int index) {
}
#ifndef SERIALGC
void objArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj,
void ObjArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj,
int index) {
if (UseCompressedOops) {
objarray_follow_contents<narrowOop>(cm, obj, index);
@ -74,7 +74,7 @@ void objArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj,
}
template <class T>
void objArrayKlass::objarray_follow_contents(ParCompactionManager* cm, oop obj,
void ObjArrayKlass::objarray_follow_contents(ParCompactionManager* cm, oop obj,
int index) {
objArrayOop a = objArrayOop(obj);
const size_t len = size_t(a->length());

2
hotspot/src/share/vm/oops/objArrayOop.cpp
View File

@ -31,7 +31,7 @@
\
int objArrayOopDesc::oop_iterate_range(OopClosureType* blk, int start, int end) { \
SpecializationStats::record_call(); \
return ((objArrayKlass*)klass())->oop_oop_iterate_range##nv_suffix(this, blk, start, end); \
return ((ObjArrayKlass*)klass())->oop_oop_iterate_range##nv_suffix(this, blk, start, end); \
}
ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayOop_OOP_ITERATE_DEFN)

2
hotspot/src/share/vm/oops/objArrayOop.hpp
View File

@ -31,7 +31,7 @@
// Evaluating "String arg[10]" will create an objArrayOop.
class objArrayOopDesc : public arrayOopDesc {
friend class objArrayKlass;
friend class ObjArrayKlass;
friend class Runtime1;
friend class psPromotionManager;
friend class CSetMarkOopClosure;

2
hotspot/src/share/vm/oops/oop.pcgc.inline.hpp
View File

@ -44,7 +44,7 @@ inline void oopDesc::update_contents(ParCompactionManager* cm) {
// It might contain oops beyond the header, so take the virtual call.
new_klass->oop_update_pointers(cm, this);
}
// Else skip it. The typeArrayKlass in the header never needs scavenging.
// Else skip it. The TypeArrayKlass in the header never needs scavenging.
}
inline void oopDesc::follow_contents(ParCompactionManager* cm) {

2
hotspot/src/share/vm/oops/oop.psgc.inline.hpp
View File

@ -39,7 +39,7 @@ inline void oopDesc::push_contents(PSPromotionManager* pm) {
// It might contain oops beyond the header, so take the virtual call.
k->oop_push_contents(pm, this);
}
// Else skip it. The typeArrayKlass in the header never needs scavenging.
// Else skip it. The TypeArrayKlass in the header never needs scavenging.
}
#endif // SHARE_VM_OOPS_OOP_PSGC_INLINE_HPP

8
hotspot/src/share/vm/oops/oopsHierarchy.hpp
View File

@ -128,7 +128,7 @@ public:
#endif
// from parNewGeneration and other things that want to get to the end of
// an oop for stuff (like objArrayKlass.cpp)
// an oop for stuff (like ObjArrayKlass.cpp)
operator oop* () const { return (oop *)obj(); }
};
@ -172,8 +172,8 @@ class InstanceKlass;
class InstanceMirrorKlass;
class InstanceClassLoaderKlass;
class InstanceRefKlass;
class arrayKlass;
class objArrayKlass;
class typeArrayKlass;
class ArrayKlass;
class ObjArrayKlass;
class TypeArrayKlass;
#endif // SHARE_VM_OOPS_OOPSHIERARCHY_HPP

84
hotspot/src/share/vm/oops/typeArrayKlass.cpp
View File

@ -40,18 +40,18 @@
#include "oops/typeArrayOop.hpp"
#include "runtime/handles.inline.hpp"
bool typeArrayKlass::compute_is_subtype_of(Klass* k) {
bool TypeArrayKlass::compute_is_subtype_of(Klass* k) {
if (!k->oop_is_typeArray()) {
return arrayKlass::compute_is_subtype_of(k);
return ArrayKlass::compute_is_subtype_of(k);
}
typeArrayKlass* tak = typeArrayKlass::cast(k);
TypeArrayKlass* tak = TypeArrayKlass::cast(k);
if (dimension() != tak->dimension()) return false;
return element_type() == tak->element_type();
}
typeArrayKlass* typeArrayKlass::create_klass(BasicType type,
TypeArrayKlass* TypeArrayKlass::create_klass(BasicType type,
const char* name_str, TRAPS) {
Symbol* sym = NULL;
if (name_str != NULL) {
@ -60,7 +60,7 @@ typeArrayKlass* typeArrayKlass::create_klass(BasicType type,
ClassLoaderData* null_loader_data = ClassLoaderData::the_null_class_loader_data();
typeArrayKlass* ak = typeArrayKlass::allocate(null_loader_data, type, sym, CHECK_NULL);
TypeArrayKlass* ak = TypeArrayKlass::allocate(null_loader_data, type, sym, CHECK_NULL);
// Add all classes to our internal class loader list here,
// including classes in the bootstrap (NULL) class loader.
@ -73,27 +73,27 @@ typeArrayKlass* typeArrayKlass::create_klass(BasicType type,
return ak;
}
typeArrayKlass* typeArrayKlass::allocate(ClassLoaderData* loader_data, BasicType type, Symbol* name, TRAPS) {
assert(typeArrayKlass::header_size() <= InstanceKlass::header_size(),
TypeArrayKlass* TypeArrayKlass::allocate(ClassLoaderData* loader_data, BasicType type, Symbol* name, TRAPS) {
assert(TypeArrayKlass::header_size() <= InstanceKlass::header_size(),
"array klasses must be same size as InstanceKlass");
int size = arrayKlass::static_size(typeArrayKlass::header_size());
int size = ArrayKlass::static_size(TypeArrayKlass::header_size());
return new (loader_data, size, THREAD) typeArrayKlass(type, name);
return new (loader_data, size, THREAD) TypeArrayKlass(type, name);
}
typeArrayKlass::typeArrayKlass(BasicType type, Symbol* name) : arrayKlass(name) {
TypeArrayKlass::TypeArrayKlass(BasicType type, Symbol* name) : ArrayKlass(name) {
set_layout_helper(array_layout_helper(type));
assert(oop_is_array(), "sanity");
assert(oop_is_typeArray(), "sanity");
set_max_length(arrayOopDesc::max_array_length(type));
assert(size() >= typeArrayKlass::header_size(), "bad size");
assert(size() >= TypeArrayKlass::header_size(), "bad size");
set_class_loader_data(ClassLoaderData::the_null_class_loader_data());
}
typeArrayOop typeArrayKlass::allocate_common(int length, bool do_zero, TRAPS) {
typeArrayOop TypeArrayKlass::allocate_common(int length, bool do_zero, TRAPS) {
assert(log2_element_size() >= 0, "bad scale");
if (length >= 0) {
if (length <= max_length()) {
@ -117,7 +117,7 @@ typeArrayOop typeArrayKlass::allocate_common(int length, bool do_zero, TRAPS) {
}
}
oop typeArrayKlass::multi_allocate(int rank, jint* last_size, TRAPS) {
oop TypeArrayKlass::multi_allocate(int rank, jint* last_size, TRAPS) {
// For typeArrays this is only called for the last dimension
assert(rank == 1, "just checking");
int length = *last_size;
@ -125,11 +125,11 @@ oop typeArrayKlass::multi_allocate(int rank, jint* last_size, TRAPS) {
}
void typeArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS) {
void TypeArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS) {
assert(s->is_typeArray(), "must be type array");
// Check destination
if (!d->is_typeArray() || element_type() != typeArrayKlass::cast(d->klass())->element_type()) {
if (!d->is_typeArray() || element_type() != TypeArrayKlass::cast(d->klass())->element_type()) {
THROW(vmSymbols::java_lang_ArrayStoreException());
}
@ -156,7 +156,7 @@ void typeArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos
// create a klass of array holding typeArrays
Klass* typeArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
Klass* TypeArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
int dim = dimension();
assert(dim <= n, "check order of chain");
if (dim == n)
@ -173,92 +173,92 @@ Klass* typeArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
MutexLocker mu(MultiArray_lock, THREAD);
if (higher_dimension() == NULL) {
Klass* oak = objArrayKlass::allocate_objArray_klass(
Klass* oak = ObjArrayKlass::allocate_objArray_klass(
class_loader_data(), dim + 1, this, CHECK_NULL);
objArrayKlass* h_ak = objArrayKlass::cast(oak);
ObjArrayKlass* h_ak = ObjArrayKlass::cast(oak);
h_ak->set_lower_dimension(this);
OrderAccess::storestore();
set_higher_dimension(h_ak);
assert(h_ak->oop_is_objArray(), "incorrect initialization of objArrayKlass");
assert(h_ak->oop_is_objArray(), "incorrect initialization of ObjArrayKlass");
}
}
} else {
CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
}
objArrayKlass* h_ak = objArrayKlass::cast(higher_dimension());
ObjArrayKlass* h_ak = ObjArrayKlass::cast(higher_dimension());
if (or_null) {
return h_ak->array_klass_or_null(n);
}
return h_ak->array_klass(n, CHECK_NULL);
}
Klass* typeArrayKlass::array_klass_impl(bool or_null, TRAPS) {
Klass* TypeArrayKlass::array_klass_impl(bool or_null, TRAPS) {
return array_klass_impl(or_null, dimension() + 1, THREAD);
}
int typeArrayKlass::oop_size(oop obj) const {
int TypeArrayKlass::oop_size(oop obj) const {
assert(obj->is_typeArray(),"must be a type array");
typeArrayOop t = typeArrayOop(obj);
return t->object_size();
}
void typeArrayKlass::oop_follow_contents(oop obj) {
void TypeArrayKlass::oop_follow_contents(oop obj) {
assert(obj->is_typeArray(),"must be a type array");
// Performance tweak: We skip iterating over the klass pointer since we
// know that Universe::typeArrayKlass never moves.
// know that Universe::TypeArrayKlass never moves.
}
#ifndef SERIALGC
void typeArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj) {
void TypeArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj) {
assert(obj->is_typeArray(),"must be a type array");
// Performance tweak: We skip iterating over the klass pointer since we
// know that Universe::typeArrayKlass never moves.
// know that Universe::TypeArrayKlass never moves.
}
#endif // SERIALGC
int typeArrayKlass::oop_adjust_pointers(oop obj) {
int TypeArrayKlass::oop_adjust_pointers(oop obj) {
assert(obj->is_typeArray(),"must be a type array");
typeArrayOop t = typeArrayOop(obj);
// Performance tweak: We skip iterating over the klass pointer since we
// know that Universe::typeArrayKlass never moves.
// know that Universe::TypeArrayKlass never moves.
return t->object_size();
}
int typeArrayKlass::oop_oop_iterate(oop obj, ExtendedOopClosure* blk) {
int TypeArrayKlass::oop_oop_iterate(oop obj, ExtendedOopClosure* blk) {
assert(obj->is_typeArray(),"must be a type array");
typeArrayOop t = typeArrayOop(obj);
// Performance tweak: We skip iterating over the klass pointer since we
// know that Universe::typeArrayKlass never moves.
// know that Universe::TypeArrayKlass never moves.
return t->object_size();
}
int typeArrayKlass::oop_oop_iterate_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) {
int TypeArrayKlass::oop_oop_iterate_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) {
assert(obj->is_typeArray(),"must be a type array");
typeArrayOop t = typeArrayOop(obj);
// Performance tweak: We skip iterating over the klass pointer since we
// know that Universe::typeArrayKlass never moves.
// know that Universe::TypeArrayKlass never moves.
return t->object_size();
}
#ifndef SERIALGC
void typeArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
void TypeArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
ShouldNotReachHere();
assert(obj->is_typeArray(),"must be a type array");
}
int
typeArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
TypeArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
assert(obj->is_typeArray(),"must be a type array");
return typeArrayOop(obj)->object_size();
}
#endif // SERIALGC
void typeArrayKlass::initialize(TRAPS) {
void TypeArrayKlass::initialize(TRAPS) {
// Nothing to do. Having this function is handy since objArrayKlasses can be
// initialized by calling initialize on their bottom_klass, see objArrayKlass::initialize
// initialized by calling initialize on their bottom_klass, see ObjArrayKlass::initialize
}
const char* typeArrayKlass::external_name(BasicType type) {
const char* TypeArrayKlass::external_name(BasicType type) {
switch (type) {
case T_BOOLEAN: return "[Z";
case T_CHAR: return "[C";
@ -276,7 +276,7 @@ const char* typeArrayKlass::external_name(BasicType type) {
// Printing
void typeArrayKlass::print_on(outputStream* st) const {
void TypeArrayKlass::print_on(outputStream* st) const {
#ifndef PRODUCT
assert(is_klass(), "must be klass");
print_value_on(st);
@ -284,7 +284,7 @@ void typeArrayKlass::print_on(outputStream* st) const {
#endif //PRODUCT
}
void typeArrayKlass::print_value_on(outputStream* st) const {
void TypeArrayKlass::print_value_on(outputStream* st) const {
assert(is_klass(), "must be klass");
st->print("{type array ");
switch (element_type()) {
@ -364,8 +364,8 @@ static void print_long_array(typeArrayOop ta, int print_len, outputStream* st) {
}
void typeArrayKlass::oop_print_on(oop obj, outputStream* st) {
arrayKlass::oop_print_on(obj, st);
void TypeArrayKlass::oop_print_on(oop obj, outputStream* st) {
ArrayKlass::oop_print_on(obj, st);
typeArrayOop ta = typeArrayOop(obj);
int print_len = MIN2((intx) ta->length(), MaxElementPrintSize);
switch (element_type()) {
@ -387,6 +387,6 @@ void typeArrayKlass::oop_print_on(oop obj, outputStream* st) {
#endif // PRODUCT
const char* typeArrayKlass::internal_name() const {
const char* TypeArrayKlass::internal_name() const {
return Klass::external_name();
}

24
hotspot/src/share/vm/oops/typeArrayKlass.hpp
View File

@ -28,19 +28,19 @@
#include "classfile/classLoaderData.hpp"
#include "oops/arrayKlass.hpp"
// A typeArrayKlass is the klass of a typeArray
// A TypeArrayKlass is the klass of a typeArray
// It contains the type and size of the elements
class typeArrayKlass : public arrayKlass {
class TypeArrayKlass : public ArrayKlass {
friend class VMStructs;
private:
jint _max_length; // maximum number of elements allowed in an array
// Constructor
typeArrayKlass(BasicType type, Symbol* name);
static typeArrayKlass* allocate(ClassLoaderData* loader_data, BasicType type, Symbol* name, TRAPS);
TypeArrayKlass(BasicType type, Symbol* name);
static TypeArrayKlass* allocate(ClassLoaderData* loader_data, BasicType type, Symbol* name, TRAPS);
public:
typeArrayKlass() {} // For dummy objects.
TypeArrayKlass() {} // For dummy objects.
// instance variables
jint max_length() { return _max_length; }
@ -50,10 +50,10 @@ class typeArrayKlass : public arrayKlass {
bool oop_is_typeArray_slow() const { return true; }
// klass allocation
static typeArrayKlass* create_klass(BasicType type, const char* name_str,
static TypeArrayKlass* create_klass(BasicType type, const char* name_str,
TRAPS);
static inline Klass* create_klass(BasicType type, int scale, TRAPS) {
typeArrayKlass* tak = create_klass(type, external_name(type), CHECK_NULL);
TypeArrayKlass* tak = create_klass(type, external_name(type), CHECK_NULL);
assert(scale == (1 << tak->log2_element_size()), "scale must check out");
return tak;
}
@ -90,17 +90,17 @@ class typeArrayKlass : public arrayKlass {
public:
// Casting from Klass*
static typeArrayKlass* cast(Klass* k) {
assert(k->oop_is_typeArray(), "cast to typeArrayKlass");
return (typeArrayKlass*) k;
static TypeArrayKlass* cast(Klass* k) {
assert(k->oop_is_typeArray(), "cast to TypeArrayKlass");
return (TypeArrayKlass*) k;
}
// Naming
static const char* external_name(BasicType type);
// Sizing
static int header_size() { return sizeof(typeArrayKlass)/HeapWordSize; }
int size() const { return arrayKlass::static_size(header_size()); }
static int header_size() { return sizeof(TypeArrayKlass)/HeapWordSize; }
int size() const { return ArrayKlass::static_size(header_size()); }
// Initialization (virtual from Klass)
void initialize(TRAPS);

4
hotspot/src/share/vm/oops/typeArrayOop.hpp
View File

@ -73,7 +73,7 @@ class typeArrayOopDesc : public arrayOopDesc {
jfloat* float_base() const { return (jfloat*) base(T_FLOAT); }
jdouble* double_base() const { return (jdouble*) base(T_DOUBLE); }
friend class typeArrayKlass;
friend class TypeArrayKlass;
public:
jbyte* byte_at_addr(int which) const {
@ -190,7 +190,7 @@ class typeArrayOopDesc : public arrayOopDesc {
public:
int object_size() {
typeArrayKlass* tk = typeArrayKlass::cast(klass());
TypeArrayKlass* tk = TypeArrayKlass::cast(klass());
return object_size(tk->layout_helper(), length());
}
};

4
hotspot/src/share/vm/opto/library_call.cpp
View File

@ -3435,7 +3435,7 @@ bool LibraryCallKit::inline_native_Class_query(vmIntrinsics::ID id) {
if (generate_array_guard(kls, region) != NULL) {
// Be sure to pin the oop load to the guard edge just created:
Node* is_array_ctrl = region->in(region->req()-1);
Node* cma = basic_plus_adr(kls, in_bytes(arrayKlass::component_mirror_offset()));
Node* cma = basic_plus_adr(kls, in_bytes(ArrayKlass::component_mirror_offset()));
Node* cmo = make_load(is_array_ctrl, cma, TypeInstPtr::MIRROR, T_OBJECT);
phi->add_req(cmo);
}
@ -5032,7 +5032,7 @@ LibraryCallKit::generate_arraycopy(const TypePtr* adr_type,
PreserveJVMState pjvms(this);
set_control(not_subtype_ctrl);
// (At this point we can assume disjoint_bases, since types differ.)
int ek_offset = in_bytes(objArrayKlass::element_klass_offset());
int ek_offset = in_bytes(ObjArrayKlass::element_klass_offset());
Node* p1 = basic_plus_adr(dest_klass, ek_offset);
Node* n1 = LoadKlassNode::make(_gvn, immutable_memory(), p1, TypeRawPtr::BOTTOM);
Node* dest_elem_klass = _gvn.transform(n1);

12
hotspot/src/share/vm/opto/memnode.cpp
View File

@ -1671,9 +1671,9 @@ const Type *LoadNode::Value( PhaseTransform *phase ) const {
}
const Type* aift = load_array_final_field(tkls, klass);
if (aift != NULL) return aift;
if (tkls->offset() == in_bytes(arrayKlass::component_mirror_offset())
if (tkls->offset() == in_bytes(ArrayKlass::component_mirror_offset())
&& klass->is_array_klass()) {
// The field is arrayKlass::_component_mirror. Return its (constant) value.
// The field is ArrayKlass::_component_mirror. Return its (constant) value.
// (Folds up aClassConstant.getComponentType, common in Arrays.copyOf.)
assert(Opcode() == Op_LoadP, "must load an oop from _component_mirror");
return TypeInstPtr::make(klass->as_array_klass()->component_mirror());
@ -2014,7 +2014,7 @@ const Type *LoadNode::klass_value_common( PhaseTransform *phase ) const {
if( !klass->is_loaded() )
return _type; // Bail out if not loaded
if( klass->is_obj_array_klass() &&
tkls->offset() == in_bytes(objArrayKlass::element_klass_offset())) {
tkls->offset() == in_bytes(ObjArrayKlass::element_klass_offset())) {
ciKlass* elem = klass->as_obj_array_klass()->element_klass();
// // Always returning precise element type is incorrect,
// // e.g., element type could be object and array may contain strings
@ -2067,7 +2067,7 @@ Node* LoadNode::klass_identity_common(PhaseTransform *phase ) {
}
// Simplify k.java_mirror.as_klass to plain k, where k is a Klass*.
// Simplify ak.component_mirror.array_klass to plain ak, ak an arrayKlass.
// Simplify ak.component_mirror.array_klass to plain ak, ak an ArrayKlass.
// See inline_native_Class_query for occurrences of these patterns.
// Java Example: x.getClass().isAssignableFrom(y)
// Java Example: Array.newInstance(x.getClass().getComponentType(), n)
@ -2080,7 +2080,7 @@ Node* LoadNode::klass_identity_common(PhaseTransform *phase ) {
&& (offset == java_lang_Class::klass_offset_in_bytes() ||
offset == java_lang_Class::array_klass_offset_in_bytes())) {
// We are loading a special hidden field from a Class mirror,
// the field which points to its Klass or arrayKlass metaobject.
// the field which points to its Klass or ArrayKlass metaobject.
if (base->is_Load()) {
Node* adr2 = base->in(MemNode::Address);
const TypeKlassPtr* tkls = phase->type(adr2)->isa_klassptr();
@ -2091,7 +2091,7 @@ Node* LoadNode::klass_identity_common(PhaseTransform *phase ) {
) {
int mirror_field = in_bytes(Klass::java_mirror_offset());
if (offset == java_lang_Class::array_klass_offset_in_bytes()) {
mirror_field = in_bytes(arrayKlass::component_mirror_offset());
mirror_field = in_bytes(ArrayKlass::component_mirror_offset());
}
if (tkls->offset() == mirror_field) {
return adr2->in(AddPNode::Base);

2
hotspot/src/share/vm/opto/parseHelper.cpp
View File

@ -200,7 +200,7 @@ void Parse::array_store_check() {
// Come here for polymorphic array klasses
// Extract the array element class
int element_klass_offset = in_bytes(objArrayKlass::element_klass_offset());
int element_klass_offset = in_bytes(ObjArrayKlass::element_klass_offset());
Node *p2 = basic_plus_adr(array_klass, array_klass, element_klass_offset);
Node *a_e_klass = _gvn.transform( LoadKlassNode::make(_gvn, immutable_memory(), p2, tak) );

18
hotspot/src/share/vm/opto/runtime.cpp
View File

@ -286,13 +286,13 @@ JRT_BLOCK_ENTRY(void, OptoRuntime::new_array_C(Klass* array_type, int len, JavaT
if (Klass::cast(array_type)->oop_is_typeArray()) {
// The oopFactory likes to work with the element type.
// (We could bypass the oopFactory, since it doesn't add much value.)
BasicType elem_type = typeArrayKlass::cast(array_type)->element_type();
BasicType elem_type = TypeArrayKlass::cast(array_type)->element_type();
result = oopFactory::new_typeArray(elem_type, len, THREAD);
} else {
// Although the oopFactory likes to work with the elem_type,
// the compiler prefers the array_type, since it must already have
// that latter value in hand for the fast path.
Klass* elem_type = objArrayKlass::cast(array_type)->element_klass();
Klass* elem_type = ObjArrayKlass::cast(array_type)->element_klass();
result = oopFactory::new_objArray(elem_type, len, THREAD);
}
@ -323,7 +323,7 @@ JRT_BLOCK_ENTRY(void, OptoRuntime::new_array_nozero_C(Klass* array_type, int len
assert(Klass::cast(array_type)->oop_is_typeArray(), "should be called only for type array");
// The oopFactory likes to work with the element type.
BasicType elem_type = typeArrayKlass::cast(array_type)->element_type();
BasicType elem_type = TypeArrayKlass::cast(array_type)->element_type();
result = oopFactory::new_typeArray_nozero(elem_type, len, THREAD);
// Pass oops back through thread local storage. Our apparent type to Java
@ -344,7 +344,7 @@ JRT_BLOCK_ENTRY(void, OptoRuntime::new_array_nozero_C(Klass* array_type, int len
is_deoptimized_caller_frame(thread)) {
// Zero array here if the caller is deoptimized.
int size = ((typeArrayOop)result)->object_size();
BasicType elem_type = typeArrayKlass::cast(array_type)->element_type();
BasicType elem_type = TypeArrayKlass::cast(array_type)->element_type();
const size_t hs = arrayOopDesc::header_size(elem_type);
// Align to next 8 bytes to avoid trashing arrays's length.
const size_t aligned_hs = align_object_offset(hs);
@ -370,7 +370,7 @@ JRT_ENTRY(void, OptoRuntime::multianewarray2_C(Klass* elem_type, int len1, int l
jint dims[2];
dims[0] = len1;
dims[1] = len2;
oop obj = arrayKlass::cast(elem_type)->multi_allocate(2, dims, THREAD);
oop obj = ArrayKlass::cast(elem_type)->multi_allocate(2, dims, THREAD);
deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
thread->set_vm_result(obj);
JRT_END
@ -386,7 +386,7 @@ JRT_ENTRY(void, OptoRuntime::multianewarray3_C(Klass* elem_type, int len1, int l
dims[0] = len1;
dims[1] = len2;
dims[2] = len3;
oop obj = arrayKlass::cast(elem_type)->multi_allocate(3, dims, THREAD);
oop obj = ArrayKlass::cast(elem_type)->multi_allocate(3, dims, THREAD);
deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
thread->set_vm_result(obj);
JRT_END
@ -403,7 +403,7 @@ JRT_ENTRY(void, OptoRuntime::multianewarray4_C(Klass* elem_type, int len1, int l
dims[1] = len2;
dims[2] = len3;
dims[3] = len4;
oop obj = arrayKlass::cast(elem_type)->multi_allocate(4, dims, THREAD);
oop obj = ArrayKlass::cast(elem_type)->multi_allocate(4, dims, THREAD);
deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
thread->set_vm_result(obj);
JRT_END
@ -421,7 +421,7 @@ JRT_ENTRY(void, OptoRuntime::multianewarray5_C(Klass* elem_type, int len1, int l
dims[2] = len3;
dims[3] = len4;
dims[4] = len5;
oop obj = arrayKlass::cast(elem_type)->multi_allocate(5, dims, THREAD);
oop obj = ArrayKlass::cast(elem_type)->multi_allocate(5, dims, THREAD);
deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
thread->set_vm_result(obj);
JRT_END
@ -438,7 +438,7 @@ JRT_ENTRY(void, OptoRuntime::multianewarrayN_C(Klass* elem_type, arrayOopDesc* d
jint *c_dims = NEW_RESOURCE_ARRAY(jint, len);
Copy::conjoint_jints_atomic(j_dims, c_dims, len);
oop obj = arrayKlass::cast(elem_type)->multi_allocate(len, c_dims, THREAD);
oop obj = ArrayKlass::cast(elem_type)->multi_allocate(len, c_dims, THREAD);
deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
thread->set_vm_result(obj);
JRT_END

31
hotspot/src/share/vm/prims/jni.cpp
View File

@ -1,5 +1,6 @@
/*
* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2012 Red Hat, Inc.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -2820,10 +2821,9 @@ JNI_END
JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \
JNIWrapper("Set" XSTR(Result) "Field"); \
\
HS_DTRACE_PROBE_CDECL_N(hotspot_jni, Set##Result##Field__entry, \
( JNIEnv*, jobject, jfieldID FP_SELECT_##Result(COMMA Argument,/*empty*/) ) ); \
HS_DTRACE_PROBE_N(hotspot_jni, Set##Result##Field__entry, \
( env, obj, fieldID FP_SELECT_##Result(COMMA value,/*empty*/) ) ); \
FP_SELECT_##Result( \
DTRACE_PROBE4(hotspot_jni, Set##Result##Field__entry, env, obj, fieldID, value), \
DTRACE_PROBE3(hotspot_jni, Set##Result##Field__entry, env, obj, fieldID)); \
\
oop o = JNIHandles::resolve_non_null(obj); \
Klass* k = o->klass(); \
@ -3130,10 +3130,9 @@ JNI_END
\
JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \
JNIWrapper("SetStatic" XSTR(Result) "Field"); \
HS_DTRACE_PROBE_CDECL_N(hotspot_jni, SetStatic##Result##Field__entry,\
( JNIEnv*, jclass, jfieldID FP_SELECT_##Result(COMMA Argument,/*empty*/) ) ); \
HS_DTRACE_PROBE_N(hotspot_jni, SetStatic##Result##Field__entry, \
( env, clazz, fieldID FP_SELECT_##Result(COMMA value,/*empty*/) ) ); \
FP_SELECT_##Result( \
DTRACE_PROBE4(hotspot_jni, SetStatic##Result##Field__entry, env, clazz, fieldID, value), \
DTRACE_PROBE3(hotspot_jni, SetStatic##Result##Field__entry, env, clazz, fieldID)); \
\
JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
assert(id->is_static_field_id(), "invalid static field id"); \
@ -3442,8 +3441,8 @@ JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass ele
KlassHandle ek(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass)));
Klass* ako = Klass::cast(ek())->array_klass(CHECK_NULL);
KlassHandle ak = KlassHandle(THREAD, ako);
objArrayKlass::cast(ak())->initialize(CHECK_NULL);
objArrayOop result = objArrayKlass::cast(ak())->allocate(length, CHECK_NULL);
ObjArrayKlass::cast(ak())->initialize(CHECK_NULL);
objArrayOop result = ObjArrayKlass::cast(ak())->allocate(length, CHECK_NULL);
oop initial_value = JNIHandles::resolve(initialElement);
if (initial_value != NULL) { // array already initialized with NULL
for (int index = 0; index < length; index++) {
@ -3502,7 +3501,7 @@ JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize
objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
oop v = JNIHandles::resolve(value);
if (a->is_within_bounds(index)) {
if (v == NULL || v->is_a(objArrayKlass::cast(a->klass())->element_klass())) {
if (v == NULL || v->is_a(ObjArrayKlass::cast(a->klass())->element_klass())) {
a->obj_at_put(index, v);
} else {
THROW(vmSymbols::java_lang_ArrayStoreException());
@ -3787,7 +3786,7 @@ jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start,
THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
} else { \
if (len > 0) { \
int sc = typeArrayKlass::cast(src->klass())->log2_element_size(); \
int sc = TypeArrayKlass::cast(src->klass())->log2_element_size(); \
memcpy((u_char*) buf, \
(u_char*) src->Tag##_at_addr(start), \
len << sc); \
@ -3822,7 +3821,7 @@ jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start,
THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
} else { \
if (len > 0) { \
int sc = typeArrayKlass::cast(src->klass())->log2_element_size(); \
int sc = TypeArrayKlass::cast(src->klass())->log2_element_size(); \
memcpy((u_char*) buf, \
(u_char*) src->Tag##_at_addr(start), \
len << sc); \
@ -3871,7 +3870,7 @@ jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start,
THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
} else { \
if (len > 0) { \
int sc = typeArrayKlass::cast(dst->klass())->log2_element_size(); \
int sc = TypeArrayKlass::cast(dst->klass())->log2_element_size(); \
memcpy((u_char*) dst->Tag##_at_addr(start), \
(u_char*) buf, \
len << sc); \
@ -3906,7 +3905,7 @@ jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start,
THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
} else { \
if (len > 0) { \
int sc = typeArrayKlass::cast(dst->klass())->log2_element_size(); \
int sc = TypeArrayKlass::cast(dst->klass())->log2_element_size(); \
memcpy((u_char*) dst->Tag##_at_addr(start), \
(u_char*) buf, \
len << sc); \
@ -4251,7 +4250,7 @@ JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboole
if (a->is_objArray()) {
type = T_OBJECT;
} else {
type = typeArrayKlass::cast(a->klass())->element_type();
type = TypeArrayKlass::cast(a->klass())->element_type();
}
void* ret = arrayOop(a)->base(type);
#ifndef USDT2

2
hotspot/src/share/vm/prims/jniCheck.cpp
View File

@ -290,7 +290,7 @@ checkArray(JavaThread* thr, jarray jArray, int elementType)
if (elementType != -1) {
if (aOop->is_typeArray()) {
BasicType array_type = typeArrayKlass::cast(aOop->klass())->element_type();
BasicType array_type = TypeArrayKlass::cast(aOop->klass())->element_type();
if (array_type != elementType)
ReportJNIFatalError(thr, fatal_element_type_mismatch);
} else if (aOop->is_objArray()) {

8
hotspot/src/share/vm/prims/jvm.cpp
View File

@ -1048,7 +1048,7 @@ JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls))
if (signers == NULL) return NULL;
// copy of the signers array
Klass* element = objArrayKlass::cast(signers->klass())->element_klass();
Klass* element = ObjArrayKlass::cast(signers->klass())->element_klass();
objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL);
for (int index = 0; index < signers->length(); index++) {
signers_copy->obj_at_put(index, signers->obj_at(index));
@ -3302,10 +3302,10 @@ JVM_ENTRY(jobject, JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currCla
if (k->oop_is_typeArray()) {
// typeArray
result = typeArrayKlass::cast(k)->allocate(length, CHECK_NULL);
result = TypeArrayKlass::cast(k)->allocate(length, CHECK_NULL);
} else if (k->oop_is_objArray()) {
// objArray
objArrayKlass* oak = objArrayKlass::cast(k);
ObjArrayKlass* oak = ObjArrayKlass::cast(k);
oak->initialize(CHECK_NULL); // make sure class is initialized (matches Classic VM behavior)
result = oak->allocate(length, CHECK_NULL);
} else {
@ -4193,7 +4193,7 @@ JVM_ENTRY(jobjectArray, JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobject
}
// check if threads is not an array of objects of Thread class
Klass* k = objArrayKlass::cast(ah->klass())->element_klass();
Klass* k = ObjArrayKlass::cast(ah->klass())->element_klass();
if (k != SystemDictionary::Thread_klass()) {
THROW_(vmSymbols::java_lang_IllegalArgumentException(), 0);
}

2
hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp
View File

@ -2606,7 +2606,7 @@ void VM_RedefineClasses::set_new_constant_pool(
void VM_RedefineClasses::adjust_array_vtable(Klass* k_oop) {
arrayKlass* ak = arrayKlass::cast(k_oop);
ArrayKlass* ak = ArrayKlass::cast(k_oop);
bool trace_name_printed = false;
ak->vtable()->adjust_method_entries(_matching_old_methods,
_matching_new_methods,

4
hotspot/src/share/vm/prims/jvmtiTagMap.cpp
View File

@ -1075,7 +1075,7 @@ static jint invoke_array_primitive_value_callback(jvmtiArrayPrimitiveValueCallba
// get base address of first element
typeArrayOop array = typeArrayOop(obj);
BasicType type = typeArrayKlass::cast(array->klass())->element_type();
BasicType type = TypeArrayKlass::cast(array->klass())->element_type();
void* elements = array->base(type);
// jvmtiPrimitiveType is defined so this mapping is always correct
@ -2750,7 +2750,7 @@ inline bool VM_HeapWalkOperation::iterate_over_array(oop o) {
objArrayOop array = objArrayOop(o);
// array reference to its class
oop mirror = objArrayKlass::cast(array->klass())->java_mirror();
oop mirror = ObjArrayKlass::cast(array->klass())->java_mirror();
if (!CallbackInvoker::report_class_reference(o, mirror)) {
return false;
}

2
hotspot/src/share/vm/prims/unsafe.cpp
View File

@ -802,7 +802,7 @@ static void getBaseAndScale(int& base, int& scale, jclass acls, TRAPS) {
base = arrayOopDesc::base_offset_in_bytes(T_OBJECT);
scale = heapOopSize;
} else if (k->oop_is_typeArray()) {
typeArrayKlass* tak = typeArrayKlass::cast(k);
TypeArrayKlass* tak = TypeArrayKlass::cast(k);
base = tak->array_header_in_bytes();
assert(base == arrayOopDesc::base_offset_in_bytes(tak->element_type()), "array_header_size semantics ok");
scale = (1 << tak->log2_element_size());

2
hotspot/src/share/vm/runtime/advancedThresholdPolicy.cpp
View File

@ -156,7 +156,7 @@ bool AdvancedThresholdPolicy::is_method_profiled(Method* method) {
// Called with the queue locked and with at least one element
CompileTask* AdvancedThresholdPolicy::select_task(CompileQueue* compile_queue) {
CompileTask *max_task = NULL;
Method* max_method;
Method* max_method = NULL;
jlong t = os::javaTimeMillis();
// Iterate through the queue and find a method with a maximum rate.
for (CompileTask* task = compile_queue->first(); task != NULL;) {

6
hotspot/src/share/vm/runtime/deoptimization.cpp
View File

@ -755,12 +755,12 @@ bool Deoptimization::realloc_objects(JavaThread* thread, frame* fr, GrowableArra
InstanceKlass* ik = InstanceKlass::cast(k());
obj = ik->allocate_instance(CHECK_(false));
} else if (k->oop_is_typeArray()) {
typeArrayKlass* ak = typeArrayKlass::cast(k());
TypeArrayKlass* ak = TypeArrayKlass::cast(k());
assert(sv->field_size() % type2size[ak->element_type()] == 0, "non-integral array length");
int len = sv->field_size() / type2size[ak->element_type()];
obj = ak->allocate(len, CHECK_(false));
} else if (k->oop_is_objArray()) {
objArrayKlass* ak = objArrayKlass::cast(k());
ObjArrayKlass* ak = ObjArrayKlass::cast(k());
obj = ak->allocate(sv->field_size(), CHECK_(false));
}
@ -923,7 +923,7 @@ void Deoptimization::reassign_fields(frame* fr, RegisterMap* reg_map, GrowableAr
FieldReassigner reassign(fr, reg_map, sv, obj());
ik->do_nonstatic_fields(&reassign);
} else if (k->oop_is_typeArray()) {
typeArrayKlass* ak = typeArrayKlass::cast(k());
TypeArrayKlass* ak = TypeArrayKlass::cast(k());
reassign_type_array_elements(fr, reg_map, sv, (typeArrayOop) obj(), ak->element_type());
} else if (k->oop_is_objArray()) {
reassign_object_array_elements(fr, reg_map, sv, (objArrayOop) obj());

3
hotspot/src/share/vm/runtime/globals.hpp
View File

@ -1066,9 +1066,6 @@ class CommandLineFlags {
\
product(bool, MonitorInUseLists, false, "Track Monitors for Deflation") \
\
product(intx, Atomics, 0, \
"(Unsafe,Unstable) Diagnostic - Controls emission of atomics") \
\
product(intx, SyncFlags, 0, "(Unsafe,Unstable) Experimental Sync flags" ) \
\
product(intx, SyncVerbose, 0, "(Unstable)" ) \

26
hotspot/src/share/vm/runtime/reflection.cpp
View File

@ -212,7 +212,7 @@ BasicType Reflection::array_get(jvalue* value, arrayOop a, int index, TRAPS) {
return T_OBJECT;
} else {
assert(a->is_typeArray(), "just checking");
BasicType type = typeArrayKlass::cast(a->klass())->element_type();
BasicType type = TypeArrayKlass::cast(a->klass())->element_type();
switch (type) {
case T_BOOLEAN:
value->z = typeArrayOop(a)->bool_at(index);
@ -254,7 +254,7 @@ void Reflection::array_set(jvalue* value, arrayOop a, int index, BasicType value
if (value_type == T_OBJECT) {
oop obj = (oop) value->l;
if (obj != NULL) {
Klass* element_klass = objArrayKlass::cast(a->klass())->element_klass();
Klass* element_klass = ObjArrayKlass::cast(a->klass())->element_klass();
if (!obj->is_a(element_klass)) {
THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "array element type mismatch");
}
@ -263,7 +263,7 @@ void Reflection::array_set(jvalue* value, arrayOop a, int index, BasicType value
}
} else {
assert(a->is_typeArray(), "just checking");
BasicType array_type = typeArrayKlass::cast(a->klass())->element_type();
BasicType array_type = TypeArrayKlass::cast(a->klass())->element_type();
if (array_type != value_type) {
// The widen operation can potentially throw an exception, but cannot block,
// so typeArrayOop a is safe if the call succeeds.
@ -313,7 +313,7 @@ Klass* Reflection::basic_type_mirror_to_arrayklass(oop basic_type_mirror, TRAPS)
oop Reflection:: basic_type_arrayklass_to_mirror(Klass* basic_type_arrayklass, TRAPS) {
BasicType type = typeArrayKlass::cast(basic_type_arrayklass)->element_type();
BasicType type = TypeArrayKlass::cast(basic_type_arrayklass)->element_type();
return Universe::java_mirror(type);
}
@ -327,10 +327,10 @@ arrayOop Reflection::reflect_new_array(oop element_mirror, jint length, TRAPS) {
}
if (java_lang_Class::is_primitive(element_mirror)) {
Klass* tak = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);
return typeArrayKlass::cast(tak)->allocate(length, THREAD);
return TypeArrayKlass::cast(tak)->allocate(length, THREAD);
} else {
Klass* k = java_lang_Class::as_Klass(element_mirror);
if (Klass::cast(k)->oop_is_array() && arrayKlass::cast(k)->dimension() >= MAX_DIM) {
if (Klass::cast(k)->oop_is_array() && ArrayKlass::cast(k)->dimension() >= MAX_DIM) {
THROW_0(vmSymbols::java_lang_IllegalArgumentException());
}
return oopFactory::new_objArray(k, length, THREAD);
@ -340,7 +340,7 @@ arrayOop Reflection::reflect_new_array(oop element_mirror, jint length, TRAPS) {
arrayOop Reflection::reflect_new_multi_array(oop element_mirror, typeArrayOop dim_array, TRAPS) {
assert(dim_array->is_typeArray(), "just checking");
assert(typeArrayKlass::cast(dim_array->klass())->element_type() == T_INT, "just checking");
assert(TypeArrayKlass::cast(dim_array->klass())->element_type() == T_INT, "just checking");
if (element_mirror == NULL) {
THROW_0(vmSymbols::java_lang_NullPointerException());
@ -367,7 +367,7 @@ arrayOop Reflection::reflect_new_multi_array(oop element_mirror, typeArrayOop di
} else {
klass = java_lang_Class::as_Klass(element_mirror);
if (Klass::cast(klass)->oop_is_array()) {
int k_dim = arrayKlass::cast(klass)->dimension();
int k_dim = ArrayKlass::cast(klass)->dimension();
if (k_dim + len > MAX_DIM) {
THROW_0(vmSymbols::java_lang_IllegalArgumentException());
}
@ -375,7 +375,7 @@ arrayOop Reflection::reflect_new_multi_array(oop element_mirror, typeArrayOop di
}
}
klass = Klass::cast(klass)->array_klass(dim, CHECK_NULL);
oop obj = arrayKlass::cast(klass)->multi_allocate(len, dimensions, THREAD);
oop obj = ArrayKlass::cast(klass)->multi_allocate(len, dimensions, THREAD);
assert(obj->is_array(), "just checking");
return arrayOop(obj);
}
@ -391,17 +391,17 @@ oop Reflection::array_component_type(oop mirror, TRAPS) {
return NULL;
}
oop result = arrayKlass::cast(klass)->component_mirror();
oop result = ArrayKlass::cast(klass)->component_mirror();
#ifdef ASSERT
oop result2 = NULL;
if (arrayKlass::cast(klass)->dimension() == 1) {
if (ArrayKlass::cast(klass)->dimension() == 1) {
if (Klass::cast(klass)->oop_is_typeArray()) {
result2 = basic_type_arrayklass_to_mirror(klass, CHECK_NULL);
} else {
result2 = Klass::cast(objArrayKlass::cast(klass)->element_klass())->java_mirror();
result2 = Klass::cast(ObjArrayKlass::cast(klass)->element_klass())->java_mirror();
}
} else {
Klass* lower_dim = arrayKlass::cast(klass)->lower_dimension();
Klass* lower_dim = ArrayKlass::cast(klass)->lower_dimension();
assert(Klass::cast(lower_dim)->oop_is_array(), "just checking");
result2 = Klass::cast(lower_dim)->java_mirror();
}

2
hotspot/src/share/vm/runtime/sharedRuntime.cpp
View File

@ -2705,7 +2705,7 @@ void SharedRuntime::get_utf(oopDesc* src, address dst) {
int jlsLen = java_lang_String::length(src);
jchar* jlsPos = (jlsLen == 0) ? NULL :
jlsValue->char_at_addr(jlsOffset);
assert(typeArrayKlass::cast(jlsValue->klass())->element_type() == T_CHAR, "compressed string");
assert(TypeArrayKlass::cast(jlsValue->klass())->element_type() == T_CHAR, "compressed string");
(void) UNICODE::as_utf8(jlsPos, jlsLen, (char *)dst, max_dtrace_string_size);
}
#endif // ndef HAVE_DTRACE_H

24
hotspot/src/share/vm/runtime/vmStructs.cpp
View File

@ -268,12 +268,12 @@ typedef TwoOopHashtable<Symbol*, mtClass> SymbolTwoOopHashtable;
volatile_nonstatic_field(oopDesc, _metadata._klass, Klass*) \
volatile_nonstatic_field(oopDesc, _metadata._compressed_klass, narrowOop) \
static_field(oopDesc, _bs, BarrierSet*) \
nonstatic_field(arrayKlass, _dimension, int) \
volatile_nonstatic_field(arrayKlass, _higher_dimension, Klass*) \
volatile_nonstatic_field(arrayKlass, _lower_dimension, Klass*) \
nonstatic_field(arrayKlass, _vtable_len, int) \
nonstatic_field(arrayKlass, _alloc_size, juint) \
nonstatic_field(arrayKlass, _component_mirror, oop) \
nonstatic_field(ArrayKlass, _dimension, int) \
volatile_nonstatic_field(ArrayKlass, _higher_dimension, Klass*) \
volatile_nonstatic_field(ArrayKlass, _lower_dimension, Klass*) \
nonstatic_field(ArrayKlass, _vtable_len, int) \
nonstatic_field(ArrayKlass, _alloc_size, juint) \
nonstatic_field(ArrayKlass, _component_mirror, oop) \
nonstatic_field(CompiledICHolder, _holder_method, Method*) \
nonstatic_field(CompiledICHolder, _holder_klass, Klass*) \
nonstatic_field(ConstantPool, _tags, Array<u1>*) \
@ -379,13 +379,13 @@ typedef TwoOopHashtable<Symbol*, mtClass> SymbolTwoOopHashtable;
nonstatic_field(ConstMethod, _signature_index, u2) \
nonstatic_field(ConstMethod, _method_idnum, u2) \
nonstatic_field(ConstMethod, _generic_signature_index, u2) \
nonstatic_field(objArrayKlass, _element_klass, Klass*) \
nonstatic_field(objArrayKlass, _bottom_klass, Klass*) \
nonstatic_field(ObjArrayKlass, _element_klass, Klass*) \
nonstatic_field(ObjArrayKlass, _bottom_klass, Klass*) \
volatile_nonstatic_field(Symbol, _refcount, int) \
nonstatic_field(Symbol, _identity_hash, int) \
nonstatic_field(Symbol, _length, unsigned short) \
unchecked_nonstatic_field(Symbol, _body, sizeof(jbyte)) /* NOTE: no type */ \
nonstatic_field(typeArrayKlass, _max_length, int) \
nonstatic_field(TypeArrayKlass, _max_length, int) \
\
/***********************/ \
/* Constant Pool Cache */ \
@ -1370,9 +1370,9 @@ typedef TwoOopHashtable<Symbol*, mtClass> SymbolTwoOopHashtable;
declare_toplevel_type(MetaspaceObj) \
declare_type(Metadata, MetaspaceObj) \
declare_type(Klass, Metadata) \
declare_type(arrayKlass, Klass) \
declare_type(objArrayKlass, arrayKlass) \
declare_type(typeArrayKlass, arrayKlass) \
declare_type(ArrayKlass, Klass) \
declare_type(ObjArrayKlass, ArrayKlass) \
declare_type(TypeArrayKlass, ArrayKlass) \
declare_type(InstanceKlass, Klass) \
declare_type(InstanceClassLoaderKlass, InstanceKlass) \
declare_type(InstanceMirrorKlass, InstanceKlass) \

2
hotspot/src/share/vm/services/attachListener.cpp
View File

@ -88,7 +88,7 @@ static jint get_properties(AttachOperation* op, outputStream* out, Symbol* seria
// The result should be a [B
oop res = (oop)result.get_jobject();
assert(res->is_typeArray(), "just checking");
assert(typeArrayKlass::cast(res->klass())->element_type() == T_BYTE, "just checking");
assert(TypeArrayKlass::cast(res->klass())->element_type() == T_BYTE, "just checking");
// copy the bytes to the output stream
typeArrayOop ba = typeArrayOop(res);

2
hotspot/src/share/vm/services/diagnosticCommand.cpp
View File

@ -204,7 +204,7 @@ void PrintSystemPropertiesDCmd::execute(TRAPS) {
// The result should be a [B
oop res = (oop)result.get_jobject();
assert(res->is_typeArray(), "just checking");
assert(typeArrayKlass::cast(res->klass())->element_type() == T_BYTE, "just checking");
assert(TypeArrayKlass::cast(res->klass())->element_type() == T_BYTE, "just checking");
// copy the bytes to the output stream
typeArrayOop ba = typeArrayOop(res);

4
hotspot/src/share/vm/services/heapDumper.cpp
View File

@ -933,7 +933,7 @@ void DumperSupport::dump_class_and_array_classes(DumpWriter* writer, Klass* k) {
k = klass->array_klass_or_null();
while (k != NULL) {
Klass* klass = Klass::cast(k);
assert(klass->oop_is_objArray(), "not an objArrayKlass");
assert(klass->oop_is_objArray(), "not an ObjArrayKlass");
writer->write_u1(HPROF_GC_CLASS_DUMP);
writer->write_classID(klass);
@ -1016,7 +1016,7 @@ void DumperSupport::dump_object_array(DumpWriter* writer, objArrayOop array) {
// creates HPROF_GC_PRIM_ARRAY_DUMP record for the given type array
void DumperSupport::dump_prim_array(DumpWriter* writer, typeArrayOop array) {
BasicType type = typeArrayKlass::cast(array->klass())->element_type();
BasicType type = TypeArrayKlass::cast(array->klass())->element_type();
writer->write_u1(HPROF_GC_PRIM_ARRAY_DUMP);
writer->write_objectID(array);

10
hotspot/src/share/vm/services/management.cpp
View File

@ -426,7 +426,7 @@ static void validate_thread_id_array(typeArrayHandle ids_ah, TRAPS) {
static void validate_thread_info_array(objArrayHandle infoArray_h, TRAPS) {
// check if the element of infoArray is of type ThreadInfo class
Klass* threadinfo_klass = Management::java_lang_management_ThreadInfo_klass(CHECK);
Klass* element_klass = objArrayKlass::cast(infoArray_h->klass())->element_klass();
Klass* element_klass = ObjArrayKlass::cast(infoArray_h->klass())->element_klass();
if (element_klass != threadinfo_klass) {
THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
"infoArray element type is not ThreadInfo class");
@ -1715,7 +1715,7 @@ JVM_ENTRY(jint, jmm_GetVMGlobals(JNIEnv *env,
objArrayOop ta = objArrayOop(JNIHandles::resolve_non_null(names));
objArrayHandle names_ah(THREAD, ta);
// Make sure we have a String array
Klass* element_klass = objArrayKlass::cast(names_ah->klass())->element_klass();
Klass* element_klass = ObjArrayKlass::cast(names_ah->klass())->element_klass();
if (element_klass != SystemDictionary::String_klass()) {
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
"Array element type is not String class", 0);
@ -1891,7 +1891,7 @@ JVM_ENTRY(jint, jmm_GetInternalThreadTimes(JNIEnv *env,
objArrayHandle names_ah(THREAD, na);
// Make sure we have a String array
Klass* element_klass = objArrayKlass::cast(names_ah->klass())->element_klass();
Klass* element_klass = ObjArrayKlass::cast(names_ah->klass())->element_klass();
if (element_klass != SystemDictionary::String_klass()) {
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
"Array element type is not String class", 0);
@ -2008,7 +2008,7 @@ static objArrayOop get_memory_usage_objArray(jobjectArray array, int length, TRA
// check if the element of array is of type MemoryUsage class
Klass* usage_klass = Management::java_lang_management_MemoryUsage_klass(CHECK_0);
Klass* element_klass = objArrayKlass::cast(array_h->klass())->element_klass();
Klass* element_klass = ObjArrayKlass::cast(array_h->klass())->element_klass();
if (element_klass != usage_klass) {
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
"The element type is not MemoryUsage class", 0);
@ -2156,7 +2156,7 @@ JVM_ENTRY(void, jmm_GetDiagnosticCommandInfo(JNIEnv *env, jobjectArray cmds,
objArrayHandle cmds_ah(THREAD, ca);
// Make sure we have a String array
Klass* element_klass = objArrayKlass::cast(cmds_ah->klass())->element_klass();
Klass* element_klass = ObjArrayKlass::cast(cmds_ah->klass())->element_klass();
if (element_klass != SystemDictionary::String_klass()) {
THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
"Array element type is not String class");

2
hotspot/src/share/vm/services/threadService.cpp
View File

@ -250,7 +250,7 @@ Handle ThreadService::dump_stack_traces(GrowableArray<instanceHandle>* threads,
ResourceMark rm(THREAD);
Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_StackTraceElement_array(), true, CHECK_NH);
objArrayKlass* ik = objArrayKlass::cast(k);
ObjArrayKlass* ik = ObjArrayKlass::cast(k);
objArrayOop r = oopFactory::new_objArray(ik, num_threads, CHECK_NH);
objArrayHandle result_obj(THREAD, r);

2
hotspot/src/share/vm/shark/sharkRuntime.cpp
View File

@ -129,7 +129,7 @@ JRT_ENTRY(void, SharkRuntime::multianewarray(JavaThread* thread,
int ndims,
int* dims))
Klass* klass = method(thread)->constants()->klass_at(index, CHECK);
oop obj = arrayKlass::cast(klass)->multi_allocate(ndims, dims, CHECK);
oop obj = ArrayKlass::cast(klass)->multi_allocate(ndims, dims, CHECK);
thread->set_vm_result(obj);
JRT_END

51
hotspot/src/share/vm/utilities/dtrace.hpp
View File

@ -1,5 +1,6 @@
/*
* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2009, 2012 Red Hat, Inc.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -32,13 +33,17 @@
#define DTRACE_ONLY(x) x
#define NOT_DTRACE(x)
#if defined(SOLARIS)
// Work around dtrace tail call bug 6672627 until it is fixed in solaris 10.
#define HS_DTRACE_WORKAROUND_TAIL_CALL_BUG() \
do { volatile size_t dtrace_workaround_tail_call_bug = 1; } while (0)
#if defined(SOLARIS)
#define USDT1 1
#elif defined(LINUX)
#define HS_DTRACE_WORKAROUND_TAIL_CALL_BUG()
#define USDT1 1
#elif defined(__APPLE__)
#define HS_DTRACE_WORKAROUND_TAIL_CALL_BUG()
#define USDT2 1
#include <sys/types.h>
#include "dtracefiles/hotspot.h"
@ -63,6 +68,11 @@
#define DTRACE_PROBE3(a,b,c,d,e) {;}
#define DTRACE_PROBE4(a,b,c,d,e,f) {;}
#define DTRACE_PROBE5(a,b,c,d,e,f,g) {;}
#define DTRACE_PROBE6(a,b,c,d,e,f,g,h) {;}
#define DTRACE_PROBE7(a,b,c,d,e,f,g,h,i) {;}
#define DTRACE_PROBE8(a,b,c,d,e,f,g,h,i,j) {;}
#define DTRACE_PROBE9(a,b,c,d,e,f,g,h,i,j,k) {;}
#define DTRACE_PROBE10(a,b,c,d,e,f,g,h,i,j,k,l) {;}
#else /* USDT2 */
@ -76,10 +86,18 @@
#define HS_DTRACE_PROBE_FN(provider,name)\
__dtrace_##provider##___##name
#ifdef SOLARIS
// Solaris dtrace needs actual extern function decls.
#define HS_DTRACE_PROBE_DECL_N(provider,name,args) \
DTRACE_ONLY(extern "C" void HS_DTRACE_PROBE_FN(provider,name) args)
#define HS_DTRACE_PROBE_CDECL_N(provider,name,args) \
DTRACE_ONLY(extern void HS_DTRACE_PROBE_FN(provider,name) args)
#else
// Systemtap dtrace compatible probes on GNU/Linux don't.
// If dtrace is disabled this macro becomes NULL
#define HS_DTRACE_PROBE_DECL_N(provider,name,args)
#define HS_DTRACE_PROBE_CDECL_N(provider,name,args)
#endif
/* Dtrace probe declarations */
#define HS_DTRACE_PROBE_DECL(provider,name) \
@ -118,6 +136,8 @@
uintptr_t,uintptr_t,uintptr_t))
/* Dtrace probe definitions */
#if defined(SOLARIS)
// Solaris dtrace uses actual function calls.
#define HS_DTRACE_PROBE_N(provider,name, args) \
DTRACE_ONLY(HS_DTRACE_PROBE_FN(provider,name) args)
@ -153,6 +173,33 @@
HS_DTRACE_PROBE_N(provider,name,((uintptr_t)a0,(uintptr_t)a1,(uintptr_t)a2,\
(uintptr_t)a3,(uintptr_t)a4,(uintptr_t)a5,(uintptr_t)a6,(uintptr_t)a7,\
(uintptr_t)a8,(uintptr_t)a9))
#else
// Systemtap dtrace compatible probes on GNU/Linux use direct macros.
// If dtrace is disabled this macro becomes NULL
#define HS_DTRACE_PROBE(provider,name) HS_DTRACE_PROBE0(provider,name)
#define HS_DTRACE_PROBE0(provider,name)\
DTRACE_PROBE(provider,name)
#define HS_DTRACE_PROBE1(provider,name,a0)\
DTRACE_PROBE1(provider,name,a0)
#define HS_DTRACE_PROBE2(provider,name,a0,a1)\
DTRACE_PROBE2(provider,name,a0,a1)
#define HS_DTRACE_PROBE3(provider,name,a0,a1,a2)\
DTRACE_PROBE3(provider,name,a0,a1,a2)
#define HS_DTRACE_PROBE4(provider,name,a0,a1,a2,a3)\
DTRACE_PROBE4(provider,name,a0,a1,a2,a3)
#define HS_DTRACE_PROBE5(provider,name,a0,a1,a2,a3,a4)\
DTRACE_PROBE5(provider,name,a0,a1,a2,a3,a4)
#define HS_DTRACE_PROBE6(provider,name,a0,a1,a2,a3,a4,a5)\
DTRACE_PROBE6(provider,name,a0,a1,a2,a3,a4,a5)
#define HS_DTRACE_PROBE7(provider,name,a0,a1,a2,a3,a4,a5,a6)\
DTRACE_PROBE7(provider,name,a0,a1,a2,a3,a4,a5,a6)
#define HS_DTRACE_PROBE8(provider,name,a0,a1,a2,a3,a4,a5,a6,a7)\
DTRACE_PROBE8(provider,name,a0,a1,a2,a3,a4,a5,a6,a7)
#define HS_DTRACE_PROBE9(provider,name,a0,a1,a2,a3,a4,a5,a6,a7,a8)\
DTRACE_PROBE9(provider,name,a0,a1,a2,a3,a4,a5,a6,a7,a8)
#define HS_DTRACE_PROBE10(provider,name,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9)\
DTRACE_PROBE10(provider,name,a0,a1,a2,a3,a4,a5,a6,a7,a8,a9)
#endif
#endif /* !USDT2 */

2
hotspot/test/runtime/7194254/Test7194254.java
View File

@ -27,7 +27,7 @@
* @summary Creates several threads with different java priorities and checks
* whether jstack reports correct priorities for them.
*
* @run main T7194254
* @run main Test7194254
*/
import java.io.BufferedReader;

2
hotspot/test/runtime/7196045/Test7196045.java
View File

@ -26,7 +26,7 @@
* @test
* @bug 7196045
* @summary Possible JVM deadlock in ThreadTimesClosure when using HotspotInternal non-public API.
* @run main/othervm
* @run main/othervm Test7196045
*/
import java.lang.management.ManagementFactory;