Merge pull request #1 from nedbat/nedbat/fix-32

Fix some build issues on CI servers.

Author: DRMacIver

coverage/ctracer/module.c

@@ -44,24 +44,24 @@ PyInit_tracer(void)
         return NULL;
     }
 
-    InternTableType.tp_new = PyType_GenericNew;
-    if (PyType_Ready(&InternTableType) < 0) {
+    Py_INCREF(&CTracerType);
+    if (PyModule_AddObject(mod, "CTracer", (PyObject *)&CTracerType) < 0) {
         Py_DECREF(mod);
+        Py_DECREF(&CTracerType);
         return NULL;
     }
 
-    Py_INCREF(&CTracerType);
-    if (PyModule_AddObject(mod, "CTracer", (PyObject *)&CTracerType) < 0) {
+    /* Initialize InternTable */
+    InternTableType.tp_new = PyType_GenericNew;
+    if (PyType_Ready(&InternTableType) < 0) {
         Py_DECREF(mod);
-        Py_DECREF(&CTracerType);
         return NULL;
     }
 
     Py_INCREF(&InternTableType);
     if (PyModule_AddObject(mod, "InternTable", (PyObject *)&InternTableType) < 0) {
         Py_DECREF(mod);
         Py_DECREF(&InternTableType);
-        Py_DECREF(&InternTableType);
         return NULL;
     }
 
@@ -70,13 +70,15 @@ PyInit_tracer(void)
     if (PyType_Ready(&CFileDispositionType) < 0) {
         Py_DECREF(mod);
         Py_DECREF(&CTracerType);
+        Py_DECREF(&InternTableType);
         return NULL;
     }
 
     Py_INCREF(&CFileDispositionType);
     if (PyModule_AddObject(mod, "CFileDisposition", (PyObject *)&CFileDispositionType) < 0) {
         Py_DECREF(mod);
         Py_DECREF(&CTracerType);
+        Py_DECREF(&InternTableType);
         Py_DECREF(&CFileDispositionType);
         return NULL;
     }
@@ -109,6 +111,15 @@ inittracer(void)
     Py_INCREF(&CTracerType);
     PyModule_AddObject(mod, "CTracer", (PyObject *)&CTracerType);
 
+    /* Initialize InternTable */
+    InternTableType.tp_new = PyType_GenericNew;
+    if (PyType_Ready(&InternTableType) < 0) {
+        return;
+    }
+
+    Py_INCREF(&InternTableType);
+    PyModule_AddObject(mod, "InternTable", (PyObject *)&InternTableType);
+
     /* Initialize CFileDisposition */
     CFileDispositionType.tp_new = PyType_GenericNew;
     if (PyType_Ready(&CFileDispositionType) < 0) {

coverage/ctracer/tracer.c

@@ -72,8 +72,8 @@ static void InternTable_init_1(InternTable *table){
 }
 
 static void InternTable_dealloc_1(InternTable *table){
-    Py_XDECREF(table->zero_value);
     size_t j;
+    Py_XDECREF(table->zero_value);
     for(j = 0; j < table->capacity; j++){
         Py_XDECREF(table->entries[j].value);
     }
@@ -194,7 +194,7 @@ static const char * what_sym[] = {"CALL", "EXC ", "LINE", "RET "};
 
 // From http://www.cris.com/~Ttwang/tech/inthash.htm via
 // https://chromium.googlesource.com/chromium/blink/+/master/Source/wtf/HashFunctions.h
-static uint64_t hash64(uint64_t key){
+static PY_LONG_LONG hash64(PY_LONG_LONG key){
     key += ~(key << 32);
     key ^= (key >> 22);
     key += ~(key << 13);
@@ -211,7 +211,7 @@ static uint64_t hash64(uint64_t key){
     InternTable_lookup
 */
 static PyObject **
-InternTable_lookup(InternTable *table, uint64_t key);
+InternTable_lookup(InternTable *table, PY_LONG_LONG key);
 
 /*
  Core implementation of the InternTable hash table.
@@ -223,8 +223,8 @@ InternTable_lookup(InternTable *table, uint64_t key);
  returns a value pointer for the key.
 
 */
-static inline PyObject ** InternEntry_matches(
-    InternTable *table, size_t location, uint64_t key
+static PyObject ** InternEntry_matches(
+    InternTable *table, size_t location, PY_LONG_LONG key
 ){
     size_t index = location & (table->capacity - 1);
     InternEntry *entry = table->entries + index;
@@ -263,7 +263,7 @@ static inline PyObject ** InternEntry_matches(
                 }
             }
             free(old_entries);
-            assert(table->current_fill == old_fill);
+            assert(table->current_fill == old_fill); (void)(old_fill);
 
             /* The shape of the table has changed and the caller doesn't know
                about that, so we just recurse and look up the key in the new
@@ -288,17 +288,19 @@ a freshly created key it will be a pointer to null. The caller should then
 populate the cell with the newly created object.
 */
 static PyObject **
-InternTable_lookup(InternTable *table, uint64_t key){
+InternTable_lookup(InternTable *table, PY_LONG_LONG key){
     size_t i;
+    PyObject ** initial_attempt;
+    size_t probe;
 
     if(key == 0){
         return &(table->zero_value);
     }
-    PyObject ** initial_attempt = InternEntry_matches(table, key, key);
+    initial_attempt = InternEntry_matches(table, key, key);
     if(initial_attempt != NULL){
         return initial_attempt;
     }
-    size_t probe = hash64(key) & (table->capacity - 1);
+    probe = hash64(key) & (table->capacity - 1);
     for(i = 0; i < table->capacity; i++){
         PyObject ** attempt = InternEntry_matches(table, probe + i, key);
         if(attempt != NULL){
@@ -316,17 +318,17 @@ CTracer_record_pair(CTracer *self, int l1, int l2)
     int ret = RET_ERROR;
 
     /*
-    We combine the two int values into a uint64_t in a slightly odd way: Rather
+    We combine the two int values into a PY_LONG_LONG in a slightly odd way: Rather
     than just concatenate them, we xor them together for the low bits. The
     reason for this is that it allows us to trigger our no-hash lookup in the
     table more often, because it ensures a reasonable range of diversity in the
     low bits. We can recreate the original key as u1 = key >> 32,
     u2 = ((uint32_t)u1) ^ ((uint32_t)key), so this still maps the tuple to a
     unique key.
     */
-    uint64_t u1 = (uint32_t)l1;
-    uint64_t u2 = (uint32_t)l2;
-    uint64_t key = (u1 << 32) | (u1 ^ u2);
+    PY_LONG_LONG u1 = (PY_UINT32_T)l1;
+    PY_LONG_LONG u2 = (PY_UINT32_T)l2;
+    PY_LONG_LONG key = (u1 << 32) | (u1 ^ u2);
 
     PyObject ** container = InternTable_lookup(
         &self->intern_table, key);
@@ -355,7 +357,7 @@ static int
 CTracer_record_int(CTracer *self, int lineno_from){
 
     PyObject ** container = InternTable_lookup(
-        &self->intern_table, (uint64_t)lineno_from);
+        &self->intern_table, (PY_LONG_LONG)lineno_from);
 
     PyObject * this_line = *container;
     if (this_line == NULL) {
@@ -1367,14 +1369,17 @@ InternTable_dealloc(InternTableObject *self)
 
 static PyObject *InternTable_getitem(InternTableObject *self, PyObject *key)
 {
+    PY_LONG_LONG int_key;
+    PyObject **result;
+
     assert(self->table.entries);
     PyErr_Clear();
-    uint64_t int_key = PyLong_AsUnsignedLongLong(key);
+    int_key = MyInt_AsLongLong(key);
     if(PyErr_Occurred()){
       return NULL;
     }
 
-    PyObject **result = InternTable_lookup(&self->table, int_key);
+    result = InternTable_lookup(&self->table, int_key);
     if(*result == NULL){
         return Py_None;
     }
@@ -1385,13 +1390,16 @@ static PyObject *InternTable_getitem(InternTableObject *self, PyObject *key)
 
 static int InternTable_setitem(InternTableObject *self, PyObject *key, PyObject *value)
 {
+    PY_LONG_LONG int_key;
+    PyObject **result;
+
     assert(self->table.entries);
 
     PyErr_Clear();
-    uint64_t int_key = PyLong_AsUnsignedLongLong(key);
+    int_key = MyInt_AsLongLong(key);
     if(PyErr_Occurred()) return RET_ERROR;
 
-    PyObject **result = InternTable_lookup(&self->table, int_key);
+    result = InternTable_lookup(&self->table, int_key);
     if(*result != NULL){
         Py_XDECREF(*result);
     }

coverage/ctracer/tracer.h

@@ -8,7 +8,6 @@
 #include "structmember.h"
 #include "frameobject.h"
 #include "opcode.h"
-#include <stdint.h>
 
 #include "datastack.h"
 
@@ -25,13 +24,13 @@ that in the common case where the tracer has already seen the key somewhere we
 don't need to allocate a new one. This can significantly speed up tracing.
 */
 typedef struct InternEntry {
-    uint64_t key;
+    PY_LONG_LONG key;
     PyObject *value;
 } InternEntry;
 
 typedef struct InternTable {
     /* Store the value keyed off zero separately. This allows us to use a key
-       of zero as a not-set indicator. */ 
+       of zero as a not-set indicator. */
     PyObject * zero_value;
 
     /* The number of elements in our entries array (including absent elements).
@@ -46,7 +45,7 @@ typedef struct InternTable {
        the same fraction of capacity. */
     size_t max_fill;
 
-    /* Essentially (key, value) tuples where keys are uint64_t and values are
+    /* Essentially (key, value) tuples where keys are PY_LONG_LONG and values are
       *PyObject. Values are owned by the tracer and will have their refcount
       decremented appropriately on release.*/
     InternEntry * entries;
@@ -58,7 +57,7 @@ typedef struct InternTable {
    else.
 */
 typedef struct InternTableObject{
-    PyObject_HEAD;
+    PyObject_HEAD
     InternTable table;
 } InternTableObject;
 

coverage/ctracer/util.h

@@ -24,6 +24,7 @@
 #define MyText_FromFormat               PyUnicode_FromFormat
 #define MyInt_FromInt(i)                PyLong_FromLong((long)i)
 #define MyInt_AsInt(o)                  (int)PyLong_AsLong(o)
+#define MyInt_AsLongLong(o)             PyLong_AsUnsignedLongLong(o)
 #define MyText_InternFromString(s)      PyUnicode_InternFromString(s)
 
 #define MyType_HEAD_INIT                PyVarObject_HEAD_INIT(NULL, 0)
@@ -37,6 +38,7 @@
 #define MyText_AsString(o)              PyString_AsString(o)
 #define MyText_FromFormat               PyUnicode_FromFormat
 #define MyInt_FromInt(i)                PyInt_FromLong((long)i)
+#define MyInt_AsLongLong(o)             PyInt_AsUnsignedLongLongMask(o)
 #define MyInt_AsInt(o)                  (int)PyInt_AsLong(o)
 #define MyText_InternFromString(s)      PyString_InternFromString(s)
 

tests/test_intern_table.py

@@ -1,12 +1,22 @@
+import sys
+
 from tests.coveragetest import CoverageTest
 
 from hypothesis import given, example
 import hypothesis.strategies as st
-from coverage.tracer import InternTable
-import sys
+import pytest
+
+from coverage import env
 
+if env.C_TRACER:
+    from coverage.tracer import InternTable
 
+
+@pytest.mark.skipif(not env.C_TRACER, reason="Only the C tracer has refcounting issues")
 class TestInternTable(CoverageTest):
+
+    run_in_temp_dir = False
+
     @example([0])
     @given(st.lists(st.integers(0, 2 ** 64 - 1), unique=True))
     def test_interns_as_none_by_default(self, ls):