From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001

From: Charalampos Stratakis <cstratak@redhat.com>

Date: Mon, 30 Oct 2017 17:36:25 +0100

Subject: [PATCH] 00264: Fix test failing on aarch64

test_pass_by_value was added in Python 3.5.4 and on aarch64

it is catching an error that was there, but wasn't tested before.

Since the Python 3.5 branch is on security bug fix mode only

we backport the fix from the master branch.

Fixed upstream: http://bugs.python.org/issue29804

---

 Lib/ctypes/test/test_as_parameter.py |  4 ++++

 Lib/ctypes/test/test_structures.py   | 22 ++++++++++++++++++++++

 Modules/_ctypes/_ctypes_test.c       | 18 ++++++++++++++++++

 Modules/_ctypes/callproc.c           | 23 +++++++++++++++++++++--

 4 files changed, 65 insertions(+), 2 deletions(-)

diff --git a/Lib/ctypes/test/test_as_parameter.py b/Lib/ctypes/test/test_as_parameter.py

index 2a3484bec0..a2640575a0 100644

--- a/Lib/ctypes/test/test_as_parameter.py

+++ b/Lib/ctypes/test/test_as_parameter.py

@@ -169,6 +169,10 @@ class BasicWrapTestCase(unittest.TestCase):

         s2h = dll.ret_2h_func(self.wrap(inp))

         self.assertEqual((s2h.x, s2h.y), (99*2, 88*3))

+        # Test also that the original struct was unmodified (i.e. was passed by

+        # value)

+        self.assertEqual((inp.x, inp.y), (99, 88))

+

     def test_struct_return_8H(self):

         class S8I(Structure):

             _fields_ = [("a", c_int),

diff --git a/Lib/ctypes/test/test_structures.py b/Lib/ctypes/test/test_structures.py

index 2e9fc7c49c..fa7e86fa89 100644

--- a/Lib/ctypes/test/test_structures.py

+++ b/Lib/ctypes/test/test_structures.py

@@ -420,6 +420,28 @@ class StructureTestCase(unittest.TestCase):

         self.assertEqual(s.second, 0xcafebabe)

         self.assertEqual(s.third, 0x0bad1dea)

+    def test_pass_by_value_in_register(self):

+        class X(Structure):

+            _fields_ = [

+                ('first', c_uint),

+                ('second', c_uint)

+            ]

+

+        s = X()

+        s.first = 0xdeadbeef

+        s.second = 0xcafebabe

+        dll = CDLL(_ctypes_test.__file__)

+        func = dll._testfunc_reg_struct_update_value

+        func.argtypes = (X,)

+        func.restype = None

+        func(s)

+        self.assertEqual(s.first, 0xdeadbeef)

+        self.assertEqual(s.second, 0xcafebabe)

+        got = X.in_dll(dll, "last_tfrsuv_arg")

+        self.assertEqual(s.first, got.first)

+        self.assertEqual(s.second, got.second)

+

+

 class PointerMemberTestCase(unittest.TestCase):

     def test(self):

diff --git a/Modules/_ctypes/_ctypes_test.c b/Modules/_ctypes/_ctypes_test.c

index e3240c526f..ed2cb6c823 100644

--- a/Modules/_ctypes/_ctypes_test.c

+++ b/Modules/_ctypes/_ctypes_test.c

@@ -57,6 +57,24 @@ _testfunc_large_struct_update_value(Test in)

     ((volatile Test *)&in)->third = 0x0badf00d;

 }

+typedef struct {

+    unsigned int first;

+    unsigned int second;

+} TestReg;

+

+

+EXPORT(TestReg) last_tfrsuv_arg;

+

+

+EXPORT(void)

+_testfunc_reg_struct_update_value(TestReg in)

+{

+    last_tfrsuv_arg = in;

+    ((volatile TestReg *)&in)->first = 0x0badf00d;

+    ((volatile TestReg *)&in)->second = 0x0badf00d;

+}

+

+

 EXPORT(void)testfunc_array(int values[4])

 {

     printf("testfunc_array %d %d %d %d\n",

diff --git a/Modules/_ctypes/callproc.c b/Modules/_ctypes/callproc.c

index 70e416b950..8a20e6ae13 100644

--- a/Modules/_ctypes/callproc.c

+++ b/Modules/_ctypes/callproc.c

@@ -1044,6 +1044,13 @@ GetComError(HRESULT errcode, GUID *riid, IUnknown *pIunk)

 }

 #endif

+#if (defined(__x86_64__) && (defined(__MINGW64__) || defined(__CYGWIN__))) || \

+    defined(__aarch64__)

+#define CTYPES_PASS_BY_REF_HACK

+#define POW2(x) (((x & ~(x - 1)) == x) ? x : 0)

+#define IS_PASS_BY_REF(x) (x > 8 || !POW2(x))

+#endif

+

 /*

  * Requirements, must be ensured by the caller:

  * - argtuple is tuple of arguments

@@ -1141,8 +1148,20 @@ PyObject *_ctypes_callproc(PPROC pProc,

     }

     for (i = 0; i < argcount; ++i) {

         atypes[i] = args[i].ffi_type;

-        if (atypes[i]->type == FFI_TYPE_STRUCT

-            )

+#ifdef CTYPES_PASS_BY_REF_HACK

+        size_t size = atypes[i]->size;

+        if (IS_PASS_BY_REF(size)) {

+            void *tmp = alloca(size);

+            if (atypes[i]->type == FFI_TYPE_STRUCT)

+                memcpy(tmp, args[i].value.p, size);

+            else

+                memcpy(tmp, (void*)&args[i].value, size);

+

+            avalues[i] = tmp;

+        }

+        else

+#endif

+        if (atypes[i]->type == FFI_TYPE_STRUCT)

             avalues[i] = (void *)args[i].value.p;

         else

             avalues[i] = (void *)&args[i].value;