Divergence 64 vs 32 bit FFI using intptr_t

[feli-citas]

32 bit Integer overflows lead to divergence between 32 and 64 bit dart versions when parameter is passed through an FFI intptr_t.

DART_EXPORT intptr_t SumManyInts(intptr_t a,
                                 intptr_t b,
                                 intptr_t c,
                                 intptr_t d,
                                 intptr_t e,
                                 intptr_t f,
                                 intptr_t g,
                                 intptr_t h,
                                 intptr_t i,
                                 intptr_t j) {
  std::cout << "SumManyInts(" << a << ", " << b << ", " << c << ", " << d
            << ", " << e << ", " << f << ", " << g << ", " << h << ", " << i
            << ", " << j << ")\n";
  intptr_t retval = a + b + c + d + e + f + g + h + i + j;
  std::cout << "returning " << retval << "\n";
  return retval;
}

import 'dart:ffi' as ffi;
import 'dart:io' show Platform;

String _platformPath(String name, {String path}) {
  if (path == null) path = "";
  if (Platform.isLinux) return path + "lib" + name + ".so";
  if (Platform.isMacOS) return path + "lib" + name + ".dylib";
  if (Platform.isWindows) return path + name + ".dll";
  throw Exception("Platform not implemented");
}
    
ffi.DynamicLibrary dlopenPlatformSpecific(String name, {String path}) {
  String fullPath = _platformPath(name, path: path);
  return ffi.DynamicLibrary.open(fullPath);
}   
    
ffi.DynamicLibrary ffiTestFunctions = dlopenPlatformSpecific("ffi_test_functions");


typedef DecenaryOp = int Function(int, int, int, int, int, int, int, int, int, int);
typedef NativeDecenaryOp = ffi.IntPtr Function(
    ffi.IntPtr,
    ffi.IntPtr,
    ffi.IntPtr,
    ffi.IntPtr,
    ffi.IntPtr,
    ffi.IntPtr,
    ffi.IntPtr,
    ffi.IntPtr,
    ffi.IntPtr,
    ffi.IntPtr);
DecenaryOp sumManyInts = ffiTestFunctions
    .lookupFunction<NativeDecenaryOp, DecenaryOp>("SumManyInts");

main() {
  sumManyInts(9223372032559809536, 0, 0, 0, 0, 0, 0, 0, 0, 0);
}

64 bit

SumManyInts(9223372032559809536, 0, 0, 0, 0, 0, 0, 0, 0, 0)
returning 9223372032559809536

32 bit

SumManyInts(1024, 0, 0, 0, 0, 0, 0, 0, 0, 0)
returning 1024

[aartbik]

Ah, Dart int-s are always 64-bit. However, intptr_t-s are architecture dependent. So this behavior is to be expected. Let's not call C++ functions that depend on intptr_t.