--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ArrayKlass.java Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ArrayKlass.java Tue Oct 09 07:41:27 2012 +0200
@@ -44,7 +44,7 @@
}
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);
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Klass.java Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Klass.java Tue Oct 09 07:41:27 2012 +0200
@@ -188,11 +188,11 @@
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
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Metadata.java Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Metadata.java Tue Oct 09 07:41:27 2012 +0200
@@ -55,8 +55,8 @@
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);
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ObjArrayKlass.java Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ObjArrayKlass.java Tue Oct 09 07:41:27 2012 +0200
@@ -43,7 +43,7 @@
}
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);
}
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/TypeArrayKlass.java Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/TypeArrayKlass.java Tue Oct 09 07:41:27 2012 +0200
@@ -31,7 +31,7 @@
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 @@
}
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);
}
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/tools/jcore/ClassWriter.java Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/tools/jcore/ClassWriter.java Tue Oct 09 07:41:27 2012 +0200
@@ -354,15 +354,14 @@
}
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);
--- a/hotspot/agent/src/share/native/sadis.c Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/agent/src/share/native/sadis.c Tue Oct 09 07:41:27 2012 +0200
@@ -46,7 +46,7 @@
#else
-#include <strings.h>
+#include <string.h>
#include <dlfcn.h>
#include <link.h>
--- a/hotspot/make/bsd/makefiles/buildtree.make Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/make/bsd/makefiles/buildtree.make Tue Oct 09 07:41:27 2012 +0200
@@ -163,6 +163,13 @@
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 @@
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)"; \
--- a/hotspot/make/linux/makefiles/buildtree.make Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/make/linux/makefiles/buildtree.make Tue Oct 09 07:41:27 2012 +0200
@@ -156,6 +156,13 @@
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 @@
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)"; \
--- a/hotspot/make/linux/makefiles/dtrace.make Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/make/linux/makefiles/dtrace.make Tue Oct 09 07:41:27 2012 +0200
@@ -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.
+
--- a/hotspot/make/linux/makefiles/vm.make Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/make/linux/makefiles/vm.make Tue Oct 09 07:41:27 2012 +0200
@@ -387,7 +387,7 @@
#----------------------------------------------------------------------
-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
--- a/hotspot/make/solaris/makefiles/buildtree.make Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/make/solaris/makefiles/buildtree.make Tue Oct 09 07:41:27 2012 +0200
@@ -148,6 +148,13 @@
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 @@
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"; \
--- a/hotspot/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -2290,7 +2290,7 @@
__ 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 @@
__ 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);
--- a/hotspot/src/cpu/sparc/vm/stubGenerator_sparc.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/cpu/sparc/vm/stubGenerator_sparc.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -3091,7 +3091,7 @@
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 @@
__ 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 @@
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
--- a/hotspot/src/cpu/sparc/vm/templateTable_sparc.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/cpu/sparc/vm/templateTable_sparc.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -867,7 +867,7 @@
// 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");
--- a/hotspot/src/cpu/x86/vm/assembler_x86.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/cpu/x86/vm/assembler_x86.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -1170,26 +1170,11 @@
// 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::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 @@
// 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));
}
--- a/hotspot/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -1881,7 +1881,7 @@
__ 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 @@
#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 @@
// 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
--- a/hotspot/src/cpu/x86/vm/stubGenerator_x86_32.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/cpu/x86/vm/stubGenerator_x86_32.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -1801,7 +1801,7 @@
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 @@
__ 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 @@
// 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;
--- a/hotspot/src/cpu/x86/vm/stubGenerator_x86_64.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/cpu/x86/vm/stubGenerator_x86_64.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -2604,7 +2604,7 @@
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 @@
__ 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 @@
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);
--- a/hotspot/src/cpu/x86/vm/templateTable_x86_32.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/cpu/x86/vm/templateTable_x86_32.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -949,7 +949,7 @@
__ 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);
--- a/hotspot/src/cpu/x86/vm/templateTable_x86_64.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/cpu/x86/vm/templateTable_x86_64.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -970,7 +970,7 @@
// 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);
--- a/hotspot/src/cpu/x86/vm/x86_32.ad Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/cpu/x86/vm/x86_32.ad Tue Oct 09 07:41:27 2012 +0200
@@ -12145,8 +12145,8 @@
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 @@
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"
--- a/hotspot/src/os/windows/vm/jvm_windows.h Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/os/windows/vm/jvm_windows.h Tue Oct 09 07:41:27 2012 +0200
@@ -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 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 @@
* File I/O
*/
-// #include <sys/types.h>
-// #include <sys/stat.h>
-// #include <fcntl.h>
-// #include <errno.h>
+#include <sys/stat.h>
/* O Flags */
--- a/hotspot/src/share/vm/c1/c1_Runtime1.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/c1/c1_Runtime1.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -327,7 +327,7 @@
// 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 @@
// 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 @@
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 @@
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 @@
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);
--- a/hotspot/src/share/vm/ci/ciArrayKlass.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/ci/ciArrayKlass.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -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();
}
// ------------------------------------------------------------------
--- a/hotspot/src/share/vm/ci/ciArrayKlass.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/ci/ciArrayKlass.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -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 @@
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 @@
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();
}
--- a/hotspot/src/share/vm/ci/ciEnv.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/ci/ciEnv.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -326,7 +326,7 @@
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(),
--- a/hotspot/src/share/vm/ci/ciKlass.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/ci/ciKlass.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -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 {
--- a/hotspot/src/share/vm/ci/ciObjArrayKlass.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/ci/ciObjArrayKlass.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -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 @@
// 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;
--- a/hotspot/src/share/vm/ci/ciObjArrayKlass.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/ci/ciObjArrayKlass.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -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 @@
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);
--- a/hotspot/src/share/vm/ci/ciObjectFactory.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/ci/ciObjectFactory.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -174,7 +174,7 @@
}
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 @@
// 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 @@
// 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);
--- a/hotspot/src/share/vm/ci/ciTypeArrayKlass.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/ci/ciTypeArrayKlass.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -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(), "");
}
// ------------------------------------------------------------------
--- a/hotspot/src/share/vm/ci/ciTypeArrayKlass.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/ci/ciTypeArrayKlass.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -37,8 +37,8 @@
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"; }
--- a/hotspot/src/share/vm/classfile/classFileParser.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/classfile/classFileParser.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -782,7 +782,7 @@
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 @@
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 @@
}
// 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 @@
// 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 @@
}
// 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 @@
}
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 @@
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 @@
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 @@
"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 @@
// 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 @@
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.
--- a/hotspot/src/share/vm/classfile/classFileParser.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/classfile/classFileParser.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -148,7 +148,7 @@
// 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 @@
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 @@
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 @@
// 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 @@
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);
--- a/hotspot/src/share/vm/classfile/javaClasses.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/classfile/javaClasses.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -540,18 +540,18 @@
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 @@
#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 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 @@
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);
}
--- a/hotspot/src/share/vm/classfile/systemDictionary.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/classfile/systemDictionary.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -244,7 +244,7 @@
}
} 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 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
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));
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -204,7 +204,7 @@
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();
}
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -188,10 +188,10 @@
// 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());
--- a/hotspot/src/share/vm/gc_implementation/shared/markSweep.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/gc_implementation/shared/markSweep.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -115,7 +115,7 @@
// 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());
--- a/hotspot/src/share/vm/interpreter/bytecodeInterpreter.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/interpreter/bytecodeInterpreter.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -1626,7 +1626,7 @@
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
--- a/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -211,7 +211,7 @@
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
--- a/hotspot/src/share/vm/memory/oopFactory.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/memory/oopFactory.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -47,12 +47,12 @@
}
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_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 @@
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);
--- a/hotspot/src/share/vm/memory/oopFactory.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/memory/oopFactory.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -40,19 +40,19 @@
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);
}
--- a/hotspot/src/share/vm/memory/specialized_oop_closures.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/memory/specialized_oop_closures.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -200,7 +200,7 @@
enum Kind {
ik, // InstanceKlass
irk, // InstanceRefKlass
- oa, // objArrayKlass
+ oa, // ObjArrayKlass
NUM_Kinds
};
--- a/hotspot/src/share/vm/memory/universe.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/memory/universe.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -265,14 +265,14 @@
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 @@
{ 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); }
}
--- a/hotspot/src/share/vm/oops/arrayKlass.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/arrayKlass.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -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 @@
}
-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 @@
}
-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 @@
// 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 @@
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 @@
}
-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 @@
}
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 @@
// 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 @@
// 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::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?");
--- a/hotspot/src/share/vm/oops/arrayKlass.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/arrayKlass.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -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 @@
// 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 @@
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 @@
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 @@
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
--- a/hotspot/src/share/vm/oops/constantPool.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/constantPool.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -533,7 +533,7 @@
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
--- a/hotspot/src/share/vm/oops/constantPool.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/constantPool.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -468,7 +468,7 @@
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);
}
--- a/hotspot/src/share/vm/oops/instanceKlass.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/instanceKlass.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -989,13 +989,13 @@
// 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::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 @@
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()) {
--- a/hotspot/src/share/vm/oops/klass.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/klass.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -532,13 +532,13 @@
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 @@
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");
}
}
--- a/hotspot/src/share/vm/oops/klassVtable.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/klassVtable.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -1096,7 +1096,7 @@
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;
}
--- a/hotspot/src/share/vm/oops/klassVtable.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/klassVtable.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -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).
--- a/hotspot/src/share/vm/oops/method.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/method.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -1065,7 +1065,7 @@
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;
--- a/hotspot/src/share/vm/oops/objArrayKlass.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/objArrayKlass.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -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 @@
}
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
// 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 @@
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 @@
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 @@
}
-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 @@
// 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 @@
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 @@
}
}
-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 @@
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 @@
}
#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 @@
#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 @@
#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 @@
// 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_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 @@
}
#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 @@
})
}
-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 @@
// 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 @@
// 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 @@
#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 @@
#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 @@
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 @@
}
}
-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 @@
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++) {
--- a/hotspot/src/share/vm/oops/objArrayKlass.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/objArrayKlass.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -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 @@
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 @@
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 @@
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);
--- a/hotspot/src/share/vm/oops/objArrayKlass.inline.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/objArrayKlass.inline.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -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 @@
}
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 @@
}
#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 @@
}
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());
--- a/hotspot/src/share/vm/oops/objArrayOop.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/objArrayOop.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -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)
--- a/hotspot/src/share/vm/oops/objArrayOop.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/objArrayOop.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -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;
--- a/hotspot/src/share/vm/oops/oop.pcgc.inline.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/oop.pcgc.inline.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -44,7 +44,7 @@
// 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) {
--- a/hotspot/src/share/vm/oops/oop.psgc.inline.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/oop.psgc.inline.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -39,7 +39,7 @@
// 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
--- a/hotspot/src/share/vm/oops/oopsHierarchy.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/oopsHierarchy.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -128,7 +128,7 @@
#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 InstanceMirrorKlass;
class InstanceClassLoaderKlass;
class InstanceRefKlass;
-class arrayKlass;
-class objArrayKlass;
-class typeArrayKlass;
+class ArrayKlass;
+class ObjArrayKlass;
+class TypeArrayKlass;
#endif // SHARE_VM_OOPS_OOPSHIERARCHY_HPP
--- a/hotspot/src/share/vm/oops/typeArrayKlass.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/typeArrayKlass.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -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 @@
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 @@
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 @@
}
}
-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 @@
}
-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 @@
// 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 @@
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 @@
// 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 @@
#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 @@
}
-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 @@
#endif // PRODUCT
-const char* typeArrayKlass::internal_name() const {
+const char* TypeArrayKlass::internal_name() const {
return Klass::external_name();
}
--- a/hotspot/src/share/vm/oops/typeArrayKlass.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/typeArrayKlass.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -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 @@
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 @@
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);
--- a/hotspot/src/share/vm/oops/typeArrayOop.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/oops/typeArrayOop.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -73,7 +73,7 @@
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 @@
public:
int object_size() {
- typeArrayKlass* tk = typeArrayKlass::cast(klass());
+ TypeArrayKlass* tk = TypeArrayKlass::cast(klass());
return object_size(tk->layout_helper(), length());
}
};
--- a/hotspot/src/share/vm/opto/library_call.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/opto/library_call.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -3435,7 +3435,7 @@
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 @@
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);
--- a/hotspot/src/share/vm/opto/memnode.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/opto/memnode.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -1671,9 +1671,9 @@
}
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 @@
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 @@
}
// 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 @@
&& (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 @@
) {
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);
--- a/hotspot/src/share/vm/opto/parseHelper.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/opto/parseHelper.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -200,7 +200,7 @@
// 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) );
--- a/hotspot/src/share/vm/opto/runtime.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/opto/runtime.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -286,13 +286,13 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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
--- a/hotspot/src/share/vm/prims/jni.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/prims/jni.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -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_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_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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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
--- a/hotspot/src/share/vm/prims/jniCheck.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/prims/jniCheck.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -290,7 +290,7 @@
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()) {
--- a/hotspot/src/share/vm/prims/jvm.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/prims/jvm.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -1048,7 +1048,7 @@
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 @@
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 @@
}
// 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);
}
--- a/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -2606,7 +2606,7 @@
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,
--- a/hotspot/src/share/vm/prims/jvmtiTagMap.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/prims/jvmtiTagMap.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -1075,7 +1075,7 @@
// 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 @@
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;
}
--- a/hotspot/src/share/vm/prims/unsafe.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/prims/unsafe.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -802,7 +802,7 @@
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());
--- a/hotspot/src/share/vm/runtime/advancedThresholdPolicy.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/runtime/advancedThresholdPolicy.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -156,7 +156,7 @@
// 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;) {
--- a/hotspot/src/share/vm/runtime/deoptimization.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/runtime/deoptimization.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -755,12 +755,12 @@
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 @@
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());
--- a/hotspot/src/share/vm/runtime/globals.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/runtime/globals.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -1066,9 +1066,6 @@
\
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)" ) \
--- a/hotspot/src/share/vm/runtime/reflection.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/runtime/reflection.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -212,7 +212,7 @@
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 @@
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 @@
}
} 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 @@
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 @@
}
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_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 @@
} 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 @@
}
}
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 @@
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();
}
--- a/hotspot/src/share/vm/runtime/sharedRuntime.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/runtime/sharedRuntime.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -2705,7 +2705,7 @@
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
--- a/hotspot/src/share/vm/runtime/vmStructs.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/runtime/vmStructs.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -268,12 +268,12 @@
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 @@
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 @@
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) \
--- a/hotspot/src/share/vm/services/attachListener.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/services/attachListener.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -88,7 +88,7 @@
// 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);
--- a/hotspot/src/share/vm/services/diagnosticCommand.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/services/diagnosticCommand.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -204,7 +204,7 @@
// 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);
--- a/hotspot/src/share/vm/services/heapDumper.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/services/heapDumper.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -933,7 +933,7 @@
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 @@
// 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);
--- a/hotspot/src/share/vm/services/management.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/services/management.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -426,7 +426,7 @@
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 @@
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 @@
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 @@
// 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 @@
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");
--- a/hotspot/src/share/vm/services/threadService.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/services/threadService.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -250,7 +250,7 @@
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);
--- a/hotspot/src/share/vm/shark/sharkRuntime.cpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/shark/sharkRuntime.cpp Tue Oct 09 07:41:27 2012 +0200
@@ -129,7 +129,7 @@
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
--- a/hotspot/src/share/vm/utilities/dtrace.hpp Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/src/share/vm/utilities/dtrace.hpp Tue Oct 09 07:41:27 2012 +0200
@@ -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 */
--- a/hotspot/test/runtime/7194254/Test7194254.java Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/test/runtime/7194254/Test7194254.java Tue Oct 09 07:41:27 2012 +0200
@@ -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;
--- a/hotspot/test/runtime/7196045/Test7196045.java Fri Oct 05 13:37:08 2012 -0700
+++ b/hotspot/test/runtime/7196045/Test7196045.java Tue Oct 09 07:41:27 2012 +0200
@@ -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;