objArrayKlassKlass.cpp revision 1142
/*
* Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
*/
# include "incls/_precompiled.incl"
# include "incls/_objArrayKlassKlass.cpp.incl"
return k();
}
// system_objArrays have no instance klass, so allocate with fake class, then reset to NULL
return k;
}
}
// Eagerly allocate the direct array supertype.
if (!Universe::is_bootstrapping()) {
if (element_super.not_null()) {
// The element type has a direct super. E.g., String[] has direct super of Object[].
// Also, see if the element has secondary supertypes.
// We need an array type for each.
supers_exist = false;
break;
}
}
if (!supers_exist) {
// Oops. Not allocated yet. Back out, allocate it, and retry.
#ifndef PRODUCT
if (WizardMode) {
}
#endif
{
}
// Now retry from the beginning
// Create a handle because the enclosing brace, when locking
// can cause a gc. Better to have this function return a Handle.
} // re-lock
return ek();
}
} else {
// The element type is already Object. Object[] has direct super of Object.
}
}
// Create type name for klass (except for symbol arrays, since symbolKlass
// does not have a name). This will potentially allocate an object, cause
// GC, and all other kinds of things. Hence, this must be done before we
// get a handle to the new objArrayKlass we want to construct. We cannot
// block while holding a handling to a partly initialized object.
if (!element_klass->oop_is_symbol()) {
int idx = 0;
}
if (element_klass->oop_is_instance()) {
}
}
CHECK_0);
// Initialize instance variables
oak->set_dimension(n);
if (element_klass->oop_is_objArray()) {
} else {
bk = element_klass();
}
assert(bk != NULL && (Klass::cast(bk)->oop_is_instance() || Klass::cast(bk)->oop_is_typeArray()), "invalid bottom klass");
// Call complete_create_array_klass after all instance variables has been initialized.
return k();
}
}
#ifndef SERIALGC
}
#endif // SERIALGC
}
}
int
}
#ifndef SERIALGC
}
}
}
oop* p;
p = oak->element_klass_addr();
p = oak->bottom_klass_addr();
}
#endif // SERIALGC
#ifndef PRODUCT
// Printing
}
}
#endif
const char* objArrayKlassKlass::internal_name() const {
return "{object array class}";
}
// Verification
}