archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-28 07:14:30 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8001107: @Stable annotation for constant folding of lazily evaluated variables

Browse source 
Co-authored-by: John Rose <john.r.rose@oracle.com>
Reviewed-by: rbackman, twisti, kvn
This commit is contained in:
Vladimir Ivanov 2013-09-10 14:51:48 -07:00
parent 19d50345e1
commit f0e77ac67f
25 changed files with 419 additions and 84 deletions
Download patch file Download diff file Expand all files Collapse all files

79
hotspot/src/share/vm/ci/ciArray.cpp
View file

@ -24,13 +24,92 @@
#include "precompiled.hpp"
#include "ci/ciArray.hpp"
#include "ci/ciArrayKlass.hpp"
#include "ci/ciConstant.hpp"
#include "ci/ciKlass.hpp"
#include "ci/ciUtilities.hpp"
#include "oops/objArrayOop.hpp"
#include "oops/typeArrayOop.hpp"
// ciArray
//
// This class represents an arrayOop in the HotSpot virtual
// machine.
static BasicType fixup_element_type(BasicType bt) {
if (bt == T_ARRAY) return T_OBJECT;
if (bt == T_BOOLEAN) return T_BYTE;
return bt;
}
ciConstant ciArray::element_value_impl(BasicType elembt,
arrayOop ary,
int index) {
if (ary == NULL)
return ciConstant();
assert(ary->is_array(), "");
if (index < 0 || index >= ary->length())
return ciConstant();
ArrayKlass* ak = (ArrayKlass*) ary->klass();
BasicType abt = ak->element_type();
if (fixup_element_type(elembt) !=
fixup_element_type(abt))
return ciConstant();
switch (elembt) {
case T_ARRAY:
case T_OBJECT:
{
assert(ary->is_objArray(), "");
objArrayOop objary = (objArrayOop) ary;
oop elem = objary->obj_at(index);
ciEnv* env = CURRENT_ENV;
ciObject* box = env->get_object(elem);
return ciConstant(T_OBJECT, box);
}
}
assert(ary->is_typeArray(), "");
typeArrayOop tary = (typeArrayOop) ary;
jint value = 0;
switch (elembt) {
case T_LONG: return ciConstant(tary->long_at(index));
case T_FLOAT: return ciConstant(tary->float_at(index));
case T_DOUBLE: return ciConstant(tary->double_at(index));
default: return ciConstant();
case T_BYTE: value = tary->byte_at(index); break;
case T_BOOLEAN: value = tary->byte_at(index) & 1; break;
case T_SHORT: value = tary->short_at(index); break;
case T_CHAR: value = tary->char_at(index); break;
case T_INT: value = tary->int_at(index); break;
}
return ciConstant(elembt, value);
}
// ------------------------------------------------------------------
// ciArray::element_value
//
// Current value of an element.
// Returns T_ILLEGAL if there is no element at the given index.
ciConstant ciArray::element_value(int index) {
BasicType elembt = element_basic_type();
GUARDED_VM_ENTRY(
return element_value_impl(elembt, get_arrayOop(), index);
)
}
// ------------------------------------------------------------------
// ciArray::element_value_by_offset
//
// Current value of an element at the specified offset.
// Returns T_ILLEGAL if there is no element at the given offset.
ciConstant ciArray::element_value_by_offset(intptr_t element_offset) {
BasicType elembt = element_basic_type();
intptr_t shift = exact_log2(type2aelembytes(elembt));
intptr_t header = arrayOopDesc::base_offset_in_bytes(elembt);
intptr_t index = (element_offset - header) >> shift;
intptr_t offset = header + ((intptr_t)index << shift);
if (offset != element_offset || index != (jint)index)
return ciConstant();
return element_value((jint) index);
}
// ------------------------------------------------------------------
// ciArray::print_impl