Examples with VectorType com.oracle.truffle.llvm.runtime.types.VectorType used on opensource projects

Example 1 with VectorType

use of com.oracle.truffle.llvm.runtime.types.VectorType in project sulong by graalvm.

the class BinaryOperationConstant method fromSymbols.

public static BinaryOperationConstant fromSymbols(SymbolTable symbols, Type type, int opcode, int lhs, int rhs) {
    final boolean isFloatingPoint = Type.isFloatingpointType(type) || (type instanceof VectorType && Type.isFloatingpointType(((VectorType) type).getElementType()));
    final BinaryOperator operator = BinaryOperator.decode(opcode, isFloatingPoint);
    final BinaryOperationConstant constant = new BinaryOperationConstant(type, operator);
    constant.lhs = symbols.getForwardReferenced(lhs, constant);
    constant.rhs = symbols.getForwardReferenced(rhs, constant);
    return constant;
}

Example 2 with VectorType

use of com.oracle.truffle.llvm.runtime.types.VectorType in project sulong by graalvm.

the class AggregateConstant method fromData.

public static AggregateConstant fromData(Type type, long[] data) {
    final AggregateConstant aggregateConstant;
    final Type elementType;
    if (type instanceof ArrayType) {
        final ArrayType arrayType = (ArrayType) type;
        elementType = arrayType.getElementType();
        aggregateConstant = new ArrayConstant(arrayType, data.length);
    } else if (type instanceof VectorType) {
        final VectorType vectorType = (VectorType) type;
        elementType = vectorType.getElementType();
        aggregateConstant = new VectorConstant((VectorType) type, data.length);
    } else {
        throw new RuntimeException("Cannot create constant from data: " + type);
    }
    for (int i = 0; i < data.length; i++) {
        aggregateConstant.elements[i] = Constant.createFromData(elementType, data[i]);
    }
    return aggregateConstant;
}

Example 3 with VectorType

use of com.oracle.truffle.llvm.runtime.types.VectorType in project sulong by graalvm.

the class Function method createShuffleVector.

private void createShuffleVector(long[] args) {
    int i = 0;
    int vector1 = getIndex(args[i++]);
    Type vectorType;
    if (scope.isValueForwardRef(vector1)) {
        vectorType = types.get(args[i++]);
    } else {
        vectorType = scope.getValueType(vector1);
    }
    int vector2 = getIndex(args[i++]);
    int mask = getIndex(args[i]);
    Type subtype = ((VectorType) vectorType).getElementType();
    int length = ((VectorType) scope.getValueType(mask)).getNumberOfElements();
    Type type = new VectorType(subtype, length);
    emit(ShuffleVectorInstruction.fromSymbols(scope.getSymbols(), type, vector1, vector2, mask));
}

Example 4 with VectorType

use of com.oracle.truffle.llvm.runtime.types.VectorType in project sulong by graalvm.

the class BasicNodeFactory method createVectorLiteralNode.

@Override
public LLVMExpressionNode createVectorLiteralNode(LLVMParserRuntime runtime, List<LLVMExpressionNode> listValues, Type type) {
    LLVMExpressionNode[] vals = listValues.toArray(new LLVMExpressionNode[listValues.size()]);
    Type llvmType = ((VectorType) type).getElementType();
    if (llvmType instanceof PrimitiveType) {
        switch(((PrimitiveType) llvmType).getPrimitiveKind()) {
            case I1:
                return LLVMVectorI1LiteralNodeGen.create(vals);
            case I8:
                return LLVMVectorI8LiteralNodeGen.create(vals);
            case I16:
                return LLVMVectorI16LiteralNodeGen.create(vals);
            case I32:
                return LLVMVectorI32LiteralNodeGen.create(vals);
            case I64:
                return LLVMVectorI64LiteralNodeGen.create(vals);
            case FLOAT:
                return LLVMVectorFloatLiteralNodeGen.create(vals);
            case DOUBLE:
                return LLVMVectorDoubleLiteralNodeGen.create(vals);
            default:
                throw new AssertionError();
        }
    } else if (llvmType instanceof PointerType) {
        if (((PointerType) llvmType).getPointeeType() instanceof FunctionType) {
            return LLVMVectorFunctionLiteralNodeGen.create(vals);
        } else {
            return LLVMVectorAddressLiteralNodeGen.create(vals);
        }
    } else {
        throw new AssertionError(llvmType + " not yet supported");
    }
}

Example 5 with VectorType

use of com.oracle.truffle.llvm.runtime.types.VectorType in project sulong by graalvm.

the class Types method record.

@Override
public void record(long id, long[] args) {
    TypesRecord record = TypesRecord.decode(id);
    Type type;
    switch(record) {
        case NUMBER_OF_ENTRIES:
            table = new Type[(int) args[0]];
            return;
        case VOID:
            type = VoidType.INSTANCE;
            break;
        case FLOAT:
            type = PrimitiveType.FLOAT;
            break;
        case DOUBLE:
            type = PrimitiveType.DOUBLE;
            break;
        case LABEL:
            type = MetaType.LABEL;
            break;
        case OPAQUE:
            if (structName != null) {
                type = new OpaqueType(LLVMIdentifier.toLocalIdentifier(structName));
                structName = null;
                module.addGlobalType(type);
            } else {
                type = new OpaqueType();
            }
            break;
        case INTEGER:
            type = Type.getIntegerType((int) args[0]);
            break;
        case POINTER:
            {
                final PointerType pointerType = new PointerType(null);
                setType((int) args[0], pointerType::setPointeeType);
                type = pointerType;
                break;
            }
        case FUNCTION_OLD:
            {
                final FunctionType functionType = new FunctionType(null, toTypes(args, 3, args.length), args[0] != 0);
                setType((int) args[2], functionType::setReturnType);
                type = functionType;
                break;
            }
        case HALF:
            type = PrimitiveType.HALF;
            break;
        case ARRAY:
            {
                final ArrayType arrayType = new ArrayType(null, (int) args[0]);
                setType((int) args[1], arrayType::setElementType);
                type = arrayType;
                break;
            }
        case VECTOR:
            {
                final VectorType vectorType = new VectorType(null, (int) args[0]);
                setType((int) args[1], vectorType::setElementType);
                type = vectorType;
                break;
            }
        case X86_FP80:
            type = PrimitiveType.X86_FP80;
            break;
        case FP128:
            type = PrimitiveType.F128;
            break;
        case PPC_FP128:
            type = PrimitiveType.PPC_FP128;
            break;
        case METADATA:
            type = MetaType.METADATA;
            break;
        case X86_MMX:
            type = MetaType.X86MMX;
            break;
        case STRUCT_NAME:
            {
                structName = Records.toString(args);
                return;
            }
        case STRUCT_ANON:
        case STRUCT_NAMED:
            {
                final boolean isPacked = args[0] != 0;
                final Type[] members = toTypes(args, 1, args.length);
                if (structName != null) {
                    type = new StructureType(LLVMIdentifier.toTypeIdentifier(structName), isPacked, members);
                    structName = null;
                    module.addGlobalType(type);
                } else {
                    type = new StructureType(isPacked, members);
                }
                break;
            }
        case FUNCTION:
            {
                final FunctionType functionType = new FunctionType(null, toTypes(args, 2, args.length), args[0] != 0);
                setType((int) args[1], functionType::setReturnType);
                type = functionType;
                break;
            }
        case TOKEN:
            type = MetaType.TOKEN;
            break;
        default:
            type = MetaType.UNKNOWN;
            break;
    }
    if (table[size] != null) {
        ((UnresolvedType) table[size]).dependent.accept(type);
    }
    table[size++] = type;
}