private static long headerSize(BasicType type) {
if (Universe.elementTypeShouldBeAligned(type)) {
return alignObjectSize(headerSizeInBytes()) / VM.getVM().getHeapWordSize();
} else {
return headerSizeInBytes() / VM.getVM().getHeapWordSize();
}
}
private void initOtherId() {
VM vm = getOtherVm();
vm.invoke(
new CacheSerializableRunnable("Connect") {
public void run2() throws CacheException {
getCache();
}
});
this.otherId = (DistributedMember) vm.invoke(ProxyDUnitTest.class, "getVMDistributedMember");
}
private long lengthOffsetInBytes() {
if (lengthOffsetInBytes != 0) {
return lengthOffsetInBytes;
}
if (VM.getVM().isCompressedOopsEnabled()) {
lengthOffsetInBytes = typeSize - VM.getVM().getIntSize();
} else {
lengthOffsetInBytes = typeSize;
}
return lengthOffsetInBytes;
}
private void doCreateOtherVm() {
VM vm = getOtherVm();
vm.invoke(
new CacheSerializableRunnable("create root") {
public void run2() throws CacheException {
AttributesFactory af = new AttributesFactory();
af.setDataPolicy(DataPolicy.REPLICATE);
af.setScope(Scope.DISTRIBUTED_ACK);
createRootRegion("ProxyDUnitTest", af.create());
}
});
}
private static long headerSizeInBytes() {
if (headerSize != 0) {
return headerSize;
}
if (VM.getVM().isCompressedOopsEnabled()) {
headerSize = typeSize;
} else {
headerSize =
VM.getVM().alignUp(typeSize + VM.getVM().getIntSize(), VM.getVM().getHeapWordSize());
}
return headerSize;
}
/** Only returns addresses of valid OopHandles */
private Address getOopHandleAddress(int x) {
if (Assert.ASSERTS_ENABLED) {
Assert.that(x < top(), "out of bounds");
}
Address oopAddr = addr.addOffsetTo(handlesField.getOffset() + x * VM.getVM().getOopSize());
OopHandle handle = oopAddr.getOopHandleAt(0);
if (VM.getVM().getUniverse().isInReserved(handle)
&& !VM.getVM().getJNIHandles().isDeletedHandle(handle)) {
/* the oop handle is valid only if it is not freed (i.e. reserved in heap) and is not a deleted oop */
return oopAddr;
} else {
return null;
}
}
public static CGGradient create(CGColorSpace space, float[] components, float[] locations) {
if (space == null) {
throw new NullPointerException("space");
}
if (components == null) {
throw new NullPointerException("components");
}
return create(
space,
VM.getArrayValuesAddress(CoreGraphics.toMachineSizedFloatArray(components)),
locations != null
? VM.getArrayValuesAddress(CoreGraphics.toMachineSizedFloatArray(locations))
: 0,
locations != null ? locations.length : 0);
}
// "size helper" == instance size in words
public long getSizeHelper() {
int lh = getLayoutHelper();
if (Assert.ASSERTS_ENABLED) {
Assert.that(lh > 0, "layout helper initialized for instance class");
}
return lh / VM.getVM().getAddressSize();
}
private static void initialize(TypeDataBase db) {
if (VM.getVM().isServerCompiler()) {
Type type = db.lookupType("Matcher");
Field f = type.getField("_regEncode");
matcherRegEncodeAddr = f.getStaticFieldAddress();
}
}
public void replaceRegion(
@ByVal MTLRegion region,
@MachineSizedUInt long level,
byte[] pixelBytes,
@MachineSizedUInt long bytesPerRow) {
replaceRegion(region, level, VM.getArrayValuesAddress(pixelBytes), bytesPerRow);
}
/**
* Logic to select the appropriate guarding mechanism for the edge from caller to callee according
* to the controlling {@link OPT_Options}. If we are using IG_CODE_PATCH, then this method also
* records the required dependency. Precondition: lock on {@link VM_Class#OptCLDepManager} is
* held.
*
* @param caller The caller method
* @param callee The callee method
* @param codePatchSupported Can we use code patching at this call site?
*/
private byte chooseGuard(
VM_Method caller,
VM_Method singleImpl,
VM_Method callee,
OPT_CompilationState state,
boolean codePatchSupported) {
byte guard = state.getOptions().INLINING_GUARD;
if (codePatchSupported) {
if (VM.VerifyAssertions && VM.runningVM) {
VM._assert(VM_Lock.owns(VM_Class.OptCLDepManager));
}
if (guard == OPT_Options.IG_CODE_PATCH) {
if (OPT_ClassLoadingDependencyManager.TRACE || OPT_ClassLoadingDependencyManager.DEBUG) {
VM_Class.OptCLDepManager.report(
"CODE PATCH: Inlined " + singleImpl + " into " + caller + "\n");
}
VM_Class.OptCLDepManager.addNotOverriddenDependency(callee, state.getCompiledMethod());
}
} else if (guard == OPT_Options.IG_CODE_PATCH) {
guard = OPT_Options.IG_METHOD_TEST;
}
if (guard == OPT_Options.IG_METHOD_TEST && singleImpl.getDeclaringClass().isFinal()) {
// class test is more efficient and just as effective
guard = OPT_Options.IG_CLASS_TEST;
}
return guard;
}
public int getFieldOrMethodAt(int which) {
if (DEBUG) {
System.err.print("ConstantPool.getFieldOrMethodAt(" + which + "): new index = ");
}
int i = -1;
ConstantPoolCache cache = getCache();
if (cache == null) {
i = which;
} else {
// change byte-ordering and go via cache
i =
cache
.getEntryAt(0xFFFF & VM.getVM().getBytes().swapShort((short) which))
.getConstantPoolIndex();
}
if (Assert.ASSERTS_ENABLED) {
Assert.that(getTagAt(i).isFieldOrMethod(), "Corrupted constant pool");
}
if (DEBUG) {
System.err.println(i);
}
int res = getIntAt(i);
if (DEBUG) {
System.err.println("ConstantPool.getFieldOrMethodAt(" + i + "): result = " + res);
}
return res;
}
private static void initialize(TypeDataBase db) {
if (Assert.ASSERTS_ENABLED) {
Assert.that(!VM.getVM().isCore(), "Debug info not used in core build");
}
OFFSET_MASK = db.lookupIntConstant("Location::OFFSET_MASK").intValue();
OFFSET_SHIFT = db.lookupIntConstant("Location::OFFSET_SHIFT").intValue();
TYPE_MASK = db.lookupIntConstant("Location::TYPE_MASK").intValue();
TYPE_SHIFT = db.lookupIntConstant("Location::TYPE_SHIFT").intValue();
WHERE_MASK = db.lookupIntConstant("Location::WHERE_MASK").intValue();
WHERE_SHIFT = db.lookupIntConstant("Location::WHERE_SHIFT").intValue();
// Location::Type constants
TYPE_NORMAL = db.lookupIntConstant("Location::normal").intValue();
TYPE_OOP = db.lookupIntConstant("Location::oop").intValue();
TYPE_NARROWOOP = db.lookupIntConstant("Location::narrowoop").intValue();
TYPE_INT_IN_LONG = db.lookupIntConstant("Location::int_in_long").intValue();
TYPE_LNG = db.lookupIntConstant("Location::lng").intValue();
TYPE_FLOAT_IN_DBL = db.lookupIntConstant("Location::float_in_dbl").intValue();
TYPE_DBL = db.lookupIntConstant("Location::dbl").intValue();
TYPE_ADDR = db.lookupIntConstant("Location::addr").intValue();
TYPE_INVALID = db.lookupIntConstant("Location::invalid").intValue();
// Location::Where constants
WHERE_ON_STACK = db.lookupIntConstant("Location::on_stack").intValue();
WHERE_IN_REGISTER = db.lookupIntConstant("Location::in_register").intValue();
}
public long getLongAt(long index) {
int oneHalf = getHandle().getJIntAt(indexOffset(index + 1));
int otherHalf = getHandle().getJIntAt(indexOffset(index));
// buildLongFromIntsPD accepts higher address value, lower address value
// in that order.
return VM.getVM().buildLongFromIntsPD(oneHalf, otherHalf);
}
public void forEachObject(Object[] args) {
boolean subtypes = true;
Klass kls = null;
Callable func = null;
switch (args.length) {
case 3:
{
Object b = args[2];
if (b != null && b instanceof Boolean) {
subtypes = ((Boolean) b).booleanValue();
}
}
case 2:
{
Object k = args[1];
if (k == null) return;
if (k instanceof JSJavaKlass) {
kls = ((JSJavaKlass) k).getKlass();
} else if (k instanceof String) {
kls = SystemDictionaryHelper.findInstanceKlass((String) k);
if (kls == null) return;
}
}
case 1:
{
Object f = args[0];
if (f != null && f instanceof Callable) {
func = (Callable) f;
} else {
// unknown target - just return
return;
}
}
break;
default:
return;
}
final Callable finalFunc = func;
HeapVisitor visitor =
new DefaultHeapVisitor() {
public boolean doObj(Oop oop) {
JSJavaObject jo = factory.newJSJavaObject(oop);
if (jo != null) {
try {
finalFunc.call(new Object[] {jo});
} catch (ScriptException exp) {
throw new RuntimeException(exp);
}
}
return false;
}
};
ObjectHeap heap = VM.getVM().getObjectHeap();
if (kls == null) {
kls = SystemDictionaryHelper.findInstanceKlass("java.lang.Object");
}
heap.iterateObjectsOfKlass(visitor, kls, subtypes);
}
/*</constructors>*/
public NSOutputStream(byte[] bytes) {
super((SkipInit) null);
if (bytes == null) {
throw new NullPointerException("bytes");
}
initObject(init(VM.getArrayValuesAddress(bytes), bytes.length));
}
public long write(byte[] bytes, int offset, int length) {
NSMutableData.checkOffsetAndCount(bytes.length, offset, length);
if (length == 0) {
return 0;
}
return write(VM.getArrayValuesAddress(bytes) + offset, length);
}
private long getElementSize() {
if (elementSize != 0) {
return elementSize;
} else {
elementSize = VM.getVM().getOopSize();
}
return elementSize;
}
static {
VM.registerVMInitializedObserver(
new Observer() {
public void update(Observable o, Object data) {
initialize(VM.getVM().getTypeDataBase());
}
});
}
public byte[] getBytes(
int length,
@MachineSizedUInt long bytesPerRow,
@ByVal MTLRegion region,
@MachineSizedUInt long level) {
byte[] bytes = new byte[length];
getBytes(VM.getArrayValuesAddress(bytes), bytesPerRow, region, level);
return bytes;
}
/** Convenience routine taking Strings; lookup is done in SymbolTable. */
public Method findMethod(String name, String sig) {
SymbolTable syms = VM.getVM().getSymbolTable();
Symbol nameSym = syms.probe(name);
Symbol sigSym = syms.probe(sig);
if (nameSym == null || sigSym == null) {
return null;
}
return findMethod(nameSym, sigSym);
}
/**
* @param offset
* @param length
* @return
* @throws NSErrorException
*/
public byte[] getBytes(int offset, int length) throws NSErrorException {
byte[] bytes = new byte[length];
NSError.NSErrorPtr err = new NSError.NSErrorPtr();
getBytes(VM.getArrayValuesAddress(bytes), offset, length, err);
if (err.get() != null) {
throw new NSErrorException(err.get());
}
return bytes;
}
private static void initialize(TypeDataBase db) {
Type type = db.lookupType("oopDesc");
if (VM.getVM().isCompressedOopsEnabled()) {
klassField = type.getNarrowOopField("_metadata._compressed_klass");
} else {
klassField = type.getOopField("_metadata._klass");
}
}
public ThreadProxy getThreadProxy(Address addr) {
// Addr is the address of the JavaThread.
// Fetch the OSThread (for now and for simplicity, not making a
// separate "OSThread" class in this package)
Address osThreadAddr = osThreadField.getValue(addr);
// Get the address of the _thread_id from the OSThread
Address threadIdAddr = osThreadAddr.addOffsetTo(osThreadThreadIDField.getOffset());
JVMDebugger debugger = VM.getVM().getDebugger();
return debugger.getThreadForIdentifierAddress(threadIdAddr);
}
private static CGGradient create(CGColorSpace space, CGColor[] colors, Object locations) {
if (colors == null) {
throw new NullPointerException("colors");
}
try (CFArray colorsArray = CFArray.create(colors)) {
return create(
space,
colorsArray,
locations != null
? VM.getArrayValuesAddress(CoreGraphics.toMachineSizedFloatArray(locations))
: 0);
}
}
/**
* Compute node congruence over the value number graph.
*
* <p>Algorithm: Muchnick pp. 348-355
*
* <p>Note: the Muchnick algorithm is buggy. In particular, it does not put all needed congruence
* classes on the worklist.
*
* <p>Two nodes in the value graph are congruent if one of the following holds:
*
* <ul>
* <li>they are the same node
* <li>their labels are identical constants
* <li>they have the same operators and their operands are congruent
* </ul>
*
* <p>Optimistic algorithm:
*
* <ul>
* <li>Initially assume all nodes with the same label are congruent
* <li>start a work list with all congruence classes that have multiple operands
* <li>choose a congruence class from the worklist. partition its elements into new congruence
* classes if we can discover that they are not congruent.
* <li>Add any newly created congruence classes to the work list.
* <li>(Here's the step Muchnick omits:) For each class C which has a dependence on any of the
* newly created congruence classes, add C to the work list
* <li>repeat until work list is empty
* </ul>
*
* <p>The following method breaks Muchnick's algorithm, which will assign m and n the same value
* number. Muchnick's problem is that it does not put the congruence class for 'int_mul' back on
* the worklist when we discover, for example, that i is not congruent to k
*
* <pre>
* public int foo(int a, int b, int c, int d, int e, int f, int g, int h) {
* int i = a+b;
* int j = c+d;
* int k = e+f;
* int l = g+h;
* int m = i * j;
* int n = k * l;
* int o = m/n;
* return o;
* }
* </pre>
*/
public void globalValueNumber() {
valueGraph = new OPT_ValueGraph(ir);
if (DEBUG) VM.sysWrite(valueGraph.toString());
// initialize the congurence classes
initialize();
// initialize the work list
initializeWorkList();
// drain the work list
while (!workList.empty()) {
OPT_GVCongruenceClass partition = (OPT_GVCongruenceClass) workList.pop();
partitionClass(partition);
}
// all done
if (DEBUG) printValueNumbers();
}
private static CGGradient create(CGColorSpace space, CGColor[] colors, Object locations) {
if (colors == null) {
throw new NullPointerException("colors");
}
try (CFMutableArray colorsArray =
CFMutableArray.createMutable(null, colors.length, CoreFoundation.TypeArrayCallBacks())) {
for (CGColor c : colors) {
colorsArray.appendValue(Struct.toStruct(VoidPtr.class, c.getHandle()));
}
return create(
space,
colorsArray,
locations != null
? VM.getArrayValuesAddress(CoreGraphics.toMachineSizedFloatArray(locations))
: 0);
}
}
private void iterateOops(
final InstanceKlass ik, final ObjectVisitor visitor, boolean includeSubtypes) {
ObjectHeap oh = VM.getVM().getObjectHeap();
oh.iterateObjectsOfKlass(
new HeapVisitor() {
boolean filterExists;
public void prologue(long usedSize) {
filterExists = getScriptEngine().get("filter") != null;
}
public boolean doObj(Oop obj) {
dispatchObject(obj, visitor, filterExists);
return false;
}
public void epilogue() {}
},
ik,
includeSubtypes);
}
public static boolean oopLooksValid(OopHandle oop) {
if (oop == null) {
return false;
}
if (!VM.getVM().getUniverse().isIn(oop)) {
return false;
}
try {
for (int i = 0; i < 4; ++i) {
OopHandle next = klassField.getValue(oop);
if (next == null) {
return false;
}
if (next.equals(oop)) {
return true;
}
oop = next;
}
return false;
} catch (AddressException e) {
return false;
}
}
// Creates new field from index in fields TypeArray
private Field newField(int index) {
TypeArray fields = getFields();
short signatureIndex = fields.getShortAt(index + SIGNATURE_INDEX_OFFSET);
FieldType type = new FieldType((Symbol) getConstants().getObjAt(signatureIndex));
if (type.isOop()) {
if (VM.getVM().isCompressedOopsEnabled()) {
return new NarrowOopField(this, index);
} else {
return new OopField(this, index);
}
}
if (type.isByte()) {
return new ByteField(this, index);
}
if (type.isChar()) {
return new CharField(this, index);
}
if (type.isDouble()) {
return new DoubleField(this, index);
}
if (type.isFloat()) {
return new FloatField(this, index);
}
if (type.isInt()) {
return new IntField(this, index);
}
if (type.isLong()) {
return new LongField(this, index);
}
if (type.isShort()) {
return new ShortField(this, index);
}
if (type.isBoolean()) {
return new BooleanField(this, index);
}
throw new RuntimeException("Illegal field type at index " + index);
}
