Stackless issue python#143: fix non-portable usage of bit fields

- avoid type punning / strict aliasing violations
- don't rely on implementation defined placement of bit-fields in the
storage unit.
(cherry picked from commit b9c243a)

Author: Anselm Kruis

Stackless/core/stackless_impl.h

@@ -43,7 +43,21 @@ extern "C" {
  * This would usually be done in place with the assembly macros.
  */
 
+/*
+ * Macros used to extract bit-field values from an integer in a portable
+ * way.
+ */
+#define SLP_EXTRACT_BITS_(integer, bits, offset) \
+    (((integer) & (((1U << (bits))-1U) << (offset))) >> (offset))
+
+#define SLP_SET_BITFIELD(NAME_PREFIX, bitfield_struct, integer, member) \
+    (bitfield_struct).member = SLP_EXTRACT_BITS_((integer), NAME_PREFIX ## _BITS_ ## member, NAME_PREFIX ## _OFFSET_ ## member)
+
+#define SLP_PREPARE_BITS_(value, offset) \
+    (((unsigned int)(value)) << (offset))
 
+#define SLP_GET_BITFIELD(NAME_PREFIX, bitfield_struct, member) \
+    SLP_PREPARE_BITS_((bitfield_struct).member, NAME_PREFIX ## _OFFSET_ ## member)
 
 /*
  * About the reference counting of frames and C-frames
@@ -681,10 +695,10 @@ do { \
 /* ditto, without incref. Made no sense to optimize. */
 #if defined(__GNUC__) && defined(__STDC__) && (__STDC_VERSION__ >= 199901L)
 #define SLP_DISABLE_GCC_W_ADDRESS \
-	    _Pragma("GCC diagnostic push") \
-	    _Pragma("GCC diagnostic ignored \"-Waddress\"")
+            _Pragma("GCC diagnostic push") \
+            _Pragma("GCC diagnostic ignored \"-Waddress\"")
 #define SLP_RESTORE_WARNINGS \
-	    _Pragma("GCC diagnostic pop")
+            _Pragma("GCC diagnostic pop")
 #else
 #define SLP_DISABLE_GCC_W_ADDRESS /**/
 #define SLP_RESTORE_WARNINGS /**/

Stackless/core/stackless_structs.h

@@ -62,14 +62,36 @@ extern "C" {
 
  ***************************************************************************/
 
+#define SLP_TASKLET_FLAGS_BITS_blocked 2
+#define SLP_TASKLET_FLAGS_BITS_atomic 1
+#define SLP_TASKLET_FLAGS_BITS_ignore_nesting 1
+#define SLP_TASKLET_FLAGS_BITS_autoschedule 1
+#define SLP_TASKLET_FLAGS_BITS_block_trap 1
+#define SLP_TASKLET_FLAGS_BITS_is_zombie 1
+#define SLP_TASKLET_FLAGS_BITS_pending_irq 1
+
+#define SLP_TASKLET_FLAGS_OFFSET_blocked 0
+#define SLP_TASKLET_FLAGS_OFFSET_atomic \
+    (SLP_TASKLET_FLAGS_OFFSET_blocked + SLP_TASKLET_FLAGS_BITS_blocked)
+#define SLP_TASKLET_FLAGS_OFFSET_ignore_nesting \
+    (SLP_TASKLET_FLAGS_OFFSET_atomic + SLP_TASKLET_FLAGS_BITS_atomic)
+#define SLP_TASKLET_FLAGS_OFFSET_autoschedule \
+    (SLP_TASKLET_FLAGS_OFFSET_ignore_nesting + SLP_TASKLET_FLAGS_BITS_ignore_nesting)
+#define SLP_TASKLET_FLAGS_OFFSET_block_trap \
+    (SLP_TASKLET_FLAGS_OFFSET_autoschedule + SLP_TASKLET_FLAGS_BITS_autoschedule)
+#define SLP_TASKLET_FLAGS_OFFSET_is_zombie \
+    (SLP_TASKLET_FLAGS_OFFSET_block_trap + SLP_TASKLET_FLAGS_BITS_block_trap)
+#define SLP_TASKLET_FLAGS_OFFSET_pending_irq \
+    (SLP_TASKLET_FLAGS_OFFSET_is_zombie + SLP_TASKLET_FLAGS_BITS_is_zombie)
+
 typedef struct _tasklet_flags {
-    int blocked: 2;
-    unsigned int atomic: 1;
-    unsigned int ignore_nesting: 1;
-    unsigned int autoschedule: 1;
-    unsigned int block_trap: 1;
-    unsigned int is_zombie: 1;
-    unsigned int pending_irq: 1;
+    signed int blocked: SLP_TASKLET_FLAGS_BITS_blocked;
+    unsigned int atomic: SLP_TASKLET_FLAGS_BITS_atomic;
+    unsigned int ignore_nesting: SLP_TASKLET_FLAGS_BITS_ignore_nesting;
+    unsigned int autoschedule: SLP_TASKLET_FLAGS_BITS_autoschedule;
+    unsigned int block_trap: SLP_TASKLET_FLAGS_BITS_block_trap;
+    unsigned int is_zombie: SLP_TASKLET_FLAGS_BITS_is_zombie;
+    unsigned int pending_irq: SLP_TASKLET_FLAGS_BITS_pending_irq;
 } PyTaskletFlagStruc;
 
 /* a partial copy of PyThreadState. Used to preserve 
@@ -160,10 +182,20 @@ typedef struct _bomb {
 
  ***************************************************************************/
 
+#define SLP_CHANNEL_FLAGS_BITS_closing 1
+#define SLP_CHANNEL_FLAGS_BITS_preference 2
+#define SLP_CHANNEL_FLAGS_BITS_schedule_all 1
+
+#define SLP_CHANNEL_FLAGS_OFFSET_closing 0
+#define SLP_CHANNEL_FLAGS_OFFSET_preference \
+    (SLP_CHANNEL_FLAGS_OFFSET_closing + SLP_CHANNEL_FLAGS_BITS_closing)
+#define SLP_CHANNEL_FLAGS_OFFSET_schedule_all \
+    (SLP_CHANNEL_FLAGS_OFFSET_preference + SLP_CHANNEL_FLAGS_BITS_preference)
+
 typedef struct _channel_flags {
-    unsigned int closing: 1;
-    int preference: 2;
-    unsigned int schedule_all:1;
+    unsigned int closing: SLP_CHANNEL_FLAGS_BITS_closing;
+    signed int preference: SLP_CHANNEL_FLAGS_BITS_preference;
+    unsigned int schedule_all: SLP_CHANNEL_FLAGS_BITS_schedule_all;
 } PyChannelFlagStruc;
 
 typedef struct _channel {

Stackless/module/channelobject.c

@@ -13,6 +13,37 @@
 static void
 channel_remove_all(PyObject *ob);
 
+Py_LOCAL_INLINE(PyChannelFlagStruc)
+channel_flags_from_integer(int flags) {
+#if defined(SLP_USE_NATIVE_BITFIELD_LAYOUT) && SLP_USE_NATIVE_BITFIELD_LAYOUT
+    PyChannelFlagStruc f;
+    Py_MEMCPY(&f, &flags, sizeof(f));
+#else
+    /* the portable way */
+    PyChannelFlagStruc f = {0, };
+    SLP_SET_BITFIELD(SLP_CHANNEL_FLAGS, f, flags, closing);
+    SLP_SET_BITFIELD(SLP_CHANNEL_FLAGS, f, flags, preference);
+    SLP_SET_BITFIELD(SLP_CHANNEL_FLAGS, f, flags, schedule_all);
+#endif
+    (void) Py_BUILD_ASSERT_EXPR(sizeof(f) == sizeof(flags));
+    return f;
+}
+
+Py_LOCAL_INLINE(int)
+channel_flags_as_integer(PyChannelFlagStruc flags) {
+    int f;
+    (void) Py_BUILD_ASSERT_EXPR(sizeof(f) == sizeof(flags));
+#if defined(SLP_USE_NATIVE_BITFIELD_LAYOUT) && SLP_USE_NATIVE_BITFIELD_LAYOUT
+    Py_MEMCPY(&f, &flags, sizeof(f));
+#else
+    /* the portable way */
+    f = SLP_GET_BITFIELD(SLP_CHANNEL_FLAGS, flags, closing) |
+            SLP_GET_BITFIELD(SLP_CHANNEL_FLAGS, flags, preference) |
+            SLP_GET_BITFIELD(SLP_CHANNEL_FLAGS, flags, schedule_all);
+#endif
+    return f;
+}
+
 /* GC support.  The tasklets already know if they are collectable
  * or not.  If they are not, and referenced by the channel, then
  * no channel_clear() will be performed.  Thus, the GC support
@@ -163,7 +194,7 @@ PyChannel_New(PyTypeObject *type)
         c->head = c->tail = (PyTaskletObject *) c;
         c->balance = 0;
         c->chan_weakreflist = NULL;
-        *(int*)&c->flags = 0;
+        memset(&c->flags, 0, sizeof(c->flags));
         c->flags.preference = -1; /* default fast receive */
     }
     return c;
@@ -1089,7 +1120,7 @@ channel_reduce(PyChannelObject * ch)
     tup = Py_BuildValue("(O()(iiO))",
                         Py_TYPE(ch),
                         ch->balance,
-                        ch->flags,
+                        channel_flags_as_integer(ch->flags),
                         lis
                         );
 err_exit:
@@ -1118,7 +1149,7 @@ channel_setstate(PyObject *self, PyObject *args)
 
     channel_remove_all((PyObject *) ch);
     n = PyList_GET_SIZE(lis);
-    *(int *)&ch->flags = flags;
+    ch->flags = channel_flags_from_integer(flags);
     dir = balance > 0 ? 1 : -1;
 
     for (i = 0; i < n; i++) {

Stackless/module/taskletobject.c

@@ -9,6 +9,48 @@
 #ifdef STACKLESS
 #include "core/stackless_impl.h"
 
+/*
+ * Convert C-bitfield
+ */
+Py_LOCAL_INLINE(PyTaskletFlagStruc)
+tasklet_flags_from_integer(int flags) {
+#if defined(SLP_USE_NATIVE_BITFIELD_LAYOUT) && SLP_USE_NATIVE_BITFIELD_LAYOUT
+    PyTaskletFlagStruc f;
+    Py_MEMCPY(&f, &flags, sizeof(f));
+#else
+    /* the portable way */
+    PyTaskletFlagStruc f = {0, };
+    SLP_SET_BITFIELD(SLP_TASKLET_FLAGS, f, flags, blocked);
+    SLP_SET_BITFIELD(SLP_TASKLET_FLAGS, f, flags, atomic);
+    SLP_SET_BITFIELD(SLP_TASKLET_FLAGS, f, flags, ignore_nesting);
+    SLP_SET_BITFIELD(SLP_TASKLET_FLAGS, f, flags, autoschedule);
+    SLP_SET_BITFIELD(SLP_TASKLET_FLAGS, f, flags, block_trap);
+    SLP_SET_BITFIELD(SLP_TASKLET_FLAGS, f, flags, is_zombie);
+    SLP_SET_BITFIELD(SLP_TASKLET_FLAGS, f, flags, pending_irq);
+#endif
+    (void) Py_BUILD_ASSERT_EXPR(sizeof(f) == sizeof(flags));
+    return f;
+}
+
+Py_LOCAL_INLINE(int)
+tasklet_flags_as_integer(PyTaskletFlagStruc flags) {
+    int f;
+    (void) Py_BUILD_ASSERT_EXPR(sizeof(f) == sizeof(flags));
+#if defined(SLP_USE_NATIVE_BITFIELD_LAYOUT) && SLP_USE_NATIVE_BITFIELD_LAYOUT
+    Py_MEMCPY(&f, &flags, sizeof(f));
+#else
+    /* the portable way */
+    f = SLP_GET_BITFIELD(SLP_TASKLET_FLAGS, flags, blocked) |
+            SLP_GET_BITFIELD(SLP_TASKLET_FLAGS, flags, atomic) |
+            SLP_GET_BITFIELD(SLP_TASKLET_FLAGS, flags, ignore_nesting) |
+            SLP_GET_BITFIELD(SLP_TASKLET_FLAGS, flags, autoschedule) |
+            SLP_GET_BITFIELD(SLP_TASKLET_FLAGS, flags, block_trap) |
+            SLP_GET_BITFIELD(SLP_TASKLET_FLAGS, flags, is_zombie) |
+            SLP_GET_BITFIELD(SLP_TASKLET_FLAGS, flags, pending_irq);
+#endif
+    return f;
+}
+
 void
 slp_current_insert(PyTaskletObject *task)
 {
@@ -366,7 +408,7 @@ tasklet_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     t = (PyTaskletObject *) type->tp_alloc(type, 0);
     if (t == NULL)
         return NULL;
-    *(int*)&t->flags = 0;
+    memset(&t->flags, 0, sizeof(t->flags));
     t->recursion_depth = 0;
     t->next = NULL;
     t->prev = NULL;
@@ -460,7 +502,7 @@ tasklet_reduce(PyTaskletObject * t)
     assert(t->cstate != NULL);
     tup = Py_BuildValue("(O()(" TASKLET_TUPLEFMT "))",
                         Py_TYPE(t),
-                        t->flags,
+                        tasklet_flags_as_integer(t->flags),
                         t->tempval,
                         t->cstate->nesting_level,
                         lis
@@ -513,7 +555,7 @@ tasklet_setstate(PyObject *self, PyObject *args)
      * channel would have set it.
      */
     j = t->flags.blocked;
-    *(int *)&t->flags = flags;
+    t->flags = tasklet_flags_from_integer(flags);
     if (t->next == NULL) {
         t->flags.blocked = 0;
     } else {

Stackless/platf/switch_amd64_unix.h

@@ -29,6 +29,8 @@
  *      Ported from i386.
  */
 
+#define SLP_USE_NATIVE_BITFIELD_LAYOUT 1
+
 #define STACK_REFPLUS 1
 
 #ifdef SLP_EVAL
@@ -86,7 +88,7 @@
 /* Maximum possible clobber list. It gives the same assembly code as the minimum list.
    If the ABI evolves, it might be necessary to add some of these registers */
 #define REGS_CLOBBERED "memory", "rax", "rbx", "rcx", "rdx", "rsi", "rdi", \
-    "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",		        \
+    "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",                       \
     "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)", \
     "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7", \
     "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
@@ -130,13 +132,13 @@ slp_switch(void)
         SLP_RESTORE_STATE();
 #if STACKLESS_FRHACK
         __asm__ volatile (
-	    "ldmxcsr %1\n\t"
+            "ldmxcsr %1\n\t"
             "fldcw %0\n\t"
             : : "m" (x87cw), "m" (mxcsr));
 #else
         __asm__ volatile (
             "movq %2, %%rbp\n\t"
-	    "ldmxcsr %1\n\t"
+            "ldmxcsr %1\n\t"
             "fldcw %0\n\t"
             : : "m" (x87cw), "m" (mxcsr), "m" (rbp));
 #endif

Stackless/platf/switch_x64_msvc.h

@@ -22,6 +22,8 @@
  *      Initial final version after lots of iterations for i386.
  */
 
+#define SLP_USE_NATIVE_BITFIELD_LAYOUT 1
+
 #define alloca _alloca
 
 #define STACK_REFPLUS 1

Stackless/platf/switch_x86_msvc.h

@@ -22,6 +22,8 @@
  *      Initial final version after lots of iterations for i386.
  */
 
+#define SLP_USE_NATIVE_BITFIELD_LAYOUT 1
+
 /* for the SEH things */
 #ifndef _WINDOWS_
 #define WIN32_LEAN_AND_MEAN

Stackless/platf/switch_x86_unix.h

@@ -21,6 +21,8 @@
  *      Ported from i386.
  */
 
+#define SLP_USE_NATIVE_BITFIELD_LAYOUT 1
+
 #define STACK_REFPLUS 1
 
 #ifdef SLP_EVAL
@@ -78,12 +80,12 @@ slp_switch(void)
     register int *stackref, stsizediff;
 #if STACKLESS_FRHACK
     __asm__ volatile (
-	""
+        ""
         : : : REGS_CLOBBERED );
 #else
     void * ebp;
     __asm__ volatile (
-	"movl %%ebp, %0\n\t"
+        "movl %%ebp, %0\n\t"
         : "=m" (ebp) : : REGS_CLOBBERED );
 #endif
     __asm__ ("movl %%esp, %0" : "=g" (stackref));