Repaired the debug Windows deaths in test_descr, by allocating enough

tim-one · tim-one · commit 406fe3b1c029 · 2001-10-06T19:04:01.000Z
pad memory to properly align the __dict__ pointer in all cases.

gcmodule.c/objimpl.h, _PyObject_GC_Malloc:
+ Added a "padding" argument so that this flavor of malloc can allocate
  enough bytes for alignment padding (it can't know this is needed, but
  its callers do).

typeobject.c, PyType_GenericAlloc:
+ Allocated enough bytes to align the __dict__ pointer.
+ Sped and simplified the round-up-to-PTRSIZE logic.
+ Added blank lines so I could parse the if/else blocks &lt;0.7 wink&gt;.
diff --git a/Include/objimpl.h b/Include/objimpl.h
@@ -230,7 +230,8 @@ extern DL_IMPORT(void) _PyObject_Del(PyObject *);
 #define PyObject_IS_GC(o) (PyType_IS_GC((o)->ob_type) && \
 	((o)->ob_type->tp_is_gc == NULL || (o)->ob_type->tp_is_gc(o)))
 
-extern DL_IMPORT(PyObject *) _PyObject_GC_Malloc(PyTypeObject *, int);
+extern DL_IMPORT(PyObject *) _PyObject_GC_Malloc(PyTypeObject *,
+					int nitems, size_t padding);
 extern DL_IMPORT(PyVarObject *) _PyObject_GC_Resize(PyVarObject *, int);
 
 #define PyObject_GC_Resize(type, op, n) \
diff --git a/Modules/gcmodule.c b/Modules/gcmodule.c
@@ -798,13 +798,14 @@ _PyObject_GC_UnTrack(PyObject *op)
 }
 
 PyObject *
-_PyObject_GC_Malloc(PyTypeObject *tp, int size)
+_PyObject_GC_Malloc(PyTypeObject *tp, int nitems, size_t padding)
 {
 	PyObject *op;
 #ifdef WITH_CYCLE_GC
-	const size_t nbytes = sizeof(PyGC_Head) +
-			      (size_t)_PyObject_VAR_SIZE(tp, size);
-	PyGC_Head *g = PyObject_MALLOC(nbytes);						
+	const size_t basic = (size_t)_PyObject_VAR_SIZE(tp, nitems);
+	const size_t nbytes = sizeof(PyGC_Head) + basic + padding;
+
+	PyGC_Head *g = PyObject_MALLOC(nbytes);
 	if (g == NULL)
 		return (PyObject *)PyErr_NoMemory();
 	g->gc_next = NULL;
@@ -820,7 +821,7 @@ _PyObject_GC_Malloc(PyTypeObject *tp, int size)
 	}
 	op = FROM_GC(g);
 #else
-	op = PyObject_MALLOC(_PyObject_VAR_SIZE(tp, size));
+	op = PyObject_MALLOC(_PyObject_VAR_SIZE(tp, nitems) + padding);
 	if (op == NULL)
 		return (PyObject *)PyErr_NoMemory();
 
@@ -831,14 +832,14 @@ _PyObject_GC_Malloc(PyTypeObject *tp, int size)
 PyObject *
 _PyObject_GC_New(PyTypeObject *tp)
 {
-	PyObject *op = _PyObject_GC_Malloc(tp, 0);
+	PyObject *op = _PyObject_GC_Malloc(tp, 0, 0);
 	return PyObject_INIT(op, tp);
 }
 
 PyVarObject *
 _PyObject_GC_NewVar(PyTypeObject *tp, int size)
 {
-	PyVarObject *op = (PyVarObject *) _PyObject_GC_Malloc(tp, size);
+	PyVarObject *op = (PyVarObject *) _PyObject_GC_Malloc(tp, size, 0);
 	return PyObject_INIT_VAR(op, tp, size);
 }
 
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
@@ -192,32 +192,42 @@ PyType_GenericAlloc(PyTypeObject *type, int nitems)
 {
 #define PTRSIZE (sizeof(PyObject *))
 
-	int size;
+	size_t size = (size_t)_PyObject_VAR_SIZE(type, nitems);
+	size_t padding = 0;
 	PyObject *obj;
 
-	/* Inline PyObject_New() so we can zero the memory */
-	size = _PyObject_VAR_SIZE(type, nitems);
-	/* Round up size, if necessary, so we fully zero out __dict__ */
-	if (type->tp_itemsize % PTRSIZE != 0) {
-		size += PTRSIZE - 1;
-		size /= PTRSIZE;
-		size *= PTRSIZE;
-	}
-	if (PyType_IS_GC(type)) {
-		obj = _PyObject_GC_Malloc(type, nitems);
+	/* Round up size, if necessary, so that the __dict__ pointer
+	   following the variable part is properly aligned for the platform.
+	   This is needed only for types with a vrbl number of items
+	   before the __dict__ pointer == types that record the dict offset
+	   as a negative offset from the end of the object.  If tp_dictoffset
+	   is 0, there is no __dict__; if positive, tp_dict was declared in a C
+	   struct so the compiler already took care of aligning it. */
+        if (type->tp_dictoffset < 0) {
+		padding = PTRSIZE - size % PTRSIZE;
+		if (padding == PTRSIZE)
+			padding = 0;
+		size += padding;
 	}
-	else {
+
+	if (PyType_IS_GC(type))
+		obj = _PyObject_GC_Malloc(type, nitems, padding);
+	else
 		obj = PyObject_MALLOC(size);
-	}
+
 	if (obj == NULL)
 		return PyErr_NoMemory();
+
 	memset(obj, '\0', size);
+
 	if (type->tp_flags & Py_TPFLAGS_HEAPTYPE)
 		Py_INCREF(type);
+
 	if (type->tp_itemsize == 0)
 		PyObject_INIT(obj, type);
 	else
 		(void) PyObject_INIT_VAR((PyVarObject *)obj, type, nitems);
+
 	if (PyType_IS_GC(type))
 		_PyObject_GC_TRACK(obj);
 	return obj;

Original file line number	Diff line number	Diff line change
`@@ -798,13 +798,14 @@ _PyObject_GC_UnTrack(PyObject *op)`
`798`	`798`	`}`
`799`	`799`
`800`	`800`	`PyObject *`
`801`		`-_PyObject_GC_Malloc(PyTypeObject *tp, int size)`
	`801`	`+_PyObject_GC_Malloc(PyTypeObject *tp, int nitems, size_t padding)`
`802`	`802`	`{`
`803`	`803`	`PyObject *op;`
`804`	`804`	`#ifdef WITH_CYCLE_GC`
`805`		`- const size_t nbytes = sizeof(PyGC_Head) +`
`806`		`- (size_t)_PyObject_VAR_SIZE(tp, size);`
`807`		`- PyGC_Head *g = PyObject_MALLOC(nbytes);`
	`805`	`+ const size_t basic = (size_t)_PyObject_VAR_SIZE(tp, nitems);`
	`806`	`+ const size_t nbytes = sizeof(PyGC_Head) + basic + padding;`
	`807`	`+`
	`808`	`+ PyGC_Head *g = PyObject_MALLOC(nbytes);`
`808`	`809`	`if (g == NULL)`
`809`	`810`	`return (PyObject *)PyErr_NoMemory();`
`810`	`811`	`g->gc_next = NULL;`
`@@ -820,7 +821,7 @@ _PyObject_GC_Malloc(PyTypeObject *tp, int size)`
`820`	`821`	`}`
`821`	`822`	`op = FROM_GC(g);`
`822`	`823`	`#else`
`823`		`- op = PyObject_MALLOC(_PyObject_VAR_SIZE(tp, size));`
	`824`	`+ op = PyObject_MALLOC(_PyObject_VAR_SIZE(tp, nitems) + padding);`
`824`	`825`	`if (op == NULL)`
`825`	`826`	`return (PyObject *)PyErr_NoMemory();`
`826`	`827`
`@@ -831,14 +832,14 @@ _PyObject_GC_Malloc(PyTypeObject *tp, int size)`
`831`	`832`	`PyObject *`
`832`	`833`	`_PyObject_GC_New(PyTypeObject *tp)`
`833`	`834`	`{`
`834`		`- PyObject *op = _PyObject_GC_Malloc(tp, 0);`
	`835`	`+ PyObject *op = _PyObject_GC_Malloc(tp, 0, 0);`
`835`	`836`	`return PyObject_INIT(op, tp);`
`836`	`837`	`}`
`837`	`838`
`838`	`839`	`PyVarObject *`
`839`	`840`	`_PyObject_GC_NewVar(PyTypeObject *tp, int size)`
`840`	`841`	`{`
`841`		`- PyVarObject op = (PyVarObject ) _PyObject_GC_Malloc(tp, size);`
	`842`	`+ PyVarObject op = (PyVarObject ) _PyObject_GC_Malloc(tp, size, 0);`
`842`	`843`	`return PyObject_INIT_VAR(op, tp, size);`
`843`	`844`	`}`
`844`	`845`