FastLongMethodGenerator.java

  1. package org.jruby.ext.ffi.jffi;


  4. import com.kenai.jffi.CallContext;
  5. import com.kenai.jffi.CallingConvention;
  6. import com.kenai.jffi.Platform;
  7. import org.jruby.ext.ffi.NativeType;

  9. /**
  10.  *
  11.  */
  12. final class FastLongMethodGenerator extends AbstractNumericMethodGenerator {
  13.     private static final int MAX_PARAMETERS = getMaximumFastLongParameters();

  15.     private static final String[] signatures = buildSignatures(long.class, MAX_PARAMETERS);

  17.     private static final String[] methodNames = {
  18.         "invokeL0", "invokeL1", "invokeL2", "invokeL3", "invokeL4", "invokeL5", "invokeL6"
  19.     };

  21.     String getInvokerMethodName(JITSignature signature) {

  23.         final int parameterCount = signature.getParameterCount();

  25.         if (parameterCount <= MAX_PARAMETERS && parameterCount <= methodNames.length) {
  26.             return methodNames[parameterCount];

  28.         } else {
  29.             throw new IllegalArgumentException("invalid fast-long parameter count: " + parameterCount);
  30.         }
  31.     }

  33.     String getInvokerSignature(int parameterCount) {
  34.         if (parameterCount <= MAX_PARAMETERS && parameterCount <= signatures.length) {
  35.             return signatures[parameterCount];
  36.         }
  37.         throw new IllegalArgumentException("invalid fast-long parameter count: " + parameterCount);
  38.     }

  40.     final Class getInvokerIntType() {
  41.         return long.class;
  42.     }

  44.     public boolean isSupported(JITSignature signature) {
  45.         final int parameterCount = signature.getParameterCount();

  47.         if (!signature.getCallingConvention().equals(CallingConvention.DEFAULT) || parameterCount > MAX_PARAMETERS) {
  48.             return false;
  49.         }

  51.         final Platform platform = Platform.getPlatform();

  53.         if (platform.getOS().equals(Platform.OS.WINDOWS)) {
  54.             return false;
  55.         }

  57.         // Only supported on amd64 arches
  58.         if (!platform.getCPU().equals(Platform.CPU.X86_64)) {
  59.             return false;
  60.         }

  62.         for (int i = 0; i < parameterCount; i++) {
  63.             if (!isFastLongParameter(platform, signature.getParameterType(i))) {
  64.                 return false;
  65.             }
  66.         }

  68.         return isFastLongResult(platform, signature.getResultType());
  69.     }


  72.     final static int getMaximumFastLongParameters() {
  73.         try {
  74.             com.kenai.jffi.Invoker.class.getDeclaredMethod("invokeL6", CallContext.class, long.class,
  75.                     long.class, long.class, long.class, long.class, long.class, long.class);
  76.             return 6;
  77.         } catch (Throwable t) {
  78.             return -1;
  79.         }
  80.     }


  83.     private static boolean isFastLongType(Platform platform, NativeType type) {
  84.         switch (type) {
  85.             case BOOL:
  86.             case CHAR:
  87.             case UCHAR:
  88.             case SHORT:
  89.             case USHORT:
  90.             case INT:
  91.             case UINT:
  92.             case LONG:
  93.             case ULONG:
  94.             case LONG_LONG:
  95.             case ULONG_LONG:
  96.             case POINTER:
  97.                 return true;

  99.             default:
  100.                 return false;
  101.         }
  102.     }


  105.     static boolean isFastLongResult(Platform platform, NativeType type) {
  106.         switch (type) {
  107.             case VOID:
  108.                 return true;
  109.                 
  110.             case POINTER:
  111.             case STRING:
  112.             case TRANSIENT_STRING:
  113.                 return platform.addressSize() == 64;

  115.             default:
  116.                 return isFastLongType(platform, type);
  117.         }
  118.     }

  120.     static boolean isFastLongParameter(Platform platform, NativeType type) {
  121.         switch (type) {
  122.             case POINTER:
  123.             case BUFFER_IN:
  124.             case BUFFER_OUT:
  125.             case BUFFER_INOUT:
  126.             case STRING:
  127.             case TRANSIENT_STRING:
  128.                 return platform.addressSize() == 64;
  129.             
  130.             default:
  131.                 return isFastLongType(platform, type);
  132.         }
  133.     }
  134. }
Created with JaCoCo 0.7.3.201501050207