Examples with NullConstant com.oracle.truffle.llvm.parser.model.symbols.constants.NullConstant used on opensource projects

Example 1 with NullConstant

use of com.oracle.truffle.llvm.parser.model.symbols.constants.NullConstant in project sulong by graalvm.

the class ParseUtil method asLong.

public static long asLong(long[] args, int index, Metadata md) {
    final int typeIndex = index << 1;
    if (typeIndex >= args.length) {
        return DEFAULT_NUMBER;
    }
    final Type type = md.getTypeById(args[typeIndex]);
    if (type == MetaType.METADATA || VoidType.INSTANCE.equals(type)) {
        return DEFAULT_NUMBER;
    }
    final int valueIndex = typeIndex + 1;
    final SymbolImpl value = md.getScope().getSymbols().getOrNull((int) args[valueIndex]);
    if (value instanceof IntegerConstant) {
        return ((IntegerConstant) value).getValue();
    } else if (value instanceof BigIntegerConstant) {
        return ((BigIntegerConstant) value).getValue().longValue();
    } else if (value instanceof NullConstant || value instanceof UndefinedConstant) {
        return 0L;
    } else {
        return DEFAULT_NUMBER;
    }
}

Example 2 with NullConstant

use of com.oracle.truffle.llvm.parser.model.symbols.constants.NullConstant in project sulong by graalvm.

the class LLVMBitcodeInstructionVisitor method visit.

@Override
public void visit(AllocateInstruction allocate) {
    final Type type = allocate.getPointeeType();
    int alignment;
    if (allocate.getAlign() == 0) {
        alignment = runtime.getContext().getByteAlignment(type);
    } else {
        alignment = 1 << (allocate.getAlign() - 1);
    }
    if (alignment == 0) {
        alignment = LLVMStack.NO_ALIGNMENT_REQUIREMENTS;
    }
    final SymbolImpl count = allocate.getCount();
    final LLVMExpressionNode result;
    if (count instanceof NullConstant) {
        result = nodeFactory.createAlloca(runtime, type, alignment);
    } else if (count instanceof IntegerConstant) {
        long numElements = (int) ((IntegerConstant) count).getValue();
        if (numElements == 1) {
            result = nodeFactory.createAlloca(runtime, type, alignment);
        } else {
            assert numElements == (int) numElements;
            ArrayType arrayType = new ArrayType(type, (int) numElements);
            result = nodeFactory.createAlloca(runtime, arrayType, alignment);
        }
    } else {
        LLVMExpressionNode num = symbols.resolve(count);
        result = nodeFactory.createAllocaArray(runtime, type, num, alignment);
    }
    // we never want to step on allocations, only to actual assignments in the source
    createFrameWrite(result, allocate, null);
}

Example 3 with NullConstant

use of com.oracle.truffle.llvm.parser.model.symbols.constants.NullConstant in project sulong by graalvm.

the class ParseUtil method isInteger.

public static boolean isInteger(long[] args, int index, Metadata md) {
    final int typeIndex = index << 1;
    final Type type = md.getTypeById(args[typeIndex]);
    if (type == MetaType.METADATA || VoidType.INSTANCE.equals(type)) {
        return false;
    }
    final int valueIndex = typeIndex + 1;
    final SymbolImpl value = md.getScope().getSymbols().getOrNull((int) args[valueIndex]);
    return value instanceof IntegerConstant || value instanceof BigIntegerConstant || value instanceof NullConstant || value instanceof UndefinedConstant;
}

Example 4 with NullConstant

use of com.oracle.truffle.llvm.parser.model.symbols.constants.NullConstant in project sulong by graalvm.

the class LLVMRuntimeDebugInformation method handleDebugIntrinsic.

LLVMExpressionNode handleDebugIntrinsic(SymbolImpl value, SourceVariable variable, MDExpression expression, long index, boolean isDeclaration) {
    if (!isEnabled || variable.hasStaticAllocation()) {
        return null;
    }
    LLVMExpressionNode valueRead = null;
    if (isDeclaration) {
        if (value instanceof UndefinedConstant) {
            if (variable.hasValue()) {
                // know this from the presence of the value
                return null;
            }
            valueRead = symbols.resolve(new NullConstant(MetaType.DEBUG));
        } else if (value instanceof NullConstant) {
            valueRead = symbols.resolve(new NullConstant(MetaType.DEBUG));
        } else if (value instanceof GlobalValueSymbol || value.getType() instanceof PointerType) {
            valueRead = symbols.resolve(value);
        }
    } else {
        valueRead = symbols.resolve(value);
        if (index != 0) {
            // this is unsupported, it doesn't appear in LLVM 3.8+
            return null;
        }
    }
    if (valueRead == null) {
        return null;
    }
    int partIndex = -1;
    int[] clearParts = null;
    if (ValueFragment.describesFragment(expression)) {
        final ValueFragment fragment = ValueFragment.parse(expression);
        final List<ValueFragment> siblings = variable.getFragments();
        final List<Integer> clearSiblings = new ArrayList<>(siblings.size());
        partIndex = ValueFragment.getPartIndex(fragment, siblings, clearSiblings);
        if (clearSiblings.isEmpty()) {
            // this will be the case most of the time
            clearParts = CLEAR_NONE;
        } else {
            clearParts = clearSiblings.stream().mapToInt(Integer::intValue).toArray();
        }
    }
    if (partIndex < 0 && variable.hasFragments()) {
        partIndex = variable.getFragmentIndex(0, (int) variable.getSymbol().getType().getSize());
        if (partIndex < 0) {
            throw new IllegalStateException("Cannot find index of value fragment!");
        }
        clearParts = new int[variable.getFragments().size() - 1];
        for (int i = 0; i < partIndex; i++) {
            clearParts[i] = i;
        }
        for (int i = partIndex; i < clearParts.length; i++) {
            clearParts[i] = i + 1;
        }
    }
    final boolean mustDereference = isDeclaration || mustDereferenceValue(expression, variable.getSourceType(), value);
    final FrameSlot targetSlot = frame.findOrAddFrameSlot(variable.getSymbol(), MetaType.DEBUG, FrameSlotKind.Object);
    final LLVMExpressionNode containerRead = factory.createFrameRead(runtime, MetaType.DEBUG, targetSlot);
    return factory.createDebugWrite(mustDereference, valueRead, targetSlot, containerRead, partIndex, clearParts);
}