Java HotSpotCallingConventionType.NativeCall方法代码示例

import jdk.vm.ci.hotspot.HotSpotCallingConventionType; //导入方法依赖的package包/类
@Override
public RegisterArray getCallingConventionRegisters(Type type, JavaKind kind) {
    HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type;
    switch (kind) {
        case Boolean:
        case Byte:
        case Short:
        case Char:
        case Int:
        case Long:
        case Object:
            return hotspotType == HotSpotCallingConventionType.NativeCall ? nativeGeneralParameterRegisters : javaGeneralParameterRegisters;
        case Float:
        case Double:
            return simdParameterRegisters;
        default:
            throw JVMCIError.shouldNotReachHere();
    }
}
 

import jdk.vm.ci.hotspot.HotSpotCallingConventionType; //导入方法依赖的package包/类
@Override
public RegisterArray getCallingConventionRegisters(Type type, JavaKind kind) {
    HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type;
    switch (kind) {
        case Boolean:
        case Byte:
        case Short:
        case Char:
        case Int:
        case Long:
        case Object:
            return hotspotType == HotSpotCallingConventionType.NativeCall ? nativeGeneralParameterRegisters : javaGeneralParameterRegisters;
        case Float:
        case Double:
            return hotspotType == HotSpotCallingConventionType.NativeCall ? nativeXMMParameterRegisters : javaXMMParameterRegisters;
        default:
            throw JVMCIError.shouldNotReachHere();
    }
}
 

import jdk.vm.ci.hotspot.HotSpotCallingConventionType; //导入方法依赖的package包/类
@Override
public Register[] getCallingConventionRegisters(Type type, JavaKind kind) {
    HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type;
    switch (kind) {
        case Boolean:
        case Byte:
        case Short:
        case Char:
        case Int:
        case Long:
        case Object:
            return hotspotType == HotSpotCallingConventionType.NativeCall ? nativeGeneralParameterRegisters : javaGeneralParameterRegisters;
        case Float:
        case Double:
            return simdParameterRegisters;
        default:
            throw JVMCIError.shouldNotReachHere();
    }
}
 

import jdk.vm.ci.hotspot.HotSpotCallingConventionType; //导入方法依赖的package包/类
@Override
public Register[] getCallingConventionRegisters(Type type, JavaKind kind) {
    HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type;
    switch (kind) {
        case Boolean:
        case Byte:
        case Short:
        case Char:
        case Int:
        case Long:
        case Object:
            return hotspotType == HotSpotCallingConventionType.NativeCall ? nativeGeneralParameterRegisters : javaGeneralParameterRegisters;
        case Float:
        case Double:
            return xmmParameterRegisters;
        default:
            throw JVMCIError.shouldNotReachHere();
    }
}
 

import jdk.vm.ci.hotspot.HotSpotCallingConventionType; //导入方法依赖的package包/类
@Override
public CallingConvention getCallingConvention(Type type, JavaType returnType, JavaType[] parameterTypes, ValueKindFactory<?> valueKindFactory) {
    HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type;
    if (type == HotSpotCallingConventionType.NativeCall) {
        return callingConvention(nativeGeneralParameterRegisters, returnType, parameterTypes, hotspotType, valueKindFactory);
    }
    // On x64, parameter locations are the same whether viewed
    // from the caller or callee perspective
    return callingConvention(javaGeneralParameterRegisters, returnType, parameterTypes, hotspotType, valueKindFactory);
}
 

import jdk.vm.ci.hotspot.HotSpotCallingConventionType; //导入方法依赖的package包/类
@Override
public CallingConvention getCallingConvention(Type type, JavaType returnType, JavaType[] parameterTypes, ValueKindFactory<?> valueKindFactory) {
    HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type;
    if (type == HotSpotCallingConventionType.NativeCall) {
        return callingConvention(nativeGeneralParameterRegisters, nativeXMMParameterRegisters, windowsOS, returnType, parameterTypes, hotspotType, valueKindFactory);
    }
    // On x64, parameter locations are the same whether viewed
    // from the caller or callee perspective
    return callingConvention(javaGeneralParameterRegisters, javaXMMParameterRegisters, false, returnType, parameterTypes, hotspotType, valueKindFactory);
}
 

import jdk.vm.ci.hotspot.HotSpotCallingConventionType; //导入方法依赖的package包/类
@Override
public CallingConvention getCallingConvention(Type type, JavaType returnType, JavaType[] parameterTypes, ValueKindFactory<?> valueKindFactory) {
    HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type;
    if (type == HotSpotCallingConventionType.JavaCall || type == HotSpotCallingConventionType.NativeCall) {
        return callingConvention(cpuCallerParameterRegisters, returnType, parameterTypes, hotspotType, valueKindFactory);
    }
    if (type == HotSpotCallingConventionType.JavaCallee) {
        return callingConvention(cpuCalleeParameterRegisters, returnType, parameterTypes, hotspotType, valueKindFactory);
    }
    throw JVMCIError.shouldNotReachHere();
}
 

import jdk.vm.ci.hotspot.HotSpotCallingConventionType; //导入方法依赖的package包/类
@Override
public CallingConvention getCallingConvention(Type type, JavaType returnType, JavaType[] parameterTypes, TargetDescription target) {
    HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type;
    if (type == HotSpotCallingConventionType.NativeCall) {
        return callingConvention(nativeGeneralParameterRegisters, returnType, parameterTypes, hotspotType, target);
    }
    // On x64, parameter locations are the same whether viewed
    // from the caller or callee perspective
    return callingConvention(javaGeneralParameterRegisters, returnType, parameterTypes, hotspotType, target);
}
 

import jdk.vm.ci.hotspot.HotSpotCallingConventionType; //导入方法依赖的package包/类
@Override
public CallingConvention getCallingConvention(Type type, JavaType returnType, JavaType[] parameterTypes, TargetDescription target) {
    HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type;
    if (type == HotSpotCallingConventionType.JavaCall || type == HotSpotCallingConventionType.NativeCall) {
        return callingConvention(cpuCallerParameterRegisters, returnType, parameterTypes, hotspotType, target);
    }
    if (type == HotSpotCallingConventionType.JavaCallee) {
        return callingConvention(cpuCalleeParameterRegisters, returnType, parameterTypes, hotspotType, target);
    }
    throw JVMCIError.shouldNotReachHere();
}
 

import jdk.vm.ci.hotspot.HotSpotCallingConventionType; //导入方法依赖的package包/类
/**
 * Creates a {@link HotSpotForeignCallLinkage}.
 *
 * @param descriptor the descriptor of the call
 * @param address the address of the code to call
 * @param effect specifies if the call destroys or preserves all registers (apart from
 *            temporaries which are always destroyed)
 * @param outgoingCcType outgoing (caller) calling convention type
 * @param incomingCcType incoming (callee) calling convention type (can be null)
 * @param transition specifies if this is a {@linkplain #needsDebugInfo() leaf} call
 * @param reexecutable specifies if the call can be re-executed without (meaningful) side
 *            effects. Deoptimization will not return to a point before a call that cannot be
 *            re-executed.
 * @param killedLocations the memory locations killed by the call
 */
public static HotSpotForeignCallLinkage create(MetaAccessProvider metaAccess, CodeCacheProvider codeCache, WordTypes wordTypes, HotSpotForeignCallsProvider foreignCalls,
                ForeignCallDescriptor descriptor, long address, RegisterEffect effect, Type outgoingCcType, Type incomingCcType, Transition transition, boolean reexecutable,
                LocationIdentity... killedLocations) {
    CallingConvention outgoingCc = createCallingConvention(metaAccess, codeCache, wordTypes, foreignCalls, descriptor, outgoingCcType);
    CallingConvention incomingCc = incomingCcType == null ? null : createCallingConvention(metaAccess, codeCache, wordTypes, foreignCalls, descriptor, incomingCcType);
    HotSpotForeignCallLinkageImpl linkage = new HotSpotForeignCallLinkageImpl(descriptor, address, effect, transition, outgoingCc, incomingCc, reexecutable, killedLocations);
    if (outgoingCcType == HotSpotCallingConventionType.NativeCall) {
        linkage.temporaries = foreignCalls.getNativeABICallerSaveRegisters();
    }
    return linkage;
}