com.oracle.truffle.api.profiles.ConditionProfile Java Examples

@Specialization
protected final PointersObject doCursor(final PointersObject receiver, final PointersObject maskObject,
                @CachedContext(SqueakLanguage.class) final SqueakImageContext image,
                @Cached("createBinaryProfile()") final ConditionProfile depthProfile) {
    if (image.hasDisplay()) {
        final int[] words = receiver.getFormBits(cursorReadNode);
        final int depth = receiver.getFormDepth(cursorReadNode);
        final int height = receiver.getFormHeight(cursorReadNode);
        final int width = receiver.getFormWidth(cursorReadNode);
        final PointersObject offset = receiver.getFormOffset(cursorReadNode);
        final int offsetX = Math.abs(offsetReadNode.executeInt(offset, POINT.X));
        final int offsetY = Math.abs(offsetReadNode.executeInt(offset, POINT.Y));
        if (depthProfile.profile(depth == 1)) {
            final int[] mask = cursorReadNode.executeNative(maskObject, FORM.BITS).getIntStorage();
            image.getDisplay().setCursor(words, mask, width, height, 2, offsetX, offsetY);
        } else {
            image.getDisplay().setCursor(words, null, width, height, depth, offsetX, offsetY);
        }
    }
    return receiver;
}
 

@Specialization(guards = {"!isCompiledMethodObject(targetObject)"})
protected static final Object doObjectAsMethod(final VirtualFrame frame, final NativeObject selector, final Object targetObject, final Object receiver,
                @SuppressWarnings("unused") final ClassObject rcvrClass,
                @Cached final SqueakObjectClassNode classNode,
                @Shared("writeNode") @Cached final AbstractPointersObjectWriteNode writeNode,
                @Cached final LookupMethodNode lookupNode,
                @Cached("create(argumentCount)") final FrameStackPopNNode popArguments,
                @Cached final FrameStackPopNode popReceiver,
                @Cached("createBinaryProfile()") final ConditionProfile isDoesNotUnderstandProfile,
                @Cached("create()") final DispatchEagerlyNode dispatchNode,
                @CachedContext(SqueakLanguage.class) final SqueakImageContext image) {
    final Object[] arguments = popArguments.execute(frame);
    final Object poppedReceiver = popReceiver.execute(frame);
    assert receiver == poppedReceiver;
    final ClassObject targetClass = classNode.executeLookup(targetObject);
    final Object newLookupResult = lookupNode.executeLookup(targetClass, image.runWithInSelector);
    if (isDoesNotUnderstandProfile.profile(newLookupResult == null)) {
        final Object doesNotUnderstandMethod = lookupNode.executeLookup(targetClass, image.doesNotUnderstand);
        return dispatchNode.executeDispatch(frame, (CompiledMethodObject) doesNotUnderstandMethod,
                        new Object[]{targetObject, image.newMessage(writeNode, selector, targetClass, arguments)});
    } else {
        return dispatchNode.executeDispatch(frame, (CompiledMethodObject) newLookupResult, new Object[]{targetObject, selector, image.asArrayOfObjects(arguments), receiver});
    }
}
 

@Specialization(guards = {"image.lastSeenContext != null"})
protected static final void doMaterialize(final VirtualFrame frame,
                @Cached("createBinaryProfile()") final ConditionProfile isNotLastSeenContextProfile,
                @Cached("createBinaryProfile()") final ConditionProfile continueProfile,
                @Cached("create(true)") final GetOrCreateContextNode getOrCreateContextNode,
                @CachedContext(SqueakLanguage.class) final SqueakImageContext image) {
    final ContextObject lastSeenContext = image.lastSeenContext;
    final ContextObject context = getOrCreateContextNode.executeGet(frame);
    if (isNotLastSeenContextProfile.profile(context != lastSeenContext)) {
        assert context.hasTruffleFrame();
        if (lastSeenContext != null && !lastSeenContext.hasMaterializedSender()) {
            lastSeenContext.setSender(context);
        }
        if (continueProfile.profile(!context.isTerminated() && context.hasEscaped())) {
            // Materialization needs to continue in parent frame.
            image.lastSeenContext = context;
        } else {
            // If context has not escaped, materialization can terminate here.
            image.lastSeenContext = null;
        }
    }
}
 

@Specialization(guards = {"!isCompiledMethodObject(targetObject)"})
protected final Object doObjectAsMethod(final VirtualFrame frame, final NativeObject selector, final Object targetObject, @SuppressWarnings("unused") final ClassObject rcvrClass,
                final Object[] rcvrAndArgs,
                @Cached final SqueakObjectClassNode classNode,
                @Shared("writeNode") @Cached final AbstractPointersObjectWriteNode writeNode,
                @Cached final LookupMethodNode lookupNode,
                @Cached("createBinaryProfile()") final ConditionProfile isDoesNotUnderstandProfile,
                @CachedContext(SqueakLanguage.class) final SqueakImageContext image) {
    final Object[] arguments = ArrayUtils.allButFirst(rcvrAndArgs);
    final ClassObject targetClass = classNode.executeLookup(targetObject);
    final Object newLookupResult = lookupNode.executeLookup(targetClass, image.runWithInSelector);
    if (isDoesNotUnderstandProfile.profile(newLookupResult == null)) {
        final Object doesNotUnderstandMethod = lookupNode.executeLookup(targetClass, image.doesNotUnderstand);
        return dispatchNode.executeDispatch(frame, (CompiledMethodObject) doesNotUnderstandMethod,
                        new Object[]{targetObject, image.newMessage(writeNode, selector, targetClass, arguments)});
    } else {
        return dispatchNode.executeDispatch(frame, (CompiledMethodObject) newLookupResult, new Object[]{targetObject, selector, image.asArrayOfObjects(arguments), rcvrAndArgs[0]});
    }
}
 

@SuppressWarnings("unused")
@Specialization
protected static final PointersObject doWork(final PointersObject receiver,
                final long netType,
                final long socketType,
                final long rcvBufSize,
                final long semaphoreIndex,
                final long aReadSemaphore,
                final long aWriteSemaphore,
                @Cached("createBinaryProfile()") final ConditionProfile socketTypeProfile,
                @CachedContext(SqueakLanguage.class) final SqueakImageContext image) {

    final SqueakSocket socket;
    try {
        if (socketTypeProfile.profile(socketType == 1)) {
            socket = new SqueakUDPSocket();
        } else {
            assert socketType == 0;
            socket = new SqueakTCPSocket();
        }
    } catch (final IOException e) {
        throw PrimitiveFailed.andTransferToInterpreter();
    }
    return PointersObject.newHandleWithHiddenObject(image, socket);
}
 

@TruffleBoundary
public boolean pointsTo(final Object thang) {
    // TODO: make sure this works correctly
    if (truffleFrame != null) {
        if (getSender() == thang || thang.equals(getInstructionPointer(ConditionProfile.getUncached())) || thang.equals(getStackPointer()) || getMethod() == thang || getClosure() == thang ||
                        getReceiver() == thang) {
            return true;
        }
        for (int i = 0; i < getBlockOrMethod().getNumStackSlots(); i++) {
            if (atTemp(i) == thang) {
                return true;
            }
        }
    }
    return false;
}
 

@Specialization
protected static final long doFind(@SuppressWarnings("unused") final Object receiver, final NativeObject string, final NativeObject inclusionMap, final long start,
                @Cached("createBinaryProfile()") final ConditionProfile notFoundProfile) {
    if (start < 1 || !string.isByteType() || !inclusionMap.isByteType()) {
        CompilerDirectives.transferToInterpreter();
        throw PrimitiveFailed.BAD_ARGUMENT;
    }
    if (inclusionMap.getByteLength() != 256) {
        CompilerDirectives.transferToInterpreter();
        return 0L;
    }
    final int stringSize = string.getByteLength();
    long index = start - 1;
    while (index < stringSize && inclusionMap.getByte(string.getByteUnsigned(index)) == 0) {
        index++;
    }
    return notFoundProfile.profile(index >= stringSize) ? 0L : index + 1;
}
 

@ExportMessage
public Object readMember(final String member,
                @Shared("lookupNode") @Cached final LookupMethodByStringNode lookupNode,
                @Shared("classNode") @Cached final SqueakObjectClassNode classNode,
                @Exclusive @Cached("createBinaryProfile()") final ConditionProfile alternativeProfile) throws UnknownIdentifierException {
    final ClassObject classObject = classNode.executeLookup(this);
    final String selectorString = toSelector(member);
    final Object methodObject = lookupNode.executeLookup(classObject, selectorString);
    if (alternativeProfile.profile(methodObject instanceof CompiledMethodObject)) {
        return new BoundMethod((CompiledMethodObject) methodObject, this);
    } else {
        final Object methodObjectAlternative = lookupNode.executeLookup(classObject, toAlternativeSelector(selectorString));
        if (methodObjectAlternative instanceof CompiledMethodObject) {
            return new BoundMethod((CompiledMethodObject) methodObjectAlternative, this);
        } else {
            throw UnknownIdentifierException.create(member);
        }
    }
}
 

@Specialization(guards = {"obj.isLongType()", "isLongNilTag(value)"})
protected static final void doArrayOfLongsNilTagClash(final ArrayObject obj, final long index, final long value,
                @Cached("createBinaryProfile()") final ConditionProfile isNilTagProfile) {
    /** `value` happens to be long nil tag, need to despecialize to be able store it. */
    obj.transitionFromLongsToObjects(isNilTagProfile);
    doArrayOfObjects(obj, index, value);
}
 

/**
 * Return the host address found by the last host name lookup. Returns nil if the last
 * lookup was unsuccessful.
 */
@Specialization
protected static final AbstractSqueakObject doWork(@SuppressWarnings("unused") final Object receiver,
                @Cached("createBinaryProfile()") final ConditionProfile hasResultProfile,
                @CachedContext(SqueakLanguage.class) final SqueakImageContext image) {
    final byte[] lastNameLookup = Resolver.lastHostNameLookupResult();
    LogUtils.SOCKET.finer(() -> "Name Lookup Result: " + Resolver.addressBytesToString(lastNameLookup));
    return hasResultProfile.profile(lastNameLookup == null) ? NilObject.SINGLETON : image.asByteArray(lastNameLookup);
}
 

@Specialization(guards = {"obj.isDoubleType()", "isDoubleNilTag(value)"})
protected static final void doArrayOfDoublesNilTagClash(final ArrayObject obj, final long index, final double value,
                @Cached("createBinaryProfile()") final ConditionProfile isNilTagProfile) {
    // `value` happens to be double nil tag, need to despecialize to be able store it.
    obj.transitionFromDoublesToObjects(isNilTagProfile);
    doArrayOfObjects(obj, index, value);
}
 

@Specialization
protected static final Object doLargeInteger(final LargeIntegerObject receiver, final long arg,
                @Cached("createBinaryProfile()") final ConditionProfile positiveProfile) {
    if (positiveProfile.profile(arg >= 0)) {
        return receiver.longValue() & arg;
    } else {
        return receiver.and(arg);
    }
}
 

@SuppressWarnings("unused")
@Specialization(guards = {"index >= TEMP_FRAME_START", "context == cachedContext", "index == cachedIndex"}, limit = "4")
protected static final Object doTempCached(final ContextObject context, final long index,
                @Cached("context") final ContextObject cachedContext,
                @Cached("index") final long cachedIndex,
                @Cached("createReadNode(cachedContext, cachedIndex)") final FrameSlotReadNode readNode,
                @Cached("createBinaryProfile()") final ConditionProfile isNullProfile) {
    return NilObject.nullToNil(readNode.executeReadUnsafe(cachedContext.getTruffleFrame()), isNullProfile);
}
 

@Specialization(replaces = "doLong")
protected static final Object doLongWithOverflow(final long lhs, final long rhs,
                @Cached("createBinaryProfile()") final ConditionProfile differentSignProfile,
                @CachedContext(SqueakLanguage.class) final SqueakImageContext image) {
    if (differentSignProfile.profile(differentSign(lhs, rhs))) {
        return LargeIntegerObject.subtract(image, lhs, rhs);
    } else {
        return LargeIntegerObject.add(image, lhs, rhs);
    }
}
 

@Specialization
protected static final Object doLongLargeInteger(final long lhs, final LargeIntegerObject rhs,
                @Cached("createBinaryProfile()") final ConditionProfile differentSignProfile) {
    if (differentSignProfile.profile(rhs.differentSign(lhs))) {
        return rhs.add(lhs);
    } else {
        return LargeIntegerObject.subtract(lhs, rhs);
    }
}
 

@Specialization
protected static final Object doLargeInteger(final LargeIntegerObject lhs, final LargeIntegerObject rhs,
                @Cached("createBinaryProfile()") final ConditionProfile sameSignProfile) {
    if (sameSignProfile.profile(lhs.sameSign(rhs))) {
        return lhs.subtract(rhs);
    } else {
        return lhs.add(rhs);
    }
}
 

@Specialization(rewriteOn = ArithmeticException.class)
protected static final long doLong(final long lhs, final long rhs,
                @Cached("createBinaryProfile()") final ConditionProfile differentSignProfile) {
    if (differentSignProfile.profile(differentSign(lhs, rhs))) {
        return Math.subtractExact(lhs, rhs);
    } else {
        return Math.addExact(lhs, rhs);
    }
}
 

@Specialization(replaces = "doLong")
protected static final Object doLongWithOverflow(final long lhs, final long rhs,
                @Cached("createBinaryProfile()") final ConditionProfile differentSignProfile,
                @CachedContext(SqueakLanguage.class) final SqueakImageContext image) {
    if (differentSignProfile.profile(differentSign(lhs, rhs))) {
        return LargeIntegerObject.add(image, lhs, rhs);
    } else {
        return LargeIntegerObject.subtract(image, lhs, rhs);
    }
}
 

@Specialization
protected static final Object doLargeIntegerLong(final LargeIntegerObject lhs, final long rhs,
                @Cached("createBinaryProfile()") final ConditionProfile differentSignProfile) {
    if (differentSignProfile.profile(lhs.differentSign(rhs))) {
        return lhs.subtract(rhs);
    } else {
        return lhs.add(rhs);
    }
}
 

@Specialization(guards = {"obj.isCharType()", "isCharNilTag(value)"})
protected static final void doArrayOfCharsNilTagClash(final ArrayObject obj, final long index, final char value,
                @Cached("createBinaryProfile()") final ConditionProfile isNilTagProfile) {
    /** `value` happens to be char nil tag, need to despecialize to be able store it. */
    obj.transitionFromCharsToObjects(isNilTagProfile);
    doArrayOfObjects(obj, index, value);
}
 

@Specialization(guards = "obj.isDoubleType()")
protected final void doArrayOfDoubles(final Object[] target, final ArrayObject obj,
                @Cached("createBinaryProfile()") final ConditionProfile isNilTagProfile) {
    final double[] doubles = obj.getDoubleStorage();
    for (int i = 0; i < doubles.length; i++) {
        target[offset + i] = ArrayObject.toObjectFromDouble(doubles[i], isNilTagProfile);
    }
}
 

@Specialization(guards = "obj.isLongType()")
protected final void doArrayOfLongs(final Object[] target, final ArrayObject obj,
                @Cached("createBinaryProfile()") final ConditionProfile isNilTagProfile) {
    final long[] longs = obj.getLongStorage();
    for (int i = 0; i < longs.length; i++) {
        target[offset + i] = ArrayObject.toObjectFromLong(longs[i], isNilTagProfile);
    }
}
 

@Specialization(guards = "obj.isCharType()")
protected final void doArrayOfChars(final Object[] target, final ArrayObject obj,
                @Cached("createBinaryProfile()") final ConditionProfile isNilTagProfile) {
    final char[] chars = obj.getCharStorage();
    for (int i = 0; i < chars.length; i++) {
        target[offset + i] = ArrayObject.toObjectFromChar(chars[i], isNilTagProfile);
    }
}
 

@Specialization(guards = "obj.isDoubleType()")
protected static final Object[] doArrayOfDoubles(final Object first, final ArrayObject obj,
                @Cached("createBinaryProfile()") final ConditionProfile isNilTagProfile) {
    final double[] doubles = obj.getDoubleStorage();
    final int length = doubles.length;
    final Object[] objects = new Object[1 + length];
    objects[0] = first;
    for (int i = 0; i < length; i++) {
        objects[1 + i] = ArrayObject.toObjectFromDouble(doubles[i], isNilTagProfile);
    }
    return objects;
}
 

@SuppressWarnings("unused")
@Specialization(guards = {"byteArray.isByteType()", "byteOffsetLong > 0", "byteSize == 8", "!isSigned"})
protected static final Object doAt8Unsigned(final NativeObject byteArray, final long byteOffsetLong, final long byteSize, final boolean isSigned,
                @Cached("createBinaryProfile()") final ConditionProfile positiveProfile,
                @CachedContext(SqueakLanguage.class) final SqueakImageContext image) {
    final long signedLong = doAt8Signed(byteArray, byteOffsetLong, byteSize, isSigned);
    if (positiveProfile.profile(signedLong >= 0)) {
        return signedLong;
    } else {
        return LargeIntegerObject.toUnsigned(image, signedLong);
    }
}
 

@Specialization(guards = "obj.isCharType()")
protected static final Object[] doArrayOfChars(final Object first, final ArrayObject obj,
                @Cached("createBinaryProfile()") final ConditionProfile isNilTagProfile) {
    final char[] chars = obj.getCharStorage();
    final int length = chars.length;
    final Object[] objects = new Object[1 + length];
    objects[0] = first;
    for (int i = 0; i < length; i++) {
        final char value = chars[i];
        objects[1 + i] = ArrayObject.toObjectFromChar(value, isNilTagProfile);
    }
    return objects;
}
 

@Specialization(guards = "obj.isDoubleType()")
protected static final Object[] doArrayOfDoubles(final ArrayObject obj,
                @Cached("createBinaryProfile()") final ConditionProfile isNilTagProfile) {
    final double[] doubles = obj.getDoubleStorage();
    final int length = doubles.length;
    final Object[] objects = new Object[length];
    for (int i = 0; i < length; i++) {
        objects[i] = ArrayObject.toObjectFromDouble(doubles[i], isNilTagProfile);
    }
    return objects;
}
 

@Specialization(guards = "obj.isLongType()")
protected static final Object[] doArrayOfLongs(final ArrayObject obj,
                @Cached("createBinaryProfile()") final ConditionProfile isNilTagProfile) {
    final long[] longs = obj.getLongStorage();
    final int length = longs.length;
    final Object[] objects = new Object[length];
    for (int i = 0; i < length; i++) {
        objects[i] = ArrayObject.toObjectFromLong(longs[i], isNilTagProfile);
    }
    return objects;
}
 

@Specialization
protected static final long doFind(@SuppressWarnings("unused") final Object receiver, final NativeObject key, final NativeObject body, final long start,
                final NativeObject matchTable,
                @Cached("createBinaryProfile()") final ConditionProfile quickReturnProfile,
                @Cached final BranchProfile foundProfile,
                @Cached final BranchProfile notFoundProfile) {
    if (!key.isByteType() || !body.isByteType() || !matchTable.isByteType() || matchTable.getByteLength() < 256) {
        CompilerDirectives.transferToInterpreter();
        throw PrimitiveFailed.BAD_ARGUMENT;
    }
    final int keyLength = key.getByteLength();
    if (quickReturnProfile.profile(keyLength == 0)) {
        return 0L;
    } else {
        final int bodyLength = body.getByteLength();
        for (long startIndex = Math.max(start - 1, 0); startIndex <= bodyLength - keyLength; startIndex++) {
            int index = 0;
            while (matchTable.getByte(body.getByteUnsigned(startIndex + index)) == matchTable.getByte(key.getByteUnsigned(index))) {
                if (index == keyLength - 1) {
                    foundProfile.enter();
                    return startIndex + 1;
                } else {
                    index++;
                }
            }
        }
        notFoundProfile.enter();
        return 0L;
    }
}
 

@Specialization(guards = {"cachedIndex == index", "object.getLayout() == cachedLayout", "cachedIndex >= cachedLayout.getInstSize()"}, limit = "VARIABLE_PART_INDEX_CACHE_LIMIT")
protected static final Object doReadFromVariablePartCachedIndex(final WeakVariablePointersObject object, @SuppressWarnings("unused") final int index,
                @Cached("index") final int cachedIndex,
                @Cached("object.getLayout()") final ObjectLayout cachedLayout,
                @Cached("createBinaryProfile()") final ConditionProfile nilProfile) {
    return object.getFromVariablePart(cachedIndex - cachedLayout.getInstSize(), nilProfile);
}