[commit] r2377 - Fix checkin snafu; submit the correct SqueakFFIPrims from ReentrantIA32FFIPlugin

 
Author: eliot
Date: 2011-04-01 12:51:41 -0700 (Fri, 01 Apr 2011)
New Revision: 2377

Modified:
   branches/Cog/src/plugins/SqueakFFIPrims/SqueakFFIPrims.c
Log:
Fix checkin snafu; submit the correct SqueakFFIPrims from ReentrantIA32FFIPlugin


Modified: branches/Cog/src/plugins/SqueakFFIPrims/SqueakFFIPrims.c
===================================================================
--- branches/Cog/src/plugins/SqueakFFIPrims/SqueakFFIPrims.c 2011-04-01 19:39:21 UTC (rev 2376)
+++ branches/Cog/src/plugins/SqueakFFIPrims/SqueakFFIPrims.c 2011-04-01 19:51:41 UTC (rev 2377)
@@ -1,9 +1,9 @@
 /* Automatically generated by
  VMPluginCodeGenerator VMMaker-oscog.54 uuid: 73c095bd-7fa5-4ef9-b9fc-60378cae64c7
    from
- ThreadedARMFFIPlugin VMMaker-oscog.54 uuid: 73c095bd-7fa5-4ef9-b9fc-60378cae64c7
+ ReentrantIA32FFIPlugin VMMaker-oscog.54 uuid: 73c095bd-7fa5-4ef9-b9fc-60378cae64c7
  */
-static char __buildInfo[] = "ThreadedARMFFIPlugin VMMaker-oscog.54 uuid: 73c095bd-7fa5-4ef9-b9fc-60378cae64c7 " __DATE__ ;
+static char __buildInfo[] = "ReentrantIA32FFIPlugin VMMaker-oscog.54 uuid: 73c095bd-7fa5-4ef9-b9fc-60378cae64c7 " __DATE__ ;
 
 
 
@@ -53,26 +53,20 @@
 # define setsp(ignored) 0
 #endif
 
-#if !defined(STACK_ALIGN_BYTES)
-# if __APPLE__ && __MACH__ && __i386__
-#  define STACK_ALIGN_BYTES 16
-# elif __linux__ && __i386__
-#  define STACK_ALIGN_BYTES 16
-# elif defined(__amd64__) || defined(__x86_64__) ||  defined(__amd64) || defined(__x86_64)
-#  define STACK_ALIGN_BYTES 16
-# elif defined(powerpc) || defined(__powerpc__) || defined(_POWER) || defined(__POWERPC__) || defined(__PPC__)
-#  define STACK_ALIGN_BYTES 16
-# elif defined(__sparc64__) || defined(__sparcv9__) || defined(__sparc_v9__) /* must preceed 32-bit sparc defs */
-#  define STACK_ALIGN_BYTES 16
-# elif defined(sparc) || defined(__sparc__) || defined(__sparclite__)
-#  define STACK_ALIGN_BYTES 8
-# else
-#  define STACK_ALIGN_BYTES 0
-# endif
-#endif /* !defined(STACK_ALIGN_BYTES) */
-
-#if !defined(STACK_OFFSET_BYTES)
-# define STACK_OFFSET_BYTES 0
+#if __APPLE__ && __MACH__ && __i386__
+# define STACK_ALIGN_BYTES 16
+#elif __linux__ && __i386__
+# define STACK_ALIGN_BYTES 16
+#elif defined(__amd64__) || defined(__x86_64__) ||  defined(__amd64) || defined(__x86_64)
+# define STACK_ALIGN_BYTES 16
+#elif defined(powerpc) || defined(__powerpc__) || defined(_POWER) || defined(__POWERPC__) || defined(__PPC__)
+# define STACK_ALIGN_BYTES 16
+#elif defined(__sparc64__) || defined(__sparcv9__) || defined(__sparc_v9__) /* must preceed 32-bit sparc defs */
+# define STACK_ALIGN_BYTES 16
+#elif defined(sparc) || defined(__sparc__) || defined(__sparclite__)
+# define STACK_ALIGN_BYTES 8
+#else
+# define STACK_ALIGN_BYTES 0
 #endif
 
 #if defined(_X86_) || defined(i386) || defined(__i386) || defined(__i386__)
@@ -124,11 +118,9 @@
  sqInt ffiRetHeader;
  sqInt stringArgIndex;
  char *stringArgs[15];
- sqInt regIndex;
- sqInt integerRegisters[8];
  } CalloutState;
 
-#define ThreadedFFICalloutStateForARM CalloutState
+#define ReentrantFFICalloutState CalloutState
 
 
 
@@ -141,7 +133,6 @@
 #define ExternalFunctionStackSizeIndex 3
 #define FFIAtomicTypeMask 0xF000000
 #define FFIAtomicTypeShift 24
-#define FFICallFlagThreaded null
 #define FFICallTypeApi 1
 #define FFIErrorAddressNotFound 13
 #define FFIErrorAttemptToPassVoid 14
@@ -152,6 +143,7 @@
 #define FFIErrorBadExternalFunction 17
 #define FFIErrorBadExternalLibrary 16
 #define FFIErrorBadReturn 10
+#define FFIErrorCallFrameTooBig 19
 #define FFIErrorCallType 9
 #define FFIErrorCoercionFailed 6
 #define FFIErrorIntAsPointer 4
@@ -182,7 +174,6 @@
 #define PrimErrBadNumArgs 5
 #define PrimErrBadReceiver 2
 #define PrimErrNoCMemory 10
-#define PrimErrObjectMayMove 14
 
 
 /*** Function Prototypes ***/
@@ -194,7 +185,7 @@
 static sqInt ffiArgumentSpecClassin(sqInt oop, sqInt argSpec, sqInt argClass, CalloutState *calloutState);
 static sqInt ffiAtomicArgByReferenceClassin(sqInt oop, sqInt oopClass, CalloutState *calloutState);
 static sqInt ffiAtomicStructByReferenceClassin(sqInt oop, sqInt oopClass, CalloutState *calloutState);
-static sqInt ffiCalloutToSpecOnStackin(void *procAddr, sqInt specOnStack, sqInt calloutState);
+static sqInt ffiCalloutToSpecOnStackin(void *procAddr, sqInt specOnStack, CalloutState *calloutState);
 static sqInt ffiCallArgArrayOrNilNumArgs(sqInt externalFunction, sqInt argArrayOrNil, sqInt nArgs);
 static sqInt ffiCheckReturnWithin(sqInt retSpec, sqInt retClass, CalloutState *calloutState);
 static sqInt ffiContentsOfHandleerrCode(sqInt oop, sqInt errCode);
@@ -207,16 +198,16 @@
 static sqInt ffiLoadCalloutModule(sqInt module);
 static void ffiLogCallout(sqInt lit);
 EXPORT(sqInt) ffiLogCallsTo(char*fileName);
-static sqInt ffiPushDoubleFloatin(sqInt value, sqInt calloutState);
+static sqInt ffiPushDoubleFloatin(double value, CalloutState *calloutState);
 static sqInt ffiPushPointerContentsOfin(sqInt oop, CalloutState *calloutState);
-static sqInt ffiPushPointerin(sqInt value, CalloutState *calloutState);
+static sqInt ffiPushPointerin(void *pointer, CalloutState *calloutState);
 static sqInt ffiPushSignedBytein(sqInt value, CalloutState *calloutState);
 static sqInt ffiPushSignedCharin(sqInt value, CalloutState *calloutState);
 static sqInt ffiPushSignedIntin(sqInt value, CalloutState *calloutState);
 static sqInt ffiPushSignedLongLongOopin(sqInt oop, CalloutState *calloutState);
-static sqInt ffiPushSignedLongLongin(sqLong value, CalloutState *calloutState);
+static sqInt ffiPushSignedLongLongin(usqLong value, CalloutState *calloutState);
 static sqInt ffiPushSignedShortin(sqInt value, CalloutState *calloutState);
-static sqInt ffiPushSingleFloatin(sqInt value, CalloutState *calloutState);
+static sqInt ffiPushSingleFloatin(float value, CalloutState *calloutState);
 static sqInt ffiPushStringOfLengthin(char *pointer, sqInt length, CalloutState *calloutState);
 static sqInt ffiPushStructureContentsOfin(sqInt oop, CalloutState *calloutState);
 static sqInt ffiPushStructureofSizetypeSpecofLengthin(void *pointer, sqInt structSize, sqInt *argSpec, sqInt argSpecSize, CalloutState *calloutState);
@@ -225,12 +216,11 @@
 static sqInt ffiPushUnsignedIntin(sqInt value, CalloutState *calloutState);
 static sqInt ffiPushUnsignedLongLongOopin(sqInt oop, CalloutState *calloutState);
 static sqInt ffiPushUnsignedLongLongin(usqLong value, CalloutState *calloutState);
-static sqInt ffiPushUnsignedLongin(sqInt value, CalloutState *calloutState);
 static sqInt ffiPushUnsignedShortin(sqInt value, CalloutState *calloutState);
 static sqInt ffiPushVoidin(sqInt ignored, CalloutState *calloutState);
 static sqInt ffiReturnCStringFrom(sqInt cPointer);
 static sqInt ffiReturnPointerofTypein(usqLong retVal, sqInt retType, CalloutState *calloutState);
-static sqInt ffiReturnStructofTypein(usqLong longLongRet, sqInt ffiRetClass, CalloutState *calloutState);
+static sqInt ffiReturnStructofTypein(usqLong longLongRet, sqInt ffiRetType, CalloutState *calloutState);
 static sqInt ffiReturnType(sqInt specOnStack);
 static sqInt ffiSupportsCallingConvention(sqInt aCallingConvention);
 static sqInt ffiValidateExternalDataAtomicType(sqInt oop, sqInt atomicType);
@@ -238,7 +228,6 @@
 EXPORT(const char*) getModuleName(void);
 static sqInt halt(void);
 EXPORT(sqInt) initialiseModule(void);
-static void initialize(CalloutState * self_in_initialize);
 static sqInt isAlien(sqInt anOop);
 static sqInt isAtomicType(sqInt typeSpec);
 static sqInt isDirectAlien(sqInt oop);
@@ -261,7 +250,6 @@
 EXPORT(sqInt) primitiveLogCallsTo(void);
 EXPORT(sqInt) primitiveSetManualSurfacePointer(void);
 static sqInt registerArgsSlop(void);
-static sqInt returnStructInRegisters(sqInt returnStructSize);
 EXPORT(sqInt) setInterpreter(struct VirtualMachine*anInterpreter);
 static sqInt sizeField(sqInt oop);
 static sqInt startOfData(sqInt oop);
@@ -292,6 +280,7 @@
 #define ffiAlloc(bytes) (usqInt)malloc(bytes)
 #define ffiFree(pointer) free((void *)(pointer))
 #define isCalleePopsConvention(callType) (PLATFORM_API_USES_CALLEE_POPS_CONVENTION && (callType) == FFICallTypeApi)
+#define returnStructInRegisters(sz) (WIN32_X86_STRUCT_RETURN && (sz) <= 8 && !((sz)&((sz)-1)))
 
 
 static sqInt
@@ -472,12 +461,20 @@
  }
  if (atomicType == FFITypeSingleFloat) {
  /* begin ffiPushSingleFloat:in: */
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ storeSingleFloatAtPointerfrom((calloutState->currentArg), floatValue);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
  }
  else {
  /* begin ffiPushDoubleFloat:in: */
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 8) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ storeFloatAtPointerfrom((calloutState->currentArg), floatValue);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 8);
  return 0;
  }
 }
@@ -510,9 +507,14 @@
     sqInt oopClass1;
     sqInt oopClass2;
     char *pointer;
+    void *pointer1;
+    void *pointer2;
+    void *pointer3;
     sqInt ptrAddress;
     sqInt ptrClass;
     sqInt ptrType;
+    sqInt roundedSize;
+    sqInt roundedSize1;
     sqInt spec;
     sqInt specOop;
     sqInt specType;
@@ -521,9 +523,6 @@
     sqInt typeSpec;
     sqInt typeSpec1;
     sqInt typeSpec2;
-    sqInt value;
-    sqInt value1;
-    sqInt value2;
     sqInt valueOop;
     sqInt valueOop1;
 
@@ -599,8 +598,13 @@
  structSize = ((calloutState->ffiArgHeader)) & FFIStructSizeMask;
  argSpec2 = (calloutState->ffiArgSpec);
  argSpecSize = (calloutState->ffiArgSpecSize);
- subclassResponsibility();
- return null;
+ roundedSize = (structSize + 3) & (~3);
+ if ((((calloutState->currentArg)) + roundedSize) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ memcpy((calloutState->currentArg), ((void *) ptrAddress), structSize);
+ (calloutState->currentArg = ((calloutState->currentArg)) + roundedSize);
+ return 0;
  }
  if (ptrClass == (interpreterProxy->classByteArray())) {
  if (!((interpreterProxy->byteSizeOf(valueOop)) == (((calloutState->ffiArgHeader)) & FFIStructSizeMask))) {
@@ -608,16 +612,17 @@
  }
  ptrAddress = ((int) (interpreterProxy->firstIndexableField(valueOop)));
  if (!(((calloutState->ffiArgHeader)) & FFIFlagPointer)) {
- if ((((calloutState->callFlags)) & FFICallFlagThreaded)
- && (interpreterProxy->isYoung(valueOop))) {
- return -PrimErrObjectMayMove;
- }
  /* begin ffiPushStructure:ofSize:typeSpec:ofLength:in: */
  structSize1 = ((calloutState->ffiArgHeader)) & FFIStructSizeMask;
  argSpec1 = (calloutState->ffiArgSpec);
  argSpecSize1 = (calloutState->ffiArgSpecSize);
- subclassResponsibility();
- return null;
+ roundedSize1 = (structSize1 + 3) & (~3);
+ if ((((calloutState->currentArg)) + roundedSize1) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ memcpy((calloutState->currentArg), ((void *) ptrAddress), structSize1);
+ (calloutState->currentArg = ((calloutState->currentArg)) + roundedSize1);
+ return 0;
  }
  if (!((((calloutState->ffiArgHeader)) & FFIStructSizeMask) == 4)) {
  return FFIErrorStructSize;
@@ -627,7 +632,11 @@
  return FFIErrorInvalidPointer;
  }
  /* begin ffiPushPointer:in: */
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), ptrAddress);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
  }
  return FFIErrorBadArg;
@@ -638,7 +647,11 @@
  }
  if (oop == (interpreterProxy->nilObject())) {
  /* begin ffiPushPointer:in: */
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), null);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
  }
  if (((calloutState->ffiArgHeader)) & FFIFlagAtomic) {
@@ -732,32 +745,38 @@
  ((calloutState->stringArgs))[(calloutState->stringArgIndex)] = copy;
  (calloutState->stringArgIndex = ((calloutState->stringArgIndex)) + 1);
  /* begin ffiPushPointer:in: */
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), copy);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
  }
  atomicType2 = FFITypeUnsignedByte;
  }
- if ((((calloutState->callFlags)) & FFICallFlagThreaded)
- && (((!isAlien)
- || (isDirectAlien(oop)))
- && (interpreterProxy->isYoung(oop)))) {
- return -PrimErrObjectMayMove;
- }
  if ((atomicType2 == FFITypeVoid)
  || ((((usqInt) atomicType2) >> 1) == (((usqInt) FFITypeSignedByte) >> 1))) {
  if (isString
  || (oopClass == (interpreterProxy->classByteArray()))) {
  /* begin ffiPushPointer:in: */
- value = interpreterProxy->firstIndexableField(oop);
- error("shouldBeImplemented");
+ pointer1 = interpreterProxy->firstIndexableField(oop);
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), pointer1);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
  }
  if (isAlien) {
  /* begin ffiPushPointer:in: */
- value1 = pointerForOop(((longAt(oop + BaseHeaderSize)) > 0
+ pointer2 = pointerForOop(((longAt(oop + BaseHeaderSize)) > 0
  ? (oop + BaseHeaderSize) + BytesPerOop
  : longAt((oop + BaseHeaderSize) + BytesPerOop)));
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), pointer2);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
  }
  if (!(atomicType2 == FFITypeVoid)) {
@@ -768,8 +787,12 @@
  || (atomicType2 == FFITypeSingleFloat)) {
  if (interpreterProxy->isWords(oop)) {
  /* begin ffiPushPointer:in: */
- value2 = interpreterProxy->firstIndexableField(oop);
- error("shouldBeImplemented");
+ pointer3 = interpreterProxy->firstIndexableField(oop);
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), pointer3);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
  }
  }
@@ -880,12 +903,20 @@
  }
  if (atomicType1 == FFITypeSingleFloat) {
  /* begin ffiPushSingleFloat:in: */
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ storeSingleFloatAtPointerfrom((calloutState->currentArg), floatValue);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
  }
  else {
  /* begin ffiPushDoubleFloat:in: */
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 8) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ storeFloatAtPointerfrom((calloutState->currentArg), floatValue);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 8);
  return 0;
  }
  }
@@ -908,10 +939,10 @@
     sqInt isString;
     sqInt length;
     char *pointer;
+    void *pointer1;
+    void *pointer2;
+    void *pointer3;
     sqInt typeSpec;
-    sqInt value;
-    sqInt value1;
-    sqInt value2;
 
  /* begin atomicTypeOf: */
  typeSpec = (calloutState->ffiArgHeader);
@@ -939,32 +970,38 @@
  ((calloutState->stringArgs))[(calloutState->stringArgIndex)] = copy;
  (calloutState->stringArgIndex = ((calloutState->stringArgIndex)) + 1);
  /* begin ffiPushPointer:in: */
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), copy);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
  }
  atomicType = FFITypeUnsignedByte;
  }
- if ((((calloutState->callFlags)) & FFICallFlagThreaded)
- && (((!isAlien)
- || (isDirectAlien(oop)))
- && (interpreterProxy->isYoung(oop)))) {
- return -PrimErrObjectMayMove;
- }
  if ((atomicType == FFITypeVoid)
  || ((((usqInt) atomicType) >> 1) == (((usqInt) FFITypeSignedByte) >> 1))) {
  if (isString
  || (oopClass == (interpreterProxy->classByteArray()))) {
  /* begin ffiPushPointer:in: */
- value = interpreterProxy->firstIndexableField(oop);
- error("shouldBeImplemented");
+ pointer1 = interpreterProxy->firstIndexableField(oop);
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), pointer1);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
  }
  if (isAlien) {
  /* begin ffiPushPointer:in: */
- value1 = pointerForOop(((longAt(oop + BaseHeaderSize)) > 0
+ pointer2 = pointerForOop(((longAt(oop + BaseHeaderSize)) > 0
  ? (oop + BaseHeaderSize) + BytesPerOop
  : longAt((oop + BaseHeaderSize) + BytesPerOop)));
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), pointer2);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
  }
  if (!(atomicType == FFITypeVoid)) {
@@ -975,8 +1012,12 @@
  || (atomicType == FFITypeSingleFloat)) {
  if (interpreterProxy->isWords(oop)) {
  /* begin ffiPushPointer:in: */
- value2 = interpreterProxy->firstIndexableField(oop);
- error("shouldBeImplemented");
+ pointer3 = interpreterProxy->firstIndexableField(oop);
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), pointer3);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
  }
  }
@@ -1062,17 +1103,155 @@
 }
 
 
-/* Perform the callout, collect the result and and create the return value.
- If a threaded call, disown and own VM around the call. If there are
- floating-point arguments that are passed in registers then call a dummy
- function to load them.
- This *must* be inlined because of the alloca of the outgoing stack frame
- in ffiCall:SpecOnStack:Flags:NumArgs:Args:AndTypes: */
+/* Go out, call this guy and create the return value. This *must* be inlined
+ because of
+ the alloca of the outgoing stack frame in
+ ffiCall:WithFlags:NumArgs:Args:AndTypes:
+ */
 
 static sqInt
-ffiCalloutToSpecOnStackin(void *procAddr, sqInt specOnStack, sqInt calloutState)
+ffiCalloutToSpecOnStackin(void *procAddr, sqInt specOnStack, CalloutState *calloutState)
 {
- subclassResponsibility();
+    sqInt argTypes;
+    sqInt argTypes1;
+    sqInt atomicType;
+    sqInt atomicType1;
+    sqInt classOop;
+    char *cString;
+    sqInt ffiRetType;
+    double floatRet;
+    sqInt i;
+    usqLong intRet;
+    sqInt oop;
+    sqInt oop1;
+    sqInt *ptr;
+    sqInt retClass;
+    sqInt retClass1;
+    sqInt retOop;
+    sqInt retOop1;
+    sqInt retType;
+    sqInt specLiteral;
+    sqInt specLiteral1;
+    sqInt strLen;
+    sqInt strOop;
+    char *strPtr;
+    sqInt typeSpec;
+    sqInt typeSpec1;
+
+ if ((0 + (cStackAlignment())) > 0) {
+ setsp((calloutState->argVector));
+ }
+ /* begin atomicTypeOf: */
+ typeSpec = (calloutState->ffiRetHeader);
+ atomicType = ((usqInt) (typeSpec & FFIAtomicTypeMask)) >> FFIAtomicTypeShift;
+ if ((atomicType == FFITypeSingleFloat)
+ || (atomicType == FFITypeDoubleFloat)) {
+ floatRet = dispatchFunctionPointer(((double (*)()) procAddr));
+ }
+ else {
+ intRet = dispatchFunctionPointer(((usqLong (*)()) procAddr));
+ }
+ if (isCalleePopsConvention((calloutState->callFlags))) {
+ setsp((calloutState->argVector));
+ }
+ if (((calloutState->ffiRetHeader)) & FFIFlagPointer) {
+ /* begin ffiReturnPointer:ofType:in: */
+ /* begin ffiReturnType: */
+ specLiteral1 = (specOnStack
+ ? interpreterProxy->stackValue(1)
+ : interpreterProxy->literalofMethod(0, interpreterProxy->primitiveMethod()));
+ argTypes1 = interpreterProxy->fetchPointerofObject(ExternalFunctionArgTypesIndex, specLiteral1);
+ retType = interpreterProxy->fetchPointerofObject(0, argTypes1);
+ retClass1 = interpreterProxy->fetchPointerofObject(1, retType);
+ if (retClass1 == (interpreterProxy->nilObject())) {
+ /* begin atomicTypeOf: */
+ typeSpec1 = (calloutState->ffiRetHeader);
+ atomicType1 = ((usqInt) (typeSpec1 & FFIAtomicTypeMask)) >> FFIAtomicTypeShift;
+ if ((((usqInt) atomicType1) >> 1) == (((usqInt) FFITypeSignedChar) >> 1)) {
+ /* begin ffiReturnCStringFrom: */
+ if ((((usqInt) intRet)) == null) {
+ return interpreterProxy->methodReturnValue(interpreterProxy->nilObject());
+ }
+ cString = ((char *) (((usqInt) intRet)));
+ strLen = 0;
+ while (!((cString[strLen]) == 0)) {
+ strLen += 1;
+ }
+ strOop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classString(), strLen);
+ strPtr = interpreterProxy->firstIndexableField(strOop);
+ for (i = 0; i <= (strLen - 1); i += 1) {
+ strPtr[i] = (cString[i]);
+ }
+ return interpreterProxy->methodReturnValue(strOop);
+ }
+ interpreterProxy->pushRemappableOop(retType);
+ oop1 = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classExternalAddress(), 4);
+ ptr = interpreterProxy->firstIndexableField(oop1);
+ ptr[0] = (((sqInt) intRet));
+ interpreterProxy->pushRemappableOop(oop1);
+ retOop1 = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classExternalData(), 0);
+
+ /* external address */
+
+ oop1 = interpreterProxy->popRemappableOop();
+ interpreterProxy->storePointerofObjectwithValue(0, retOop1, oop1);
+
+ /* return type */
+
+ oop1 = interpreterProxy->popRemappableOop();
+ interpreterProxy->storePointerofObjectwithValue(1, retOop1, oop1);
+ return interpreterProxy->methodReturnValue(retOop1);
+ }
+ interpreterProxy->pushRemappableOop(retClass1);
+ if (((calloutState->ffiRetHeader)) & FFIFlagStructure) {
+ classOop = interpreterProxy->classByteArray();
+ }
+ else {
+ classOop = interpreterProxy->classExternalAddress();
+ }
+ oop1 = interpreterProxy->instantiateClassindexableSize(classOop, 4);
+ ptr = interpreterProxy->firstIndexableField(oop1);
+ ptr[0] = (((sqInt) intRet));
+
+ /* return class */
+
+ retClass1 = interpreterProxy->popRemappableOop();
+ interpreterProxy->pushRemappableOop(oop1);
+ retOop1 = interpreterProxy->instantiateClassindexableSize(retClass1, 0);
+
+ /* external address */
+
+ oop1 = interpreterProxy->popRemappableOop();
+ interpreterProxy->storePointerofObjectwithValue(0, retOop1, oop1);
+ return interpreterProxy->methodReturnValue(retOop1);
+ }
+ if (((calloutState->ffiRetHeader)) & FFIFlagStructure) {
+ /* begin ffiReturnStruct:ofType:in: */
+ /* begin ffiReturnType: */
+ specLiteral = (specOnStack
+ ? interpreterProxy->stackValue(1)
+ : interpreterProxy->literalofMethod(0, interpreterProxy->primitiveMethod()));
+ argTypes = interpreterProxy->fetchPointerofObject(ExternalFunctionArgTypesIndex, specLiteral);
+ ffiRetType = interpreterProxy->fetchPointerofObject(0, argTypes);
+ retClass = interpreterProxy->fetchPointerofObject(1, ffiRetType);
+ retOop = interpreterProxy->instantiateClassindexableSize(retClass, 0);
+ interpreterProxy->pushRemappableOop(retOop);
+ oop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classByteArray(), (calloutState->structReturnSize));
+ if (returnStructInRegisters((calloutState->structReturnSize))) {
+ memcpy(interpreterProxy->firstIndexableField(oop), (&intRet), (calloutState->structReturnSize));
+ }
+ else {
+ memcpy(interpreterProxy->firstIndexableField(oop), (calloutState->limit), (calloutState->structReturnSize));
+ }
+ retOop = interpreterProxy->popRemappableOop();
+ interpreterProxy->storePointerofObjectwithValue(0, retOop, oop);
+ return interpreterProxy->methodReturnValue(retOop);
+ }
+ if ((atomicType == FFITypeSingleFloat)
+ || (atomicType == FFITypeDoubleFloat)) {
+ return interpreterProxy->methodReturnValue(interpreterProxy->floatObjectOf(floatRet));
+ }
+ return interpreterProxy->methodReturnValue(ffiCreateIntegralResultOopofAtomicTypein(intRet, atomicType, calloutState));
 }
 
 
@@ -1092,18 +1271,43 @@
     sqInt argSpec;
     sqInt argType;
     sqInt argTypeArray;
+    sqInt argTypes;
+    sqInt argTypes1;
+    sqInt atomicType;
+    sqInt atomicType1;
     CalloutState *calloutState;
+    sqInt classOop;
+    char *cString;
     sqInt err;
+    sqInt ffiRetType;
     sqInt flags;
+    double floatRet;
     sqInt functionName;
     sqInt i;
+    sqInt i1;
+    usqLong intRet;
     sqInt oop;
+    sqInt oop1;
+    sqInt oop2;
+    void *pointer;
     int *ptr;
+    sqInt *ptr1;
     sqInt requiredStackSize;
     sqInt result;
+    sqInt retClass;
+    sqInt retClass1;
+    sqInt retOop;
+    sqInt retOop1;
+    sqInt retType;
+    sqInt specLiteral;
+    sqInt specLiteral1;
     sqInt stackSize;
+    sqInt strLen;
+    sqInt strOop;
+    char *strPtr;
     CalloutState theCalloutState;
-    sqInt value;
+    sqInt typeSpec;
+    sqInt typeSpec1;
 
  if (!(interpreterProxy->isKindOfClass(externalFunction, interpreterProxy->classExternalFunction()))) {
  return ffiFail(FFIErrorNotFunction);
@@ -1132,21 +1336,21 @@
  /* begin ffiContentsOfHandle:errCode: */
  if ((addressPtr & 1)) {
  address1 = ffiFail(FFIErrorBadAddress);
- goto l2;
+ goto l3;
  }
  if (!(interpreterProxy->isBytes(addressPtr))) {
  address1 = ffiFail(FFIErrorBadAddress);
- goto l2;
+ goto l3;
  }
  if (!((interpreterProxy->byteSizeOf(addressPtr)) == 4)) {
  address1 = ffiFail(FFIErrorBadAddress);
- goto l2;
+ goto l3;
  }
  address1 = interpreterProxy->fetchPointerofObject(0, addressPtr);
-l2: /* end ffiContentsOfHandle:errCode: */;
+l3: /* end ffiContentsOfHandle:errCode: */;
  if (interpreterProxy->failed()) {
  address = 0;
- goto l3;
+ goto l4;
  }
  if (address1 == 0) {
  if (externalFunctionInstSize > ExternalFunctionStackSizeIndex) {
@@ -1154,18 +1358,18 @@
  }
  if ((interpreterProxy->slotSizeOf(externalFunction)) < 5) {
  address = ffiFail(FFIErrorNoModule);
- goto l3;
+ goto l4;
  }
  address1 = ffiLoadCalloutAddressFrom(externalFunction);
  if (interpreterProxy->failed()) {
  address = 0;
- goto l3;
+ goto l4;
  }
  ptr = interpreterProxy->firstIndexableField(addressPtr);
  ptr[0] = address1;
  }
  address = address1;
-l3: /* end ffiLoadCalloutAddress: */;
+l4: /* end ffiLoadCalloutAddress: */;
  if (interpreterProxy->failed()) {
  return 0;
  }
@@ -1205,8 +1409,13 @@
  && (1
  && (!(returnStructInRegisters((calloutState->structReturnSize)))))) {
  /* begin ffiPushPointer:in: */
- value = (calloutState->limit);
- error("shouldBeImplemented");
+ pointer = (calloutState->limit);
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ goto l1;
+ }
+ longAtput((calloutState->currentArg), pointer);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
+ l1: /* end ffiPushPointer:in: */;
  }
  for (i = 1; i <= nArgs; i += 1) {
  argType = interpreterProxy->fetchPointerofObject(i, argTypeArray);
@@ -1221,9 +1430,6 @@
  while (((calloutState->stringArgIndex)) > 0) {
  free(((calloutState->stringArgs))[(calloutState->stringArgIndex = ((calloutState->stringArgIndex)) - 1)]);
  }
- if (err == (-PrimErrObjectMayMove)) {
- return PrimErrObjectMayMove;
- }
  return ffiFail(err);
  }
  }
@@ -1232,18 +1438,138 @@
  if (ffiLogEnabled) {
  functionName = interpreterProxy->fetchPointerofObject(externalFunctionInstSize, externalFunction);
  if (!(interpreterProxy->isBytes(functionName))) {
- goto l1;
+ goto l2;
  }
  ffiLogCallOfLength(interpreterProxy->firstIndexableField(functionName), interpreterProxy->byteSizeOf(functionName));
  }
-l1: /* end ffiLogCallout: */;
+l2: /* end ffiLogCallout: */;
  if ((requiredStackSize < 0)
  && (externalFunctionInstSize > ExternalFunctionStackSizeIndex)) {
  stackSize = ((calloutState->currentArg)) - ((calloutState->argVector));
  interpreterProxy->storeIntegerofObjectwithValue(ExternalFunctionStackSizeIndex, externalFunction, stackSize);
  }
  /* begin ffiCalloutTo:SpecOnStack:in: */
- subclassResponsibility();
+ if ((0 + (cStackAlignment())) > 0) {
+ setsp((calloutState->argVector));
+ }
+ /* begin atomicTypeOf: */
+ typeSpec = (calloutState->ffiRetHeader);
+ atomicType = ((usqInt) (typeSpec & FFIAtomicTypeMask)) >> FFIAtomicTypeShift;
+ if ((atomicType == FFITypeSingleFloat)
+ || (atomicType == FFITypeDoubleFloat)) {
+ floatRet = dispatchFunctionPointer(((double (*)()) address));
+ }
+ else {
+ intRet = dispatchFunctionPointer(((usqLong (*)()) address));
+ }
+ if (isCalleePopsConvention((calloutState->callFlags))) {
+ setsp((calloutState->argVector));
+ }
+ if (((calloutState->ffiRetHeader)) & FFIFlagPointer) {
+ /* begin ffiReturnPointer:ofType:in: */
+ /* begin ffiReturnType: */
+ specLiteral1 = (argArrayOrNil != null
+ ? interpreterProxy->stackValue(1)
+ : interpreterProxy->literalofMethod(0, interpreterProxy->primitiveMethod()));
+ argTypes1 = interpreterProxy->fetchPointerofObject(ExternalFunctionArgTypesIndex, specLiteral1);
+ retType = interpreterProxy->fetchPointerofObject(0, argTypes1);
+ retClass1 = interpreterProxy->fetchPointerofObject(1, retType);
+ if (retClass1 == (interpreterProxy->nilObject())) {
+ /* begin atomicTypeOf: */
+ typeSpec1 = (calloutState->ffiRetHeader);
+ atomicType1 = ((usqInt) (typeSpec1 & FFIAtomicTypeMask)) >> FFIAtomicTypeShift;
+ if ((((usqInt) atomicType1) >> 1) == (((usqInt) FFITypeSignedChar) >> 1)) {
+ /* begin ffiReturnCStringFrom: */
+ if ((((usqInt) intRet)) == null) {
+ result = interpreterProxy->methodReturnValue(interpreterProxy->nilObject());
+ goto l5;
+ }
+ cString = ((char *) (((usqInt) intRet)));
+ strLen = 0;
+ while (!((cString[strLen]) == 0)) {
+ strLen += 1;
+ }
+ strOop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classString(), strLen);
+ strPtr = interpreterProxy->firstIndexableField(strOop);
+ for (i1 = 0; i1 <= (strLen - 1); i1 += 1) {
+ strPtr[i1] = (cString[i1]);
+ }
+ result = interpreterProxy->methodReturnValue(strOop);
+ goto l5;
+ }
+ interpreterProxy->pushRemappableOop(retType);
+ oop1 = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classExternalAddress(), 4);
+ ptr1 = interpreterProxy->firstIndexableField(oop1);
+ ptr1[0] = (((sqInt) intRet));
+ interpreterProxy->pushRemappableOop(oop1);
+ retOop1 = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classExternalData(), 0);
+
+ /* external address */
+
+ oop1 = interpreterProxy->popRemappableOop();
+ interpreterProxy->storePointerofObjectwithValue(0, retOop1, oop1);
+
+ /* return type */
+
+ oop1 = interpreterProxy->popRemappableOop();
+ interpreterProxy->storePointerofObjectwithValue(1, retOop1, oop1);
+ result = interpreterProxy->methodReturnValue(retOop1);
+ goto l5;
+ }
+ interpreterProxy->pushRemappableOop(retClass1);
+ if (((calloutState->ffiRetHeader)) & FFIFlagStructure) {
+ classOop = interpreterProxy->classByteArray();
+ }
+ else {
+ classOop = interpreterProxy->classExternalAddress();
+ }
+ oop1 = interpreterProxy->instantiateClassindexableSize(classOop, 4);
+ ptr1 = interpreterProxy->firstIndexableField(oop1);
+ ptr1[0] = (((sqInt) intRet));
+
+ /* return class */
+
+ retClass1 = interpreterProxy->popRemappableOop();
+ interpreterProxy->pushRemappableOop(oop1);
+ retOop1 = interpreterProxy->instantiateClassindexableSize(retClass1, 0);
+
+ /* external address */
+
+ oop1 = interpreterProxy->popRemappableOop();
+ interpreterProxy->storePointerofObjectwithValue(0, retOop1, oop1);
+ result = interpreterProxy->methodReturnValue(retOop1);
+ goto l5;
+ }
+ if (((calloutState->ffiRetHeader)) & FFIFlagStructure) {
+ /* begin ffiReturnStruct:ofType:in: */
+ /* begin ffiReturnType: */
+ specLiteral = (argArrayOrNil != null
+ ? interpreterProxy->stackValue(1)
+ : interpreterProxy->literalofMethod(0, interpreterProxy->primitiveMethod()));
+ argTypes = interpreterProxy->fetchPointerofObject(ExternalFunctionArgTypesIndex, specLiteral);
+ ffiRetType = interpreterProxy->fetchPointerofObject(0, argTypes);
+ retClass = interpreterProxy->fetchPointerofObject(1, ffiRetType);
+ retOop = interpreterProxy->instantiateClassindexableSize(retClass, 0);
+ interpreterProxy->pushRemappableOop(retOop);
+ oop2 = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classByteArray(), (calloutState->structReturnSize));
+ if (returnStructInRegisters((calloutState->structReturnSize))) {
+ memcpy(interpreterProxy->firstIndexableField(oop2), (&intRet), (calloutState->structReturnSize));
+ }
+ else {
+ memcpy(interpreterProxy->firstIndexableField(oop2), (calloutState->limit), (calloutState->structReturnSize));
+ }
+ retOop = interpreterProxy->popRemappableOop();
+ interpreterProxy->storePointerofObjectwithValue(0, retOop, oop2);
+ result = interpreterProxy->methodReturnValue(retOop);
+ goto l5;
+ }
+ if ((atomicType == FFITypeSingleFloat)
+ || (atomicType == FFITypeDoubleFloat)) {
+ result = interpreterProxy->methodReturnValue(interpreterProxy->floatObjectOf(floatRet));
+ goto l5;
+ }
+ result = interpreterProxy->methodReturnValue(ffiCreateIntegralResultOopofAtomicTypein(intRet, atomicType, calloutState));
+l5: /* end ffiCalloutTo:SpecOnStack:in: */;
  /* begin cleanupCalloutState: */
  while (((calloutState->stringArgIndex)) > 0) {
  free(((calloutState->stringArgs))[(calloutState->stringArgIndex = ((calloutState->stringArgIndex)) - 1)]);
@@ -1700,9 +2026,13 @@
 }
 
 static sqInt
-ffiPushDoubleFloatin(sqInt value, sqInt calloutState)
+ffiPushDoubleFloatin(double value, CalloutState *calloutState)
 {
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 8) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ storeFloatAtPointerfrom((calloutState->currentArg), value);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 8);
  return 0;
 }
 
@@ -1725,60 +2055,80 @@
  return FFIErrorInvalidPointer;
  }
  /* begin ffiPushPointer:in: */
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), ptrAddress);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
  }
  if (ptrClass == (interpreterProxy->classByteArray())) {
- if ((((calloutState->callFlags)) & FFICallFlagThreaded)
- && (interpreterProxy->isYoung(oop))) {
- return -PrimErrObjectMayMove;
- }
  ptrAddress = ((int) (interpreterProxy->firstIndexableField(oop)));
  /* begin ffiPushPointer:in: */
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), ptrAddress);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
  }
  if (interpreterProxy->includesBehaviorThatOf(ptrClass, interpreterProxy->classAlien())) {
- if ((((calloutState->callFlags)) & FFICallFlagThreaded)
- && ((isDirectAlien(oop))
- && (interpreterProxy->isYoung(oop)))) {
- return -PrimErrObjectMayMove;
- }
  ptrAddress = ((longAt(oop + BaseHeaderSize)) > 0
  ? (oop + BaseHeaderSize) + BytesPerOop
  : longAt((oop + BaseHeaderSize) + BytesPerOop));
  /* begin ffiPushPointer:in: */
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), ptrAddress);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
  }
  return FFIErrorBadArg;
 }
 
 static sqInt
-ffiPushPointerin(sqInt value, CalloutState *calloutState)
+ffiPushPointerin(void *pointer, CalloutState *calloutState)
 {
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), pointer);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
 }
 
 static sqInt
 ffiPushSignedBytein(sqInt value, CalloutState *calloutState)
 {
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), ((signed char) value));
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
 }
 
 static sqInt
 ffiPushSignedCharin(sqInt value, CalloutState *calloutState)
 {
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), ((signed char) value));
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
 }
 
 static sqInt
 ffiPushSignedIntin(sqInt value, CalloutState *calloutState)
 {
- subclassResponsibility();
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), value);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
+ return 0;
 }
 
 
@@ -1806,28 +2156,46 @@
  }
  }
  /* begin ffiPushSignedLongLong:in: */
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 8) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), ((usqInt) value));
+ longAtput(((calloutState->currentArg)) + 4, ((usqInt) (((unsigned sqLong )value) >> 32)));
+ (calloutState->currentArg = ((calloutState->currentArg)) + 8);
  return 0;
 }
 
 static sqInt
-ffiPushSignedLongLongin(sqLong value, CalloutState *calloutState)
+ffiPushSignedLongLongin(usqLong value, CalloutState *calloutState)
 {
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 8) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), ((usqInt) value));
+ longAtput(((calloutState->currentArg)) + 4, ((usqInt) (value >> 32)));
+ (calloutState->currentArg = ((calloutState->currentArg)) + 8);
  return 0;
 }
 
 static sqInt
 ffiPushSignedShortin(sqInt value, CalloutState *calloutState)
 {
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), ((signed short) value));
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
 }
 
 static sqInt
-ffiPushSingleFloatin(sqInt value, CalloutState *calloutState)
+ffiPushSingleFloatin(float value, CalloutState *calloutState)
 {
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ storeSingleFloatAtPointerfrom((calloutState->currentArg), value);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
 }
 
@@ -1848,7 +2216,11 @@
  ((calloutState->stringArgs))[(calloutState->stringArgIndex)] = copy;
  (calloutState->stringArgIndex = ((calloutState->stringArgIndex)) + 1);
  /* begin ffiPushPointer:in: */
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), copy);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
 }
 
@@ -1864,6 +2236,8 @@
     sqInt argSpecSize1;
     sqInt ptrAddress;
     sqInt ptrClass;
+    sqInt roundedSize;
+    sqInt roundedSize1;
     sqInt structSize;
     sqInt structSize1;
 
@@ -1882,8 +2256,13 @@
  structSize = ((calloutState->ffiArgHeader)) & FFIStructSizeMask;
  argSpec = (calloutState->ffiArgSpec);
  argSpecSize = (calloutState->ffiArgSpecSize);
- subclassResponsibility();
- return null;
+ roundedSize = (structSize + 3) & (~3);
+ if ((((calloutState->currentArg)) + roundedSize) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ memcpy((calloutState->currentArg), ((void *) ptrAddress), structSize);
+ (calloutState->currentArg = ((calloutState->currentArg)) + roundedSize);
+ return 0;
  }
  if (ptrClass == (interpreterProxy->classByteArray())) {
  if (!((interpreterProxy->byteSizeOf(oop)) == (((calloutState->ffiArgHeader)) & FFIStructSizeMask))) {
@@ -1891,16 +2270,17 @@
  }
  ptrAddress = ((int) (interpreterProxy->firstIndexableField(oop)));
  if (!(((calloutState->ffiArgHeader)) & FFIFlagPointer)) {
- if ((((calloutState->callFlags)) & FFICallFlagThreaded)
- && (interpreterProxy->isYoung(oop))) {
- return -PrimErrObjectMayMove;
- }
  /* begin ffiPushStructure:ofSize:typeSpec:ofLength:in: */
  structSize1 = ((calloutState->ffiArgHeader)) & FFIStructSizeMask;
  argSpec1 = (calloutState->ffiArgSpec);
  argSpecSize1 = (calloutState->ffiArgSpecSize);
- subclassResponsibility();
- return null;
+ roundedSize1 = (structSize1 + 3) & (~3);
+ if ((((calloutState->currentArg)) + roundedSize1) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ memcpy((calloutState->currentArg), ((void *) ptrAddress), structSize1);
+ (calloutState->currentArg = ((calloutState->currentArg)) + roundedSize1);
+ return 0;
  }
  if (!((((calloutState->ffiArgHeader)) & FFIStructSizeMask) == 4)) {
  return FFIErrorStructSize;
@@ -1910,7 +2290,11 @@
  return FFIErrorInvalidPointer;
  }
  /* begin ffiPushPointer:in: */
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), ptrAddress);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
  }
  return FFIErrorBadArg;
@@ -1919,27 +2303,48 @@
 static sqInt
 ffiPushStructureofSizetypeSpecofLengthin(void *pointer, sqInt structSize, sqInt *argSpec, sqInt argSpecSize, CalloutState *calloutState)
 {
- subclassResponsibility();
+    sqInt roundedSize;
+
+ roundedSize = (structSize + 3) & (~3);
+ if ((((calloutState->currentArg)) + roundedSize) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ memcpy((calloutState->currentArg), pointer, structSize);
+ (calloutState->currentArg = ((calloutState->currentArg)) + roundedSize);
+ return 0;
 }
 
 static sqInt
 ffiPushUnsignedBytein(sqInt value, CalloutState *calloutState)
 {
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), ((unsigned char) value));
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
 }
 
 static sqInt
 ffiPushUnsignedCharin(sqInt value, CalloutState *calloutState)
 {
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), ((unsigned char) value));
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
 }
 
 static sqInt
 ffiPushUnsignedIntin(sqInt value, CalloutState *calloutState)
 {
- subclassResponsibility();
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), value);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
+ return 0;
 }
 
 
@@ -1967,28 +2372,35 @@
  }
  }
  /* begin ffiPushUnsignedLongLong:in: */
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 8) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), ((usqInt) value));
+ longAtput(((calloutState->currentArg)) + 4, ((usqInt) (value >> 32)));
+ (calloutState->currentArg = ((calloutState->currentArg)) + 8);
  return 0;
 }
 
 static sqInt
 ffiPushUnsignedLongLongin(usqLong value, CalloutState *calloutState)
 {
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 8) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), ((usqInt) value));
+ longAtput(((calloutState->currentArg)) + 4, ((usqInt) (value >> 32)));
+ (calloutState->currentArg = ((calloutState->currentArg)) + 8);
  return 0;
 }
 
 static sqInt
-ffiPushUnsignedLongin(sqInt value, CalloutState *calloutState)
-{
- error("shouldBeImplemented");
- return 0;
-}
-
-static sqInt
 ffiPushUnsignedShortin(sqInt value, CalloutState *calloutState)
 {
- error("shouldBeImplemented");
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ return FFIErrorCallFrameTooBig;
+ }
+ longAtput((calloutState->currentArg), ((unsigned short) value));
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
  return 0;
 }
 
@@ -2122,9 +2534,25 @@
  alloca'ed space pointed to by the calloutState. */
 
 static sqInt
-ffiReturnStructofTypein(usqLong longLongRet, sqInt ffiRetClass, CalloutState *calloutState)
+ffiReturnStructofTypein(usqLong longLongRet, sqInt ffiRetType, CalloutState *calloutState)
 {
- subclassResponsibility();
+    sqInt oop;
+    sqInt retClass;
+    sqInt retOop;
+
+ retClass = interpreterProxy->fetchPointerofObject(1, ffiRetType);
+ retOop = interpreterProxy->instantiateClassindexableSize(retClass, 0);
+ interpreterProxy->pushRemappableOop(retOop);
+ oop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classByteArray(), (calloutState->structReturnSize));
+ if (returnStructInRegisters((calloutState->structReturnSize))) {
+ memcpy(interpreterProxy->firstIndexableField(oop), (&longLongRet), (calloutState->structReturnSize));
+ }
+ else {
+ memcpy(interpreterProxy->firstIndexableField(oop), (calloutState->limit), (calloutState->structReturnSize));
+ }
+ retOop = interpreterProxy->popRemappableOop();
+ interpreterProxy->storePointerofObjectwithValue(0, retOop, oop);
+ return interpreterProxy->methodReturnValue(retOop);
 }
 
 
@@ -2255,16 +2683,6 @@
  return 1;
 }
 
-static void
-initialize(CalloutState * self_in_initialize)
-{
- (self_in_initialize->stringArgs) = on(CArrayAccessor, new(Array, maxNumArgs(ThreadedFFIPlugin)));
- (self_in_initialize->stringArgIndex) = 0;
- (self_in_initialize->structReturnSize) = 0;
- (self_in_initialize->regIndex) = 0;
- (self_in_initialize->integerRegisters) = on(CArrayAccessor, new(Array, numRegArgs(ThreadedARMFFIPlugin)));
-}
-
 static sqInt
 isAlien(sqInt anOop)
 {
@@ -2312,22 +2730,335 @@
 EXPORT(void)
 primitiveCallout(void)
 {
+    sqInt address;
+    sqInt address1;
+    sqInt addressPtr;
+    char *allocation;
+    sqInt argClass;
+    sqInt argSpec;
+    sqInt argType;
+    sqInt argTypeArray;
+    sqInt argTypes;
+    sqInt argTypes1;
+    sqInt atomicType;
+    sqInt atomicType1;
+    CalloutState *calloutState;
+    sqInt classOop;
+    char *cString;
+    sqInt err;
     sqInt externalFunction;
+    sqInt ffiRetType;
+    sqInt flags;
+    double floatRet;
+    sqInt functionName;
+    sqInt i;
+    sqInt i1;
+    usqLong intRet;
     sqInt meth;
     sqInt nArgs;
-    sqInt retryCount;
+    sqInt oop;
+    sqInt oop1;
+    sqInt oop2;
+    void *pointer;
+    int *ptr;
+    sqInt *ptr1;
+    sqInt requiredStackSize;
+    sqInt result;
+    sqInt retClass;
+    sqInt retClass1;
+    sqInt retOop;
+    sqInt retOop1;
+    sqInt retType;
+    sqInt specLiteral;
+    sqInt specLiteral1;
+    sqInt stackSize;
+    sqInt strLen;
+    sqInt strOop;
+    char *strPtr;
+    CalloutState theCalloutState;
+    sqInt typeSpec;
+    sqInt typeSpec1;
 
  meth = interpreterProxy->primitiveMethod();
  if (!((interpreterProxy->literalCountOf(meth)) > 0)) {
  interpreterProxy->primitiveFailFor(PrimErrBadMethod); return;
  }
  externalFunction = interpreterProxy->literalofMethod(0, meth);
+ /* begin ffiCall:ArgArrayOrNil:NumArgs: */
  nArgs = interpreterProxy->methodArgumentCount();
- retryCount = 0;
- while (((ffiCallArgArrayOrNilNumArgs(externalFunction, null, nArgs)) == PrimErrObjectMayMove)
- && (((retryCount += 1)) <= nArgs)) {
- interpreterProxy->tenuringIncrementalGC();
+ if (!(interpreterProxy->isKindOfClass(externalFunction, interpreterProxy->classExternalFunction()))) {
+ ffiFail(FFIErrorNotFunction);
+ goto l3;
  }
+ flags = interpreterProxy->fetchIntegerofObject(ExternalFunctionFlagsIndex, externalFunction);
+ if (interpreterProxy->failed()) {
+ ffiFail(FFIErrorBadArgs);
+ goto l3;
+ }
+
+ /* must be array of arg types */
+
+ argTypeArray = interpreterProxy->fetchPointerofObject(ExternalFunctionArgTypesIndex, externalFunction);
+ if (!((interpreterProxy->isArray(argTypeArray))
+ && ((interpreterProxy->slotSizeOf(argTypeArray)) == (nArgs + 1)))) {
+ ffiFail(FFIErrorBadArgs);
+ goto l3;
+ }
+ if (!(1)) {
+ ffiFail(FFIErrorCallType);
+ goto l3;
+ }
+ /* begin ffiLoadCalloutAddress: */
+
+ /* Lookup the address */
+ /* Make sure it's an external handle */
+
+ addressPtr = interpreterProxy->fetchPointerofObject(0, externalFunction);
+ /* begin ffiContentsOfHandle:errCode: */
+ if ((addressPtr & 1)) {
+ address1 = ffiFail(FFIErrorBadAddress);
+ goto l4;
+ }
+ if (!(interpreterProxy->isBytes(addressPtr))) {
+ address1 = ffiFail(FFIErrorBadAddress);
+ goto l4;
+ }
+ if (!((interpreterProxy->byteSizeOf(addressPtr)) == 4)) {
+ address1 = ffiFail(FFIErrorBadAddress);
+ goto l4;
+ }
+ address1 = interpreterProxy->fetchPointerofObject(0, addressPtr);
+l4: /* end ffiContentsOfHandle:errCode: */;
+ if (interpreterProxy->failed()) {
+ address = 0;
+ goto l5;
+ }
+ if (address1 == 0) {
+ if (externalFunctionInstSize > ExternalFunctionStackSizeIndex) {
+ interpreterProxy->storePointerofObjectwithValue(ExternalFunctionStackSizeIndex, externalFunction, ((-1 << 1) | 1));
+ }
+ if ((interpreterProxy->slotSizeOf(externalFunction)) < 5) {
+ address = ffiFail(FFIErrorNoModule);
+ goto l5;
+ }
+ address1 = ffiLoadCalloutAddressFrom(externalFunction);
+ if (interpreterProxy->failed()) {
+ address = 0;
+ goto l5;
+ }
+ ptr = interpreterProxy->firstIndexableField(addressPtr);
+ ptr[0] = address1;
+ }
+ address = address1;
+l5: /* end ffiLoadCalloutAddress: */;
+ if (interpreterProxy->failed()) {
+ goto l3;
+ }
+ requiredStackSize = (externalFunctionInstSize > ExternalFunctionStackSizeIndex
+ ? interpreterProxy->fetchIntegerofObject(ExternalFunctionStackSizeIndex, externalFunction)
+ : -1);
+ if (interpreterProxy->failed()) {
+ interpreterProxy->primitiveFailFor((null == null
+ ? PrimErrBadMethod
+ : PrimErrBadReceiver));
+ goto l3;
+ }
+ stackSize = (requiredStackSize < 0
+ ? DefaultMaxStackSize
+ : requiredStackSize);
+ null;
+ calloutState = (&theCalloutState);
+ memset(calloutState, 0, sizeof(CalloutState));
+;
+ (calloutState->callFlags = flags);
+ argType = interpreterProxy->fetchPointerofObject(0, argTypeArray);
+ argSpec = interpreterProxy->fetchPointerofObject(0, argType);
+ argClass = interpreterProxy->fetchPointerofObject(1, argType);
+ if (((err = ffiCheckReturnWithin(argSpec, argClass, calloutState))) != 0) {
+ ffiFail(err);
+ goto l3;
+ }
+ allocation = alloca(((stackSize + ((calloutState->structReturnSize))) + 0) + (cStackAlignment()));
+ if (allocaLiesSoUseGetsp()) {
+ allocation = getsp();
+ }
+ if ((cStackAlignment()) != 0) {
+ allocation = ((char *) ((((usqInt)allocation)) & (~((cStackAlignment()) - 1))));
+ }
+ (calloutState->argVector = allocation);
+ (calloutState->currentArg = allocation + 0);
+ (calloutState->limit = (allocation + stackSize) + 0);
+ if ((((calloutState->structReturnSize)) > 0)
+ && (1
+ && (!(returnStructInRegisters((calloutState->structReturnSize)))))) {
+ /* begin ffiPushPointer:in: */
+ pointer = (calloutState->limit);
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ goto l1;
+ }
+ longAtput((calloutState->currentArg), pointer);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
+ l1: /* end ffiPushPointer:in: */;
+ }
+ for (i = 1; i <= nArgs; i += 1) {
+ argType = interpreterProxy->fetchPointerofObject(i, argTypeArray);
+ argSpec = interpreterProxy->fetchPointerofObject(0, argType);
+ argClass = interpreterProxy->fetchPointerofObject(1, argType);
+ oop = (null == null
+ ? interpreterProxy->stackValue(nArgs - i)
+ : interpreterProxy->fetchPointerofObject(i - 1, null));
+ err = ffiArgumentSpecClassin(oop, argSpec, argClass, calloutState);
+ if (err != 0) {
+ /* begin cleanupCalloutState: */
+ while (((calloutState->stringArgIndex)) > 0) {
+ free(((calloutState->stringArgs))[(calloutState->stringArgIndex = ((calloutState->stringArgIndex)) - 1)]);
+ }
+ ffiFail(err);
+ goto l3;
+ }
+ }
+ assert(!(interpreterProxy->failed()));
+ /* begin ffiLogCallout: */
+ if (ffiLogEnabled) {
+ functionName = interpreterProxy->fetchPointerofObject(externalFunctionInstSize, externalFunction);
+ if (!(interpreterProxy->isBytes(functionName))) {
+ goto l2;
+ }
+ ffiLogCallOfLength(interpreterProxy->firstIndexableField(functionName), interpreterProxy->byteSizeOf(functionName));
+ }
+l2: /* end ffiLogCallout: */;
+ if ((requiredStackSize < 0)
+ && (externalFunctionInstSize > ExternalFunctionStackSizeIndex)) {
+ stackSize = ((calloutState->currentArg)) - ((calloutState->argVector));
+ interpreterProxy->storeIntegerofObjectwithValue(ExternalFunctionStackSizeIndex, externalFunction, stackSize);
+ }
+ /* begin ffiCalloutTo:SpecOnStack:in: */
+ if ((0 + (cStackAlignment())) > 0) {
+ setsp((calloutState->argVector));
+ }
+ /* begin atomicTypeOf: */
+ typeSpec = (calloutState->ffiRetHeader);
+ atomicType = ((usqInt) (typeSpec & FFIAtomicTypeMask)) >> FFIAtomicTypeShift;
+ if ((atomicType == FFITypeSingleFloat)
+ || (atomicType == FFITypeDoubleFloat)) {
+ floatRet = dispatchFunctionPointer(((double (*)()) address));
+ }
+ else {
+ intRet = dispatchFunctionPointer(((usqLong (*)()) address));
+ }
+ if (isCalleePopsConvention((calloutState->callFlags))) {
+ setsp((calloutState->argVector));
+ }
+ if (((calloutState->ffiRetHeader)) & FFIFlagPointer) {
+ /* begin ffiReturnPointer:ofType:in: */
+ /* begin ffiReturnType: */
+ specLiteral1 = (null != null
+ ? interpreterProxy->stackValue(1)
+ : interpreterProxy->literalofMethod(0, interpreterProxy->primitiveMethod()));
+ argTypes1 = interpreterProxy->fetchPointerofObject(ExternalFunctionArgTypesIndex, specLiteral1);
+ retType = interpreterProxy->fetchPointerofObject(0, argTypes1);
+ retClass1 = interpreterProxy->fetchPointerofObject(1, retType);
+ if (retClass1 == (interpreterProxy->nilObject())) {
+ /* begin atomicTypeOf: */
+ typeSpec1 = (calloutState->ffiRetHeader);
+ atomicType1 = ((usqInt) (typeSpec1 & FFIAtomicTypeMask)) >> FFIAtomicTypeShift;
+ if ((((usqInt) atomicType1) >> 1) == (((usqInt) FFITypeSignedChar) >> 1)) {
+ /* begin ffiReturnCStringFrom: */
+ if ((((usqInt) intRet)) == null) {
+ result = interpreterProxy->methodReturnValue(interpreterProxy->nilObject());
+ goto l6;
+ }
+ cString = ((char *) (((usqInt) intRet)));
+ strLen = 0;
+ while (!((cString[strLen]) == 0)) {
+ strLen += 1;
+ }
+ strOop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classString(), strLen);
+ strPtr = interpreterProxy->firstIndexableField(strOop);
+ for (i1 = 0; i1 <= (strLen - 1); i1 += 1) {
+ strPtr[i1] = (cString[i1]);
+ }
+ result = interpreterProxy->methodReturnValue(strOop);
+ goto l6;
+ }
+ interpreterProxy->pushRemappableOop(retType);
+ oop1 = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classExternalAddress(), 4);
+ ptr1 = interpreterProxy->firstIndexableField(oop1);
+ ptr1[0] = (((sqInt) intRet));
+ interpreterProxy->pushRemappableOop(oop1);
+ retOop1 = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classExternalData(), 0);
+
+ /* external address */
+
+ oop1 = interpreterProxy->popRemappableOop();
+ interpreterProxy->storePointerofObjectwithValue(0, retOop1, oop1);
+
+ /* return type */
+
+ oop1 = interpreterProxy->popRemappableOop();
+ interpreterProxy->storePointerofObjectwithValue(1, retOop1, oop1);
+ result = interpreterProxy->methodReturnValue(retOop1);
+ goto l6;
+ }
+ interpreterProxy->pushRemappableOop(retClass1);
+ if (((calloutState->ffiRetHeader)) & FFIFlagStructure) {
+ classOop = interpreterProxy->classByteArray();
+ }
+ else {
+ classOop = interpreterProxy->classExternalAddress();
+ }
+ oop1 = interpreterProxy->instantiateClassindexableSize(classOop, 4);
+ ptr1 = interpreterProxy->firstIndexableField(oop1);
+ ptr1[0] = (((sqInt) intRet));
+
+ /* return class */
+
+ retClass1 = interpreterProxy->popRemappableOop();
+ interpreterProxy->pushRemappableOop(oop1);
+ retOop1 = interpreterProxy->instantiateClassindexableSize(retClass1, 0);
+
+ /* external address */
+
+ oop1 = interpreterProxy->popRemappableOop();
+ interpreterProxy->storePointerofObjectwithValue(0, retOop1, oop1);
+ result = interpreterProxy->methodReturnValue(retOop1);
+ goto l6;
+ }
+ if (((calloutState->ffiRetHeader)) & FFIFlagStructure) {
+ /* begin ffiReturnStruct:ofType:in: */
+ /* begin ffiReturnType: */
+ specLiteral = (null != null
+ ? interpreterProxy->stackValue(1)
+ : interpreterProxy->literalofMethod(0, interpreterProxy->primitiveMethod()));
+ argTypes = interpreterProxy->fetchPointerofObject(ExternalFunctionArgTypesIndex, specLiteral);
+ ffiRetType = interpreterProxy->fetchPointerofObject(0, argTypes);
+ retClass = interpreterProxy->fetchPointerofObject(1, ffiRetType);
+ retOop = interpreterProxy->instantiateClassindexableSize(retClass, 0);
+ interpreterProxy->pushRemappableOop(retOop);
+ oop2 = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classByteArray(), (calloutState->structReturnSize));
+ if (returnStructInRegisters((calloutState->structReturnSize))) {
+ memcpy(interpreterProxy->firstIndexableField(oop2), (&intRet), (calloutState->structReturnSize));
+ }
+ else {
+ memcpy(interpreterProxy->firstIndexableField(oop2), (calloutState->limit), (calloutState->structReturnSize));
+ }
+ retOop = interpreterProxy->popRemappableOop();
+ interpreterProxy->storePointerofObjectwithValue(0, retOop, oop2);
+ result = interpreterProxy->methodReturnValue(retOop);
+ goto l6;
+ }
+ if ((atomicType == FFITypeSingleFloat)
+ || (atomicType == FFITypeDoubleFloat)) {
+ result = interpreterProxy->methodReturnValue(interpreterProxy->floatObjectOf(floatRet));
+ goto l6;
+ }
+ result = interpreterProxy->methodReturnValue(ffiCreateIntegralResultOopofAtomicTypein(intRet, atomicType, calloutState));
+l6: /* end ffiCalloutTo:SpecOnStack:in: */;
+ /* begin cleanupCalloutState: */
+ while (((calloutState->stringArgIndex)) > 0) {
+ free(((calloutState->stringArgs))[(calloutState->stringArgIndex = ((calloutState->stringArgIndex)) - 1)]);
+ }
+l3: /* end ffiCall:ArgArrayOrNil:NumArgs: */;
  return;
 }
 
@@ -2338,26 +3069,338 @@
 EXPORT(void)
 primitiveCalloutWithArgs(void)
 {
+    sqInt address;
+    sqInt address1;
+    sqInt addressPtr;
+    char *allocation;
     sqInt argArray;
+    sqInt argClass;
+    sqInt argSpec;
+    sqInt argType;
+    sqInt argTypeArray;
+    sqInt argTypes;
+    sqInt argTypes1;
+    sqInt atomicType;
+    sqInt atomicType1;
+    CalloutState *calloutState;
+    sqInt classOop;
+    char *cString;
+    sqInt err;
     sqInt externalFunction;
+    sqInt ffiRetType;
+    sqInt flags;
+    double floatRet;
+    sqInt functionName;
+    sqInt i;
+    sqInt i1;
+    usqLong intRet;
     sqInt nArgs;
-    sqInt retryCount;
+    sqInt oop;
+    sqInt oop1;
+    sqInt oop2;
+    void *pointer;
+    int *ptr;
+    sqInt *ptr1;
+    sqInt requiredStackSize;
+    sqInt result;
+    sqInt retClass;
+    sqInt retClass1;
+    sqInt retOop;
+    sqInt retOop1;
+    sqInt retType;
+    sqInt specLiteral;
+    sqInt specLiteral1;
+    sqInt stackSize;
+    sqInt strLen;
+    sqInt strOop;
+    char *strPtr;
+    CalloutState theCalloutState;
+    sqInt typeSpec;
+    sqInt typeSpec1;
 
  if (!((interpreterProxy->methodArgumentCount()) == 1)) {
  interpreterProxy->primitiveFailFor(PrimErrBadNumArgs); return;
  }
- retryCount = 0;
- while (1) {
- externalFunction = interpreterProxy->stackValue(1);
- argArray = interpreterProxy->stackValue(0);
- if (!(interpreterProxy->isArray(argArray))) {
- interpreterProxy->primitiveFailFor(PrimErrBadArgument); return;
+ externalFunction = interpreterProxy->stackValue(1);
+ argArray = interpreterProxy->stackValue(0);
+ if (!(interpreterProxy->isArray(argArray))) {
+ interpreterProxy->primitiveFailFor(PrimErrBadArgument); return;
+ }
+ nArgs = interpreterProxy->slotSizeOf(argArray);
+ /* begin ffiCall:ArgArrayOrNil:NumArgs: */
+ if (!(interpreterProxy->isKindOfClass(externalFunction, interpreterProxy->classExternalFunction()))) {
+ ffiFail(FFIErrorNotFunction);
+ goto l3;
+ }
+ flags = interpreterProxy->fetchIntegerofObject(ExternalFunctionFlagsIndex, externalFunction);
+ if (interpreterProxy->failed()) {
+ ffiFail(FFIErrorBadArgs);
+ goto l3;
+ }
+
+ /* must be array of arg types */
+
+ argTypeArray = interpreterProxy->fetchPointerofObject(ExternalFunctionArgTypesIndex, externalFunction);
+ if (!((interpreterProxy->isArray(argTypeArray))
+ && ((interpreterProxy->slotSizeOf(argTypeArray)) == (nArgs + 1)))) {
+ ffiFail(FFIErrorBadArgs);
+ goto l3;
+ }
+ if (!(1)) {
+ ffiFail(FFIErrorCallType);
+ goto l3;
+ }
+ /* begin ffiLoadCalloutAddress: */
+
+ /* Lookup the address */
+ /* Make sure it's an external handle */
+
+ addressPtr = interpreterProxy->fetchPointerofObject(0, externalFunction);
+ /* begin ffiContentsOfHandle:errCode: */
+ if ((addressPtr & 1)) {
+ address1 = ffiFail(FFIErrorBadAddress);
+ goto l4;
+ }
+ if (!(interpreterProxy->isBytes(addressPtr))) {
+ address1 = ffiFail(FFIErrorBadAddress);
+ goto l4;
+ }
+ if (!((interpreterProxy->byteSizeOf(addressPtr)) == 4)) {
+ address1 = ffiFail(FFIErrorBadAddress);
+ goto l4;
+ }
+ address1 = interpreterProxy->fetchPointerofObject(0, addressPtr);
+l4: /* end ffiContentsOfHandle:errCode: */;
+ if (interpreterProxy->failed()) {
+ address = 0;
+ goto l5;
+ }
+ if (address1 == 0) {
+ if (externalFunctionInstSize > ExternalFunctionStackSizeIndex) {
+ interpreterProxy->storePointerofObjectwithValue(ExternalFunctionStackSizeIndex, externalFunction, ((-1 << 1) | 1));
  }
- nArgs = interpreterProxy->slotSizeOf(argArray);
- if (!(((ffiCallArgArrayOrNilNumArgs(externalFunction, argArray, nArgs)) == PrimErrObjectMayMove)
- && (((retryCount += 1)) <= nArgs))) break;
- interpreterProxy->tenuringIncrementalGC();
+ if ((interpreterProxy->slotSizeOf(externalFunction)) < 5) {
+ address = ffiFail(FFIErrorNoModule);
+ goto l5;
+ }
+ address1 = ffiLoadCalloutAddressFrom(externalFunction);
+ if (interpreterProxy->failed()) {
+ address = 0;
+ goto l5;
+ }
+ ptr = interpreterProxy->firstIndexableField(addressPtr);
+ ptr[0] = address1;
  }
+ address = address1;
+l5: /* end ffiLoadCalloutAddress: */;
+ if (interpreterProxy->failed()) {
+ goto l3;
+ }
+ requiredStackSize = (externalFunctionInstSize > ExternalFunctionStackSizeIndex
+ ? interpreterProxy->fetchIntegerofObject(ExternalFunctionStackSizeIndex, externalFunction)
+ : -1);
+ if (interpreterProxy->failed()) {
+ interpreterProxy->primitiveFailFor((argArray == null
+ ? PrimErrBadMethod
+ : PrimErrBadReceiver));
+ goto l3;
+ }
+ stackSize = (requiredStackSize < 0
+ ? DefaultMaxStackSize
+ : requiredStackSize);
+ null;
+ calloutState = (&theCalloutState);
+ memset(calloutState, 0, sizeof(CalloutState));
+;
+ (calloutState->callFlags = flags);
+ argType = interpreterProxy->fetchPointerofObject(0, argTypeArray);
+ argSpec = interpreterProxy->fetchPointerofObject(0, argType);
+ argClass = interpreterProxy->fetchPointerofObject(1, argType);
+ if (((err = ffiCheckReturnWithin(argSpec, argClass, calloutState))) != 0) {
+ ffiFail(err);
+ goto l3;
+ }
+ allocation = alloca(((stackSize + ((calloutState->structReturnSize))) + 0) + (cStackAlignment()));
+ if (allocaLiesSoUseGetsp()) {
+ allocation = getsp();
+ }
+ if ((cStackAlignment()) != 0) {
+ allocation = ((char *) ((((usqInt)allocation)) & (~((cStackAlignment()) - 1))));
+ }
+ (calloutState->argVector = allocation);
+ (calloutState->currentArg = allocation + 0);
+ (calloutState->limit = (allocation + stackSize) + 0);
+ if ((((calloutState->structReturnSize)) > 0)
+ && (1
+ && (!(returnStructInRegisters((calloutState->structReturnSize)))))) {
+ /* begin ffiPushPointer:in: */
+ pointer = (calloutState->limit);
+ if ((((calloutState->currentArg)) + 4) > ((calloutState->limit))) {
+ goto l1;
+ }
+ longAtput((calloutState->currentArg), pointer);
+ (calloutState->currentArg = ((calloutState->currentArg)) + 4);
+ l1: /* end ffiPushPointer:in: */;
+ }
+ for (i = 1; i <= nArgs; i += 1) {
+ argType = interpreterProxy->fetchPointerofObject(i, argTypeArray);
+ argSpec = interpreterProxy->fetchPointerofObject(0, argType);
+ argClass = interpreterProxy->fetchPointerofObject(1, argType);
+ oop = (argArray == null
+ ? interpreterProxy->stackValue(nArgs - i)
+ : interpreterProxy->fetchPointerofObject(i - 1, argArray));
+ err = ffiArgumentSpecClassin(oop, argSpec, argClass, calloutState);
+ if (err != 0) {
+ /* begin cleanupCalloutState: */
+ while (((calloutState->stringArgIndex)) > 0) {
+ free(((calloutState->stringArgs))[(calloutState->stringArgIndex = ((calloutState->stringArgIndex)) - 1)]);
+ }
+ ffiFail(err);
+ goto l3;
+ }
+ }
+ assert(!(interpreterProxy->failed()));
+ /* begin ffiLogCallout: */
+ if (ffiLogEnabled) {
+ functionName = interpreterProxy->fetchPointerofObject(externalFunctionInstSize, externalFunction);
+ if (!(interpreterProxy->isBytes(functionName))) {
+ goto l2;
+ }
+ ffiLogCallOfLength(interpreterProxy->firstIndexableField(functionName), interpreterProxy->byteSizeOf(functionName));
+ }
+l2: /* end ffiLogCallout: */;
+ if ((requiredStackSize < 0)
+ && (externalFunctionInstSize > ExternalFunctionStackSizeIndex)) {
+ stackSize = ((calloutState->currentArg)) - ((calloutState->argVector));
+ interpreterProxy->storeIntegerofObjectwithValue(ExternalFunctionStackSizeIndex, externalFunction, stackSize);
+ }
+ /* begin ffiCalloutTo:SpecOnStack:in: */
+ if ((0 + (cStackAlignment())) > 0) {
+ setsp((calloutState->argVector));
+ }
+ /* begin atomicTypeOf: */
+ typeSpec = (calloutState->ffiRetHeader);
+ atomicType = ((usqInt) (typeSpec & FFIAtomicTypeMask)) >> FFIAtomicTypeShift;
+ if ((atomicType == FFITypeSingleFloat)
+ || (atomicType == FFITypeDoubleFloat)) {
+ floatRet = dispatchFunctionPointer(((double (*)()) address));
+ }
+ else {
+ intRet = dispatchFunctionPointer(((usqLong (*)()) address));
+ }
+ if (isCalleePopsConvention((calloutState->callFlags))) {
+ setsp((calloutState->argVector));
+ }
+ if (((calloutState->ffiRetHeader)) & FFIFlagPointer) {
+ /* begin ffiReturnPointer:ofType:in: */
+ /* begin ffiReturnType: */
+ specLiteral1 = (argArray != null
+ ? interpreterProxy->stackValue(1)
+ : interpreterProxy->literalofMethod(0, interpreterProxy->primitiveMethod()));
+ argTypes1 = interpreterProxy->fetchPointerofObject(ExternalFunctionArgTypesIndex, specLiteral1);
+ retType = interpreterProxy->fetchPointerofObject(0, argTypes1);
+ retClass1 = interpreterProxy->fetchPointerofObject(1, retType);
+ if (retClass1 == (interpreterProxy->nilObject())) {
+ /* begin atomicTypeOf: */
+ typeSpec1 = (calloutState->ffiRetHeader);
+ atomicType1 = ((usqInt) (typeSpec1 & FFIAtomicTypeMask)) >> FFIAtomicTypeShift;
+ if ((((usqInt) atomicType1) >> 1) == (((usqInt) FFITypeSignedChar) >> 1)) {
+ /* begin ffiReturnCStringFrom: */
+ if ((((usqInt) intRet)) == null) {
+ result = interpreterProxy->methodReturnValue(interpreterProxy->nilObject());
+ goto l6;
+ }
+ cString = ((char *) (((usqInt) intRet)));
+ strLen = 0;
+ while (!((cString[strLen]) == 0)) {
+ strLen += 1;
+ }
+ strOop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classString(), strLen);
+ strPtr = interpreterProxy->firstIndexableField(strOop);
+ for (i1 = 0; i1 <= (strLen - 1); i1 += 1) {
+ strPtr[i1] = (cString[i1]);
+ }
+ result = interpreterProxy->methodReturnValue(strOop);
+ goto l6;
+ }
+ interpreterProxy->pushRemappableOop(retType);
+ oop1 = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classExternalAddress(), 4);
+ ptr1 = interpreterProxy->firstIndexableField(oop1);
+ ptr1[0] = (((sqInt) intRet));
+ interpreterProxy->pushRemappableOop(oop1);
+ retOop1 = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classExternalData(), 0);
+
+ /* external address */
+
+ oop1 = interpreterProxy->popRemappableOop();
+ interpreterProxy->storePointerofObjectwithValue(0, retOop1, oop1);
+
+ /* return type */
+
+ oop1 = interpreterProxy->popRemappableOop();
+ interpreterProxy->storePointerofObjectwithValue(1, retOop1, oop1);
+ result = interpreterProxy->methodReturnValue(retOop1);
+ goto l6;
+ }
+ interpreterProxy->pushRemappableOop(retClass1);
+ if (((calloutState->ffiRetHeader)) & FFIFlagStructure) {
+ classOop = interpreterProxy->classByteArray();
+ }
+ else {
+ classOop = interpreterProxy->classExternalAddress();
+ }
+ oop1 = interpreterProxy->instantiateClassindexableSize(classOop, 4);
+ ptr1 = interpreterProxy->firstIndexableField(oop1);
+ ptr1[0] = (((sqInt) intRet));
+
+ /* return class */
+
+ retClass1 = interpreterProxy->popRemappableOop();
+ interpreterProxy->pushRemappableOop(oop1);
+ retOop1 = interpreterProxy->instantiateClassindexableSize(retClass1, 0);
+
+ /* external address */
+
+ oop1 = interpreterProxy->popRemappableOop();
+ interpreterProxy->storePointerofObjectwithValue(0, retOop1, oop1);
+ result = interpreterProxy->methodReturnValue(retOop1);
+ goto l6;
+ }
+ if (((calloutState->ffiRetHeader)) & FFIFlagStructure) {
+ /* begin ffiReturnStruct:ofType:in: */
+ /* begin ffiReturnType: */
+ specLiteral = (argArray != null
+ ? interpreterProxy->stackValue(1)
+ : interpreterProxy->literalofMethod(0, interpreterProxy->primitiveMethod()));
+ argTypes = interpreterProxy->fetchPointerofObject(ExternalFunctionArgTypesIndex, specLiteral);
+ ffiRetType = interpreterProxy->fetchPointerofObject(0, argTypes);
+ retClass = interpreterProxy->fetchPointerofObject(1, ffiRetType);
+ retOop = interpreterProxy->instantiateClassindexableSize(retClass, 0);
+ interpreterProxy->pushRemappableOop(retOop);
+ oop2 = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classByteArray(), (calloutState->structReturnSize));
+ if (returnStructInRegisters((calloutState->structReturnSize))) {
+ memcpy(interpreterProxy->firstIndexableField(oop2), (&intRet), (calloutState->structReturnSize));
+ }
+ else {
+ memcpy(interpreterProxy->firstIndexableField(oop2), (calloutState->limit), (calloutState->structReturnSize));
+ }
+ retOop = interpreterProxy->popRemappableOop();
+ interpreterProxy->storePointerofObjectwithValue(0, retOop, oop2);
+ result = interpreterProxy->methodReturnValue(retOop);
+ goto l6;
+ }
+ if ((atomicType == FFITypeSingleFloat)
+ || (atomicType == FFITypeDoubleFloat)) {
+ result = interpreterProxy->methodReturnValue(interpreterProxy->floatObjectOf(floatRet));
+ goto l6;
+ }
+ result = interpreterProxy->methodReturnValue(ffiCreateIntegralResultOopofAtomicTypein(intRet, atomicType, calloutState));
+l6: /* end ffiCalloutTo:SpecOnStack:in: */;
+ /* begin cleanupCalloutState: */
+ while (((calloutState->stringArgIndex)) > 0) {
+ free(((calloutState->stringArgs))[(calloutState->stringArgIndex = ((calloutState->stringArgIndex)) - 1)]);
+ }
+l3: /* end ffiCall:ArgArrayOrNil:NumArgs: */;
  return;
 }
 
@@ -2870,8 +3913,7 @@
 /* Answer any space needed to prevent the alloca'ed outgoing arguments
  marshalling area from
  being overwritten by any register arguments during calls during
- marshalling. On ARM we
- believe this is zero. */
+ marshalling. On x86 this is 0 */
 
 static sqInt
 registerArgsSlop(void)
@@ -2880,15 +3922,6 @@
 }
 
 
-/* Answer if a struct result of a given size is returned in memory or not. */
-
-static sqInt
-returnStructInRegisters(sqInt returnStructSize)
-{
- return subclassResponsibility();
-}
-
-
 /* Note: This is coded so that is can be run from Squeak. */
 
 EXPORT(sqInt)