Mirrors
/
cpython
mirror of https://github.com/python/cpython
3
0
Fork 0
Code Releases Activity
Browse Source

bpo-9263: _PyXXX_CheckConsistency() use _PyObject_ASSERT() (GH-10108) 

Use _PyObject_ASSERT() in:

* _PyDict_CheckConsistency()
* _PyType_CheckConsistency()
* _PyUnicode_CheckConsistency()

_PyObject_ASSERT() dumps the faulty object if the assertion fails
to help debugging.
pull/10133/head
Victor Stinner 7 years ago
committed by GitHub
parent
0862505a03
commit
50fe3f8913
No known key found for this signature in database GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 64 additions and 52 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 30
      Objects/dictobject.c
  2. 10
      Objects/typeobject.c
  3. 76
      Objects/unicodeobject.c

30
Objects/dictobject.c
View File

@ -439,6 +439,8 @@ static PyObject *empty_values[1] = { NULL };
static int
_PyDict_CheckConsistency(PyDictObject *mp)
{
#define ASSERT(expr) _PyObject_ASSERT((PyObject *)mp, (expr))
PyDictKeysObject *keys = mp->ma_keys;
int splitted = _PyDict_HasSplitTable(mp);
Py_ssize_t usable = USABLE_FRACTION(keys->dk_size);
@ -447,23 +449,23 @@ _PyDict_CheckConsistency(PyDictObject *mp)
Py_ssize_t i;
#endif
assert(0 <= mp->ma_used && mp->ma_used <= usable);
assert(IS_POWER_OF_2(keys->dk_size));
assert(0 <= keys->dk_usable
ASSERT(0 <= mp->ma_used && mp->ma_used <= usable);
ASSERT(IS_POWER_OF_2(keys->dk_size));
ASSERT(0 <= keys->dk_usable
&& keys->dk_usable <= usable);
assert(0 <= keys->dk_nentries
ASSERT(0 <= keys->dk_nentries
&& keys->dk_nentries <= usable);
assert(keys->dk_usable + keys->dk_nentries <= usable);
ASSERT(keys->dk_usable + keys->dk_nentries <= usable);
if (!splitted) {
/* combined table */
assert(keys->dk_refcnt == 1);
ASSERT(keys->dk_refcnt == 1);
}
#ifdef DEBUG_PYDICT
for (i=0; i < keys->dk_size; i++) {
Py_ssize_t ix = dk_get_index(keys, i);
assert(DKIX_DUMMY <= ix && ix <= usable);
ASSERT(DKIX_DUMMY <= ix && ix <= usable);
}
for (i=0; i < usable; i++) {
@ -473,32 +475,34 @@ _PyDict_CheckConsistency(PyDictObject *mp)
if (key != NULL) {
if (PyUnicode_CheckExact(key)) {
Py_hash_t hash = ((PyASCIIObject *)key)->hash;
assert(hash != -1);
assert(entry->me_hash == hash);
ASSERT(hash != -1);
ASSERT(entry->me_hash == hash);
}
else {
/* test_dict fails if PyObject_Hash() is called again */
assert(entry->me_hash != -1);
ASSERT(entry->me_hash != -1);
}
if (!splitted) {
assert(entry->me_value != NULL);
ASSERT(entry->me_value != NULL);
}
}
if (splitted) {
assert(entry->me_value == NULL);
ASSERT(entry->me_value == NULL);
}
}
if (splitted) {
/* splitted table */
for (i=0; i < mp->ma_used; i++) {
assert(mp->ma_values[i] != NULL);
ASSERT(mp->ma_values[i] != NULL);
}
}
#endif
return 1;
#undef ASSERT
}
#endif

10
Objects/typeobject.c
View File

@ -134,15 +134,19 @@ skip_signature(const char *doc)
static int
_PyType_CheckConsistency(PyTypeObject *type)
{
#define ASSERT(expr) _PyObject_ASSERT((PyObject *)type, (expr))
if (!(type->tp_flags & Py_TPFLAGS_READY)) {
/* don't check types before PyType_Ready() */
return 1;
}
assert(!(type->tp_flags & Py_TPFLAGS_READYING));
assert(type->tp_mro != NULL && PyTuple_Check(type->tp_mro));
assert(type->tp_dict != NULL);
ASSERT(!(type->tp_flags & Py_TPFLAGS_READYING));
ASSERT(type->tp_mro != NULL && PyTuple_Check(type->tp_mro));
ASSERT(type->tp_dict != NULL);
return 1;
#undef ASSERT
}
#endif

76
Objects/unicodeobject.c
View File

@ -363,17 +363,19 @@ PyUnicode_GetMax(void)
int
_PyUnicode_CheckConsistency(PyObject *op, int check_content)
{
#define ASSERT(expr) _PyObject_ASSERT(op, (expr))
PyASCIIObject *ascii;
unsigned int kind;
assert(PyUnicode_Check(op));
ASSERT(PyUnicode_Check(op));
ascii = (PyASCIIObject *)op;
kind = ascii->state.kind;
if (ascii->state.ascii == 1 && ascii->state.compact == 1) {
assert(kind == PyUnicode_1BYTE_KIND);
assert(ascii->state.ready == 1);
ASSERT(kind == PyUnicode_1BYTE_KIND);
ASSERT(ascii->state.ready == 1);
}
else {
PyCompactUnicodeObject *compact = (PyCompactUnicodeObject *)op;
@ -381,41 +383,41 @@ _PyUnicode_CheckConsistency(PyObject *op, int check_content)
if (ascii->state.compact == 1) {
data = compact + 1;
assert(kind == PyUnicode_1BYTE_KIND
ASSERT(kind == PyUnicode_1BYTE_KIND
|| kind == PyUnicode_2BYTE_KIND
|| kind == PyUnicode_4BYTE_KIND);
assert(ascii->state.ascii == 0);
assert(ascii->state.ready == 1);
assert (compact->utf8 != data);
ASSERT(ascii->state.ascii == 0);
ASSERT(ascii->state.ready == 1);
ASSERT (compact->utf8 != data);
}
else {
PyUnicodeObject *unicode = (PyUnicodeObject *)op;
data = unicode->data.any;
if (kind == PyUnicode_WCHAR_KIND) {
assert(ascii->length == 0);
assert(ascii->hash == -1);
assert(ascii->state.compact == 0);
assert(ascii->state.ascii == 0);
assert(ascii->state.ready == 0);
assert(ascii->state.interned == SSTATE_NOT_INTERNED);
assert(ascii->wstr != NULL);
assert(data == NULL);
assert(compact->utf8 == NULL);
ASSERT(ascii->length == 0);
ASSERT(ascii->hash == -1);
ASSERT(ascii->state.compact == 0);
ASSERT(ascii->state.ascii == 0);
ASSERT(ascii->state.ready == 0);
ASSERT(ascii->state.interned == SSTATE_NOT_INTERNED);
ASSERT(ascii->wstr != NULL);
ASSERT(data == NULL);
ASSERT(compact->utf8 == NULL);
}
else {
assert(kind == PyUnicode_1BYTE_KIND
ASSERT(kind == PyUnicode_1BYTE_KIND
|| kind == PyUnicode_2BYTE_KIND
|| kind == PyUnicode_4BYTE_KIND);
assert(ascii->state.compact == 0);
assert(ascii->state.ready == 1);
assert(data != NULL);
ASSERT(ascii->state.compact == 0);
ASSERT(ascii->state.ready == 1);
ASSERT(data != NULL);
if (ascii->state.ascii) {
assert (compact->utf8 == data);
assert (compact->utf8_length == ascii->length);
ASSERT (compact->utf8 == data);
ASSERT (compact->utf8_length == ascii->length);
}
else
assert (compact->utf8 != data);
ASSERT (compact->utf8 != data);
}
}
if (kind != PyUnicode_WCHAR_KIND) {
@ -427,16 +429,16 @@ _PyUnicode_CheckConsistency(PyObject *op, int check_content)
#endif
)
{
assert(ascii->wstr == data);
assert(compact->wstr_length == ascii->length);
ASSERT(ascii->wstr == data);
ASSERT(compact->wstr_length == ascii->length);
} else
assert(ascii->wstr != data);
ASSERT(ascii->wstr != data);
}
if (compact->utf8 == NULL)
assert(compact->utf8_length == 0);
ASSERT(compact->utf8_length == 0);
if (ascii->wstr == NULL)
assert(compact->wstr_length == 0);
ASSERT(compact->wstr_length == 0);
}
/* check that the best kind is used */
if (check_content && kind != PyUnicode_WCHAR_KIND)
@ -455,23 +457,25 @@ _PyUnicode_CheckConsistency(PyObject *op, int check_content)
}
if (kind == PyUnicode_1BYTE_KIND) {
if (ascii->state.ascii == 0) {
assert(maxchar >= 128);
assert(maxchar <= 255);
ASSERT(maxchar >= 128);
ASSERT(maxchar <= 255);
}
else
assert(maxchar < 128);
ASSERT(maxchar < 128);
}
else if (kind == PyUnicode_2BYTE_KIND) {
assert(maxchar >= 0x100);
assert(maxchar <= 0xFFFF);
ASSERT(maxchar >= 0x100);
ASSERT(maxchar <= 0xFFFF);
}
else {
assert(maxchar >= 0x10000);
assert(maxchar <= MAX_UNICODE);
ASSERT(maxchar >= 0x10000);
ASSERT(maxchar <= MAX_UNICODE);
}
assert(PyUnicode_READ(kind, data, ascii->length) == 0);
ASSERT(PyUnicode_READ(kind, data, ascii->length) == 0);
}
return 1;
#undef ASSERT
}
#endif

Write Preview
Loading…
Cancel
Save