mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-07-16 07:45:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

bpo-46072: Output stats as markdown with collapsible sections. (GH-31228)

Browse source
This commit is contained in:
Mark Shannon 2022-02-09 12:30:26 +00:00 • committed by GitHub
parent 77bab59c8a
commit f71a69aa92
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 381 additions and 257 deletions
Download patch file Download diff file Expand all files Collapse all files

382
Python/specialize.c
View file

@ -481,112 +481,123 @@ initial_counter_value(void) {
#define SPEC_FAIL_OUT_OF_VERSIONS 3
#define SPEC_FAIL_OUT_OF_RANGE 4
#define SPEC_FAIL_EXPECTED_ERROR 5
#define SPEC_FAIL_WRONG_NUMBER_ARGUMENTS 6
#define SPEC_FAIL_LOAD_GLOBAL_NON_STRING_OR_SPLIT 18
/* Attributes */
#define SPEC_FAIL_NON_STRING_OR_SPLIT 6
#define SPEC_FAIL_MODULE_ATTR_NOT_FOUND 7
#define SPEC_FAIL_OVERRIDING_DESCRIPTOR 8
#define SPEC_FAIL_NON_OVERRIDING_DESCRIPTOR 9
#define SPEC_FAIL_NOT_DESCRIPTOR 10
#define SPEC_FAIL_METHOD 11
#define SPEC_FAIL_MUTABLE_CLASS 12
#define SPEC_FAIL_PROPERTY 13
#define SPEC_FAIL_NON_OBJECT_SLOT 14
#define SPEC_FAIL_READ_ONLY 15
#define SPEC_FAIL_AUDITED_SLOT 16
#define SPEC_FAIL_NOT_MANAGED_DICT 17
#define SPEC_FAIL_ATTR_OVERRIDING_DESCRIPTOR 8
#define SPEC_FAIL_ATTR_NON_OVERRIDING_DESCRIPTOR 9
#define SPEC_FAIL_ATTR_NOT_DESCRIPTOR 10
#define SPEC_FAIL_ATTR_METHOD 11
#define SPEC_FAIL_ATTR_MUTABLE_CLASS 12
#define SPEC_FAIL_ATTR_PROPERTY 13
#define SPEC_FAIL_ATTR_NON_OBJECT_SLOT 14
#define SPEC_FAIL_ATTR_READ_ONLY 15
#define SPEC_FAIL_ATTR_AUDITED_SLOT 16
#define SPEC_FAIL_ATTR_NOT_MANAGED_DICT 17
#define SPEC_FAIL_ATTR_NON_STRING_OR_SPLIT 18
#define SPEC_FAIL_ATTR_MODULE_ATTR_NOT_FOUND 19
/* Methods */
#define SPEC_FAIL_IS_ATTR 15
#define SPEC_FAIL_DICT_SUBCLASS 16
#define SPEC_FAIL_BUILTIN_CLASS_METHOD 17
#define SPEC_FAIL_CLASS_METHOD_OBJ 18
#define SPEC_FAIL_OBJECT_SLOT 19
#define SPEC_FAIL_HAS_DICT 20
#define SPEC_FAIL_HAS_MANAGED_DICT 21
#define SPEC_FAIL_INSTANCE_ATTRIBUTE 22
#define SPEC_FAIL_METACLASS_ATTRIBUTE 23
#define SPEC_FAIL_LOAD_METHOD_OVERRIDING_DESCRIPTOR 8
#define SPEC_FAIL_LOAD_METHOD_NON_OVERRIDING_DESCRIPTOR 9
#define SPEC_FAIL_LOAD_METHOD_NOT_DESCRIPTOR 10
#define SPEC_FAIL_LOAD_METHOD_METHOD 11
#define SPEC_FAIL_LOAD_METHOD_MUTABLE_CLASS 12
#define SPEC_FAIL_LOAD_METHOD_PROPERTY 13
#define SPEC_FAIL_LOAD_METHOD_NON_OBJECT_SLOT 14
#define SPEC_FAIL_LOAD_METHOD_IS_ATTR 15
#define SPEC_FAIL_LOAD_METHOD_DICT_SUBCLASS 16
#define SPEC_FAIL_LOAD_METHOD_BUILTIN_CLASS_METHOD 17
#define SPEC_FAIL_LOAD_METHOD_CLASS_METHOD_OBJ 18
#define SPEC_FAIL_LOAD_METHOD_OBJECT_SLOT 19
#define SPEC_FAIL_LOAD_METHOD_HAS_DICT 20
#define SPEC_FAIL_LOAD_METHOD_HAS_MANAGED_DICT 21
#define SPEC_FAIL_LOAD_METHOD_INSTANCE_ATTRIBUTE 22
#define SPEC_FAIL_LOAD_METHOD_METACLASS_ATTRIBUTE 23
/* Binary subscr */
/* Binary subscr and store subscr */
#define SPEC_FAIL_ARRAY_INT 8
#define SPEC_FAIL_ARRAY_SLICE 9
#define SPEC_FAIL_LIST_SLICE 10
#define SPEC_FAIL_TUPLE_SLICE 11
#define SPEC_FAIL_STRING_INT 12
#define SPEC_FAIL_STRING_SLICE 13
#define SPEC_FAIL_BUFFER_INT 15
#define SPEC_FAIL_BUFFER_SLICE 16
#define SPEC_FAIL_SEQUENCE_INT 17
#define SPEC_FAIL_SUBSCR_ARRAY_INT 8
#define SPEC_FAIL_SUBSCR_ARRAY_SLICE 9
#define SPEC_FAIL_SUBSCR_LIST_SLICE 10
#define SPEC_FAIL_SUBSCR_TUPLE_SLICE 11
#define SPEC_FAIL_SUBSCR_STRING_INT 12
#define SPEC_FAIL_SUBSCR_STRING_SLICE 13
#define SPEC_FAIL_SUBSCR_BUFFER_INT 15
#define SPEC_FAIL_SUBSCR_BUFFER_SLICE 16
#define SPEC_FAIL_SUBSCR_SEQUENCE_INT 17
/* Store subscr */
#define SPEC_FAIL_BYTEARRAY_INT 18
#define SPEC_FAIL_BYTEARRAY_SLICE 19
#define SPEC_FAIL_PY_SIMPLE 20
#define SPEC_FAIL_PY_OTHER 21
#define SPEC_FAIL_DICT_SUBCLASS_NO_OVERRIDE 22
#define SPEC_FAIL_SUBSCR_BYTEARRAY_INT 18
#define SPEC_FAIL_SUBSCR_BYTEARRAY_SLICE 19
#define SPEC_FAIL_SUBSCR_PY_SIMPLE 20
#define SPEC_FAIL_SUBSCR_PY_OTHER 21
#define SPEC_FAIL_SUBSCR_DICT_SUBCLASS_NO_OVERRIDE 22
/* Binary add */
#define SPEC_FAIL_NON_FUNCTION_SCOPE 11
#define SPEC_FAIL_DIFFERENT_TYPES 12
#define SPEC_FAIL_BINARY_OP_DIFFERENT_TYPES 12
/* Calls */
#define SPEC_FAIL_COMPLEX_PARAMETERS 8
#define SPEC_FAIL_WRONG_NUMBER_ARGUMENTS 9
#define SPEC_FAIL_CO_NOT_OPTIMIZED 10
#define SPEC_FAIL_CALL_COMPLEX_PARAMETERS 9
#define SPEC_FAIL_CALL_CO_NOT_OPTIMIZED 10
/* SPEC_FAIL_METHOD defined as 11 above */
#define SPEC_FAIL_PYCFUNCTION 13
#define SPEC_FAIL_PYCFUNCTION_WITH_KEYWORDS 14
#define SPEC_FAIL_PYCFUNCTION_FAST_WITH_KEYWORDS 15
#define SPEC_FAIL_PYCFUNCTION_NOARGS 16
#define SPEC_FAIL_BAD_CALL_FLAGS 17
#define SPEC_FAIL_CLASS 18
#define SPEC_FAIL_PYTHON_CLASS 19
#define SPEC_FAIL_C_METHOD_CALL 20
#define SPEC_FAIL_BOUND_METHOD 21
#define SPEC_FAIL_CALL_INSTANCE_METHOD 11
#define SPEC_FAIL_CALL_CMETHOD 12
#define SPEC_FAIL_CALL_PYCFUNCTION 13
#define SPEC_FAIL_CALL_PYCFUNCTION_WITH_KEYWORDS 14
#define SPEC_FAIL_CALL_PYCFUNCTION_FAST_WITH_KEYWORDS 15
#define SPEC_FAIL_CALL_PYCFUNCTION_NOARGS 16
#define SPEC_FAIL_CALL_BAD_CALL_FLAGS 17
#define SPEC_FAIL_CALL_CLASS 18
#define SPEC_FAIL_CALL_PYTHON_CLASS 19
#define SPEC_FAIL_CALL_C_METHOD_CALL 20
#define SPEC_FAIL_CALL_BOUND_METHOD 21
#define SPEC_FAIL_CALL_STR 22
#define SPEC_FAIL_CLASS_NO_VECTORCALL 23
#define SPEC_FAIL_CLASS_MUTABLE 24
#define SPEC_FAIL_KWNAMES 25
#define SPEC_FAIL_METHOD_WRAPPER 26
#define SPEC_FAIL_OPERATOR_WRAPPER 27
#define SPEC_FAIL_CALL_CLASS_NO_VECTORCALL 23
#define SPEC_FAIL_CALL_CLASS_MUTABLE 24
#define SPEC_FAIL_CALL_KWNAMES 25
#define SPEC_FAIL_CALL_METHOD_WRAPPER 26
#define SPEC_FAIL_CALL_OPERATOR_WRAPPER 27
/* COMPARE_OP */
#define SPEC_FAIL_STRING_COMPARE 13
#define SPEC_FAIL_NOT_FOLLOWED_BY_COND_JUMP 14
#define SPEC_FAIL_BIG_INT 15
#define SPEC_FAIL_COMPARE_BYTES 16
#define SPEC_FAIL_COMPARE_TUPLE 17
#define SPEC_FAIL_COMPARE_LIST 18
#define SPEC_FAIL_COMPARE_SET 19
#define SPEC_FAIL_COMPARE_BOOL 20
#define SPEC_FAIL_COMPARE_BASEOBJECT 21
#define SPEC_FAIL_COMPARE_FLOAT_LONG 22
#define SPEC_FAIL_COMPARE_LONG_FLOAT 23
#define SPEC_FAIL_COMPARE_OP_DIFFERENT_TYPES 12
#define SPEC_FAIL_COMPARE_OP_STRING 13
#define SPEC_FAIL_COMPARE_OP_NOT_FOLLOWED_BY_COND_JUMP 14
#define SPEC_FAIL_COMPARE_OP_BIG_INT 15
#define SPEC_FAIL_COMPARE_OP_BYTES 16
#define SPEC_FAIL_COMPARE_OP_TUPLE 17
#define SPEC_FAIL_COMPARE_OP_LIST 18
#define SPEC_FAIL_COMPARE_OP_SET 19
#define SPEC_FAIL_COMPARE_OP_BOOL 20
#define SPEC_FAIL_COMPARE_OP_BASEOBJECT 21
#define SPEC_FAIL_COMPARE_OP_FLOAT_LONG 22
#define SPEC_FAIL_COMPARE_OP_LONG_FLOAT 23
/* FOR_ITER */
#define SPEC_FAIL_ITER_GENERATOR 10
#define SPEC_FAIL_ITER_COROUTINE 11
#define SPEC_FAIL_ITER_ASYNC_GENERATOR 12
#define SPEC_FAIL_ITER_LIST 13
#define SPEC_FAIL_ITER_TUPLE 14
#define SPEC_FAIL_ITER_SET 15
#define SPEC_FAIL_ITER_STRING 16
#define SPEC_FAIL_ITER_BYTES 17
#define SPEC_FAIL_ITER_RANGE 18
#define SPEC_FAIL_ITER_ITERTOOLS 19
#define SPEC_FAIL_ITER_DICT_KEYS 20
#define SPEC_FAIL_ITER_DICT_ITEMS 21
#define SPEC_FAIL_ITER_DICT_VALUES 22
#define SPEC_FAIL_ITER_ENUMERATE 23
#define SPEC_FAIL_FOR_ITER_GENERATOR 10
#define SPEC_FAIL_FOR_ITER_COROUTINE 11
#define SPEC_FAIL_FOR_ITER_ASYNC_GENERATOR 12
#define SPEC_FAIL_FOR_ITER_LIST 13
#define SPEC_FAIL_FOR_ITER_TUPLE 14
#define SPEC_FAIL_FOR_ITER_SET 15
#define SPEC_FAIL_FOR_ITER_STRING 16
#define SPEC_FAIL_FOR_ITER_BYTES 17
#define SPEC_FAIL_FOR_ITER_RANGE 18
#define SPEC_FAIL_FOR_ITER_ITERTOOLS 19
#define SPEC_FAIL_FOR_ITER_DICT_KEYS 20
#define SPEC_FAIL_FOR_ITER_DICT_ITEMS 21
#define SPEC_FAIL_FOR_ITER_DICT_VALUES 22
#define SPEC_FAIL_FOR_ITER_ENUMERATE 23
/* UNPACK_SEQUENCE */
#define SPEC_FAIL_TUPLE 10
#define SPEC_FAIL_LIST 11
#define SPEC_FAIL_UNPACK_SEQUENCE_TUPLE 10
#define SPEC_FAIL_UNPACK_SEQUENCE_LIST 11
static int
@ -604,14 +615,14 @@ specialize_module_load_attr(
return -1;
}
if (dict->ma_keys->dk_kind != DICT_KEYS_UNICODE) {
SPECIALIZATION_FAIL(opcode, SPEC_FAIL_NON_STRING_OR_SPLIT);
SPECIALIZATION_FAIL(opcode, SPEC_FAIL_ATTR_NON_STRING_OR_SPLIT);
return -1;
}
Py_ssize_t index = _PyDict_GetItemHint(dict, &_Py_ID(__getattr__), -1,
&value);
assert(index != DKIX_ERROR);
if (index != DKIX_EMPTY) {
SPECIALIZATION_FAIL(opcode, SPEC_FAIL_MODULE_ATTR_NOT_FOUND);
SPECIALIZATION_FAIL(opcode, SPEC_FAIL_ATTR_MODULE_ATTR_NOT_FOUND);
return -1;
}
index = _PyDict_GetItemHint(dict, name, -1, &value);
@ -721,7 +732,7 @@ specialize_dict_access(
kind == BUILTIN_CLASSMETHOD || kind == PYTHON_CLASSMETHOD);
// No descriptor, or non overriding.
if ((type->tp_flags & Py_TPFLAGS_MANAGED_DICT) == 0) {
SPECIALIZATION_FAIL(base_op, SPEC_FAIL_NOT_MANAGED_DICT);
SPECIALIZATION_FAIL(base_op, SPEC_FAIL_ATTR_NOT_MANAGED_DICT);
return 0;
}
PyObject **dictptr = _PyObject_ManagedDictPointer(owner);
@ -783,13 +794,13 @@ _Py_Specialize_LoadAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name, Sp
DescriptorClassification kind = analyze_descriptor(type, name, &descr, 0);
switch(kind) {
case OVERRIDING:
SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_OVERRIDING_DESCRIPTOR);
SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_ATTR_OVERRIDING_DESCRIPTOR);
goto fail;
case METHOD:
SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_METHOD);
SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_ATTR_METHOD);
goto fail;
case PROPERTY:
SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_PROPERTY);
SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_ATTR_PROPERTY);
goto fail;
case OBJECT_SLOT:
{
@ -797,7 +808,7 @@ _Py_Specialize_LoadAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name, Sp
struct PyMemberDef *dmem = member->d_member;
Py_ssize_t offset = dmem->offset;
if (dmem->flags & PY_AUDIT_READ) {
SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_AUDITED_SLOT);
SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_ATTR_AUDITED_SLOT);
goto fail;
}
if (offset != (uint16_t)offset) {
@ -821,10 +832,10 @@ _Py_Specialize_LoadAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name, Sp
goto success;
}
case OTHER_SLOT:
SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_NON_OBJECT_SLOT);
SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_ATTR_NON_OBJECT_SLOT);
goto fail;
case MUTABLE:
SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_MUTABLE_CLASS);
SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_ATTR_MUTABLE_CLASS);
goto fail;
case GETSET_OVERRIDDEN:
SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_OVERRIDDEN);
@ -872,13 +883,13 @@ _Py_Specialize_StoreAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name, S
DescriptorClassification kind = analyze_descriptor(type, name, &descr, 1);
switch(kind) {
case OVERRIDING:
SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_OVERRIDING_DESCRIPTOR);
SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_ATTR_OVERRIDING_DESCRIPTOR);
goto fail;
case METHOD:
SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_METHOD);
SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_ATTR_METHOD);
goto fail;
case PROPERTY:
SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_PROPERTY);
SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_ATTR_PROPERTY);
goto fail;
case OBJECT_SLOT:
{
@ -886,7 +897,7 @@ _Py_Specialize_StoreAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name, S
struct PyMemberDef *dmem = member->d_member;
Py_ssize_t offset = dmem->offset;
if (dmem->flags & READONLY) {
SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_READ_ONLY);
SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_ATTR_READ_ONLY);
goto fail;
}
if (offset != (uint16_t)offset) {
@ -902,10 +913,10 @@ _Py_Specialize_StoreAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name, S
}
case DUNDER_CLASS:
case OTHER_SLOT:
SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_NON_OBJECT_SLOT);
SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_ATTR_NON_OBJECT_SLOT);
goto fail;
case MUTABLE:
SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_MUTABLE_CLASS);
SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_ATTR_MUTABLE_CLASS);
goto fail;
case GETSET_OVERRIDDEN:
SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_OVERRIDDEN);
@ -947,31 +958,31 @@ load_method_fail_kind(DescriptorClassification kind)
{
switch (kind) {
case OVERRIDING:
return SPEC_FAIL_OVERRIDING_DESCRIPTOR;
return SPEC_FAIL_LOAD_METHOD_OVERRIDING_DESCRIPTOR;
case METHOD:
return SPEC_FAIL_METHOD;
return SPEC_FAIL_LOAD_METHOD_METHOD;
case PROPERTY:
return SPEC_FAIL_PROPERTY;
return SPEC_FAIL_LOAD_METHOD_PROPERTY;
case OBJECT_SLOT:
return SPEC_FAIL_OBJECT_SLOT;
return SPEC_FAIL_LOAD_METHOD_OBJECT_SLOT;
case OTHER_SLOT:
return SPEC_FAIL_NON_OBJECT_SLOT;
return SPEC_FAIL_LOAD_METHOD_NON_OBJECT_SLOT;
case DUNDER_CLASS:
return SPEC_FAIL_OTHER;
case MUTABLE:
return SPEC_FAIL_MUTABLE_CLASS;
return SPEC_FAIL_LOAD_METHOD_MUTABLE_CLASS;
case GETSET_OVERRIDDEN:
return SPEC_FAIL_OVERRIDDEN;
case BUILTIN_CLASSMETHOD:
return SPEC_FAIL_BUILTIN_CLASS_METHOD;
return SPEC_FAIL_LOAD_METHOD_BUILTIN_CLASS_METHOD;
case PYTHON_CLASSMETHOD:
return SPEC_FAIL_CLASS_METHOD_OBJ;
return SPEC_FAIL_LOAD_METHOD_CLASS_METHOD_OBJ;
case NON_OVERRIDING:
return SPEC_FAIL_NON_OVERRIDING_DESCRIPTOR;
return SPEC_FAIL_LOAD_METHOD_NON_OVERRIDING_DESCRIPTOR;
case NON_DESCRIPTOR:
return SPEC_FAIL_NOT_DESCRIPTOR;
return SPEC_FAIL_LOAD_METHOD_NOT_DESCRIPTOR;
case ABSENT:
return SPEC_FAIL_INSTANCE_ATTRIBUTE;
return SPEC_FAIL_LOAD_METHOD_INSTANCE_ATTRIBUTE;
}
Py_UNREACHABLE();
}
@ -995,7 +1006,7 @@ specialize_class_load_method(PyObject *owner, _Py_CODEUNIT *instr, PyObject *nam
#ifdef Py_STATS
case ABSENT:
if (_PyType_Lookup(Py_TYPE(owner), name) != NULL) {
SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_METACLASS_ATTRIBUTE);
SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_LOAD_METHOD_METACLASS_ATTRIBUTE);
}
else {
SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_EXPECTED_ERROR);
@ -1051,13 +1062,13 @@ _Py_Specialize_LoadMethod(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name,
if (owner_cls->tp_flags & Py_TPFLAGS_MANAGED_DICT) {
PyObject **owner_dictptr = _PyObject_ManagedDictPointer(owner);
if (*owner_dictptr) {
SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_HAS_MANAGED_DICT);
SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_LOAD_METHOD_HAS_MANAGED_DICT);
goto fail;
}
PyDictKeysObject *keys = ((PyHeapTypeObject *)owner_cls)->ht_cached_keys;
Py_ssize_t index = _PyDictKeys_StringLookup(keys, name);
if (index != DKIX_EMPTY) {
SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_IS_ATTR);
SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_LOAD_METHOD_IS_ATTR);
goto fail;
}
uint32_t keys_version = _PyDictKeys_GetVersionForCurrentState(keys);
@ -1073,7 +1084,7 @@ _Py_Specialize_LoadMethod(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name,
*instr = _Py_MAKECODEUNIT(LOAD_METHOD_NO_DICT, _Py_OPARG(*instr));
}
else {
SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_HAS_DICT);
SPECIALIZATION_FAIL(LOAD_METHOD, SPEC_FAIL_LOAD_METHOD_HAS_DICT);
goto fail;
}
}
@ -1122,7 +1133,7 @@ _Py_Specialize_LoadGlobal(
PyDictKeysObject * globals_keys = ((PyDictObject *)globals)->ma_keys;
Py_ssize_t index = _PyDictKeys_StringLookup(globals_keys, name);
if (index == DKIX_ERROR) {
SPECIALIZATION_FAIL(LOAD_GLOBAL, SPEC_FAIL_NON_STRING_OR_SPLIT);
SPECIALIZATION_FAIL(LOAD_GLOBAL, SPEC_FAIL_LOAD_GLOBAL_NON_STRING_OR_SPLIT);
goto fail;
}
if (index != DKIX_EMPTY) {
@ -1144,7 +1155,7 @@ _Py_Specialize_LoadGlobal(
PyDictKeysObject * builtin_keys = ((PyDictObject *)builtins)->ma_keys;
index = _PyDictKeys_StringLookup(builtin_keys, name);
if (index == DKIX_ERROR) {
SPECIALIZATION_FAIL(LOAD_GLOBAL, SPEC_FAIL_NON_STRING_OR_SPLIT);
SPECIALIZATION_FAIL(LOAD_GLOBAL, SPEC_FAIL_LOAD_GLOBAL_NON_STRING_OR_SPLIT);
goto fail;
}
if (index != (uint16_t)index) {
@ -1183,34 +1194,34 @@ binary_subscr_fail_kind(PyTypeObject *container_type, PyObject *sub)
{
if (container_type == &PyUnicode_Type) {
if (PyLong_CheckExact(sub)) {
return SPEC_FAIL_STRING_INT;
return SPEC_FAIL_SUBSCR_STRING_INT;
}
if (PySlice_Check(sub)) {
return SPEC_FAIL_STRING_SLICE;
return SPEC_FAIL_SUBSCR_STRING_SLICE;
}
return SPEC_FAIL_OTHER;
}
else if (strcmp(container_type->tp_name, "array.array") == 0) {
if (PyLong_CheckExact(sub)) {
return SPEC_FAIL_ARRAY_INT;
return SPEC_FAIL_SUBSCR_ARRAY_INT;
}
if (PySlice_Check(sub)) {
return SPEC_FAIL_ARRAY_SLICE;
return SPEC_FAIL_SUBSCR_ARRAY_SLICE;
}
return SPEC_FAIL_OTHER;
}
else if (container_type->tp_as_buffer) {
if (PyLong_CheckExact(sub)) {
return SPEC_FAIL_BUFFER_INT;
return SPEC_FAIL_SUBSCR_BUFFER_INT;
}
if (PySlice_Check(sub)) {
return SPEC_FAIL_BUFFER_SLICE;
return SPEC_FAIL_SUBSCR_BUFFER_SLICE;
}
return SPEC_FAIL_OTHER;
}
else if (container_type->tp_as_sequence) {
if (PyLong_CheckExact(sub) && container_type->tp_as_sequence->sq_item) {
return SPEC_FAIL_SEQUENCE_INT;
return SPEC_FAIL_SUBSCR_SEQUENCE_INT;
}
}
return SPEC_FAIL_OTHER;
@ -1224,10 +1235,10 @@ static int
function_kind(PyCodeObject *code) {
int flags = code->co_flags;
if ((flags & (CO_VARKEYWORDS | CO_VARARGS)) || code->co_kwonlyargcount) {
return SPEC_FAIL_COMPLEX_PARAMETERS;
return SPEC_FAIL_CALL_COMPLEX_PARAMETERS;
}
if ((flags & CO_OPTIMIZED) == 0) {
return SPEC_FAIL_CO_NOT_OPTIMIZED;
return SPEC_FAIL_CALL_CO_NOT_OPTIMIZED;
}
return SIMPLE_FUNCTION;
}
@ -1244,7 +1255,7 @@ _Py_Specialize_BinarySubscr(
goto success;
}
SPECIALIZATION_FAIL(BINARY_SUBSCR,
PySlice_Check(sub) ? SPEC_FAIL_LIST_SLICE : SPEC_FAIL_OTHER);
PySlice_Check(sub) ? SPEC_FAIL_SUBSCR_LIST_SLICE : SPEC_FAIL_OTHER);
goto fail;
}
if (container_type == &PyTuple_Type) {
@ -1253,7 +1264,7 @@ _Py_Specialize_BinarySubscr(
goto success;
}
SPECIALIZATION_FAIL(BINARY_SUBSCR,
PySlice_Check(sub) ? SPEC_FAIL_TUPLE_SLICE : SPEC_FAIL_OTHER);
PySlice_Check(sub) ? SPEC_FAIL_SUBSCR_TUPLE_SLICE : SPEC_FAIL_OTHER);
goto fail;
}
if (container_type == &PyDict_Type) {
@ -1319,7 +1330,7 @@ _Py_Specialize_StoreSubscr(PyObject *container, PyObject *sub, _Py_CODEUNIT *ins
}
}
else if (PySlice_Check(sub)) {
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_LIST_SLICE);
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_LIST_SLICE);
goto fail;
}
else {
@ -1336,7 +1347,7 @@ _Py_Specialize_StoreSubscr(PyObject *container, PyObject *sub, _Py_CODEUNIT *ins
PyMappingMethods *as_mapping = container_type->tp_as_mapping;
if (as_mapping && (as_mapping->mp_ass_subscript
== PyDict_Type.tp_as_mapping->mp_ass_subscript)) {
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_DICT_SUBCLASS_NO_OVERRIDE);
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_DICT_SUBCLASS_NO_OVERRIDE);
goto fail;
}
if (PyObject_CheckBuffer(container)) {
@ -1345,10 +1356,10 @@ _Py_Specialize_StoreSubscr(PyObject *container, PyObject *sub, _Py_CODEUNIT *ins
}
else if (strcmp(container_type->tp_name, "array.array") == 0) {
if (PyLong_CheckExact(sub)) {
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_ARRAY_INT);
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_ARRAY_INT);
}
else if (PySlice_Check(sub)) {
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_ARRAY_SLICE);
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_ARRAY_SLICE);
}
else {
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_OTHER);
@ -1356,10 +1367,10 @@ _Py_Specialize_StoreSubscr(PyObject *container, PyObject *sub, _Py_CODEUNIT *ins
}
else if (PyByteArray_CheckExact(container)) {
if (PyLong_CheckExact(sub)) {
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_BYTEARRAY_INT);
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_BYTEARRAY_INT);
}
else if (PySlice_Check(sub)) {
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_BYTEARRAY_SLICE);
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_BYTEARRAY_SLICE);
}
else {
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_OTHER);
@ -1367,10 +1378,10 @@ _Py_Specialize_StoreSubscr(PyObject *container, PyObject *sub, _Py_CODEUNIT *ins
}
else {
if (PyLong_CheckExact(sub)) {
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_BUFFER_INT);
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_BUFFER_INT);
}
else if (PySlice_Check(sub)) {
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_BUFFER_SLICE);
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_BUFFER_SLICE);
}
else {
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_OTHER);
@ -1384,10 +1395,10 @@ _Py_Specialize_StoreSubscr(PyObject *container, PyObject *sub, _Py_CODEUNIT *ins
PyCodeObject *code = (PyCodeObject *)func->func_code;
int kind = function_kind(code);
if (kind == SIMPLE_FUNCTION) {
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_PY_SIMPLE);
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_PY_SIMPLE);
}
else {
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_PY_OTHER);
SPECIALIZATION_FAIL(STORE_SUBSCR, SPEC_FAIL_SUBSCR_PY_OTHER);
}
goto fail;
}
@ -1411,7 +1422,7 @@ specialize_class_call(
{
PyTypeObject *tp = _PyType_CAST(callable);
if (tp->tp_new == PyBaseObject_Type.tp_new) {
SPECIALIZATION_FAIL(CALL, SPEC_FAIL_PYTHON_CLASS);
SPECIALIZATION_FAIL(CALL, SPEC_FAIL_CALL_PYTHON_CLASS);
return -1;
}
if (tp->tp_flags & Py_TPFLAGS_IMMUTABLETYPE) {
@ -1434,10 +1445,10 @@ specialize_class_call(
return 0;
}
SPECIALIZATION_FAIL(CALL, tp == &PyUnicode_Type ?
SPEC_FAIL_CALL_STR : SPEC_FAIL_CLASS_NO_VECTORCALL);
SPEC_FAIL_CALL_STR : SPEC_FAIL_CALL_CLASS_NO_VECTORCALL);
return -1;
}
SPECIALIZATION_FAIL(CALL, SPEC_FAIL_CLASS_MUTABLE);
SPECIALIZATION_FAIL(CALL, SPEC_FAIL_CALL_CLASS_MUTABLE);
return -1;
}
@ -1448,19 +1459,19 @@ builtin_call_fail_kind(int ml_flags)
switch (ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O |
METH_KEYWORDS | METH_METHOD)) {
case METH_VARARGS:
return SPEC_FAIL_PYCFUNCTION;
return SPEC_FAIL_CALL_PYCFUNCTION;
case METH_VARARGS | METH_KEYWORDS:
return SPEC_FAIL_PYCFUNCTION_WITH_KEYWORDS;
return SPEC_FAIL_CALL_PYCFUNCTION_WITH_KEYWORDS;
case METH_FASTCALL | METH_KEYWORDS:
return SPEC_FAIL_PYCFUNCTION_FAST_WITH_KEYWORDS;
return SPEC_FAIL_CALL_PYCFUNCTION_FAST_WITH_KEYWORDS;
case METH_NOARGS:
return SPEC_FAIL_PYCFUNCTION_NOARGS;
return SPEC_FAIL_CALL_PYCFUNCTION_NOARGS;
/* This case should never happen with PyCFunctionObject -- only
PyMethodObject. See zlib.compressobj()'s methods for an example.
*/
case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
default:
return SPEC_FAIL_BAD_CALL_FLAGS;
return SPEC_FAIL_CALL_BAD_CALL_FLAGS;
}
}
#endif
@ -1473,7 +1484,7 @@ specialize_method_descriptor(
int nargs, PyObject *kwnames, SpecializedCacheEntry *cache)
{
if (kwnames) {
SPECIALIZATION_FAIL(CALL, SPEC_FAIL_KWNAMES);
SPECIALIZATION_FAIL(CALL, SPEC_FAIL_CALL_KWNAMES);
return -1;
}
if (_list_append == NULL) {
@ -1528,7 +1539,7 @@ specialize_py_call(
PyCodeObject *code = (PyCodeObject *)func->func_code;
int kind = function_kind(code);
if (kwnames) {
SPECIALIZATION_FAIL(CALL, SPEC_FAIL_KWNAMES);
SPECIALIZATION_FAIL(CALL, SPEC_FAIL_CALL_KWNAMES);
return -1;
}
if (kind != SIMPLE_FUNCTION) {
@ -1585,7 +1596,7 @@ specialize_c_call(PyObject *callable, _Py_CODEUNIT *instr, int nargs,
METH_KEYWORDS | METH_METHOD)) {
case METH_O: {
if (kwnames) {
SPECIALIZATION_FAIL(CALL, SPEC_FAIL_KWNAMES);
SPECIALIZATION_FAIL(CALL, SPEC_FAIL_CALL_KWNAMES);
return -1;
}
if (nargs != 1) {
@ -1606,7 +1617,7 @@ specialize_c_call(PyObject *callable, _Py_CODEUNIT *instr, int nargs,
}
case METH_FASTCALL: {
if (kwnames) {
SPECIALIZATION_FAIL(CALL, SPEC_FAIL_KWNAMES);
SPECIALIZATION_FAIL(CALL, SPEC_FAIL_CALL_KWNAMES);
return -1;
}
if (nargs == 2) {
@ -1641,26 +1652,23 @@ static int
call_fail_kind(PyObject *callable)
{
if (PyInstanceMethod_Check(callable)) {
return SPEC_FAIL_METHOD;
return SPEC_FAIL_CALL_INSTANCE_METHOD;
}
else if (PyMethod_Check(callable)) {
return SPEC_FAIL_METHOD;
return SPEC_FAIL_CALL_BOUND_METHOD;
}
// builtin method
else if (PyCMethod_Check(callable)) {
return SPEC_FAIL_METHOD;
return SPEC_FAIL_CALL_CMETHOD;
}
else if (PyType_Check(callable)) {
return SPEC_FAIL_CLASS;
return SPEC_FAIL_CALL_CLASS;
}
else if (Py_TYPE(callable) == &PyWrapperDescr_Type) {
return SPEC_FAIL_OPERATOR_WRAPPER;
return SPEC_FAIL_CALL_OPERATOR_WRAPPER;
}
else if (Py_TYPE(callable) == &_PyMethodWrapper_Type) {
return SPEC_FAIL_METHOD_WRAPPER;
}
else if (Py_TYPE(callable) == &PyMethod_Type) {
return SPEC_FAIL_BOUND_METHOD;
return SPEC_FAIL_CALL_METHOD_WRAPPER;
}
return SPEC_FAIL_OTHER;
}
@ -1716,7 +1724,7 @@ _Py_Specialize_BinaryOp(PyObject *lhs, PyObject *rhs, _Py_CODEUNIT *instr,
case NB_ADD:
case NB_INPLACE_ADD:
if (!Py_IS_TYPE(lhs, Py_TYPE(rhs))) {
SPECIALIZATION_FAIL(BINARY_OP, SPEC_FAIL_DIFFERENT_TYPES);
SPECIALIZATION_FAIL(BINARY_OP, SPEC_FAIL_BINARY_OP_DIFFERENT_TYPES);
goto failure;
}
if (PyUnicode_CheckExact(lhs)) {
@ -1742,7 +1750,7 @@ _Py_Specialize_BinaryOp(PyObject *lhs, PyObject *rhs, _Py_CODEUNIT *instr,
case NB_MULTIPLY:
case NB_INPLACE_MULTIPLY:
if (!Py_IS_TYPE(lhs, Py_TYPE(rhs))) {
SPECIALIZATION_FAIL(BINARY_OP, SPEC_FAIL_DIFFERENT_TYPES);
SPECIALIZATION_FAIL(BINARY_OP, SPEC_FAIL_BINARY_OP_DIFFERENT_TYPES);
goto failure;
}
if (PyLong_CheckExact(lhs)) {
@ -1759,7 +1767,7 @@ _Py_Specialize_BinaryOp(PyObject *lhs, PyObject *rhs, _Py_CODEUNIT *instr,
case NB_SUBTRACT:
case NB_INPLACE_SUBTRACT:
if (!Py_IS_TYPE(lhs, Py_TYPE(rhs))) {
SPECIALIZATION_FAIL(BINARY_OP, SPEC_FAIL_DIFFERENT_TYPES);
SPECIALIZATION_FAIL(BINARY_OP, SPEC_FAIL_BINARY_OP_DIFFERENT_TYPES);
goto failure;
}
if (PyLong_CheckExact(lhs)) {
@ -1796,30 +1804,30 @@ compare_op_fail_kind(PyObject *lhs, PyObject *rhs)
{
if (Py_TYPE(lhs) != Py_TYPE(rhs)) {
if (PyFloat_CheckExact(lhs) && PyLong_CheckExact(rhs)) {
return SPEC_FAIL_COMPARE_FLOAT_LONG;
return SPEC_FAIL_COMPARE_OP_FLOAT_LONG;
}
if (PyLong_CheckExact(lhs) && PyFloat_CheckExact(rhs)) {
return SPEC_FAIL_COMPARE_LONG_FLOAT;
return SPEC_FAIL_COMPARE_OP_LONG_FLOAT;
}
return SPEC_FAIL_DIFFERENT_TYPES;
return SPEC_FAIL_COMPARE_OP_DIFFERENT_TYPES;
}
if (PyBytes_CheckExact(lhs)) {
return SPEC_FAIL_COMPARE_BYTES;
return SPEC_FAIL_COMPARE_OP_BYTES;
}
if (PyTuple_CheckExact(lhs)) {
return SPEC_FAIL_COMPARE_TUPLE;
return SPEC_FAIL_COMPARE_OP_TUPLE;
}
if (PyList_CheckExact(lhs)) {
return SPEC_FAIL_COMPARE_LIST;
return SPEC_FAIL_COMPARE_OP_LIST;
}
if (PySet_CheckExact(lhs) || PyFrozenSet_CheckExact(lhs)) {
return SPEC_FAIL_COMPARE_SET;
return SPEC_FAIL_COMPARE_OP_SET;
}
if (PyBool_Check(lhs)) {
return SPEC_FAIL_COMPARE_BOOL;
return SPEC_FAIL_COMPARE_OP_BOOL;
}
if (Py_TYPE(lhs)->tp_richcompare == PyBaseObject_Type.tp_richcompare) {
return SPEC_FAIL_COMPARE_BASEOBJECT;
return SPEC_FAIL_COMPARE_OP_BASEOBJECT;
}
return SPEC_FAIL_OTHER;
}
@ -1847,7 +1855,7 @@ _Py_Specialize_CompareOp(PyObject *lhs, PyObject *rhs,
int next_opcode = _Py_OPCODE(instr[1]);
if (next_opcode != POP_JUMP_IF_FALSE && next_opcode != POP_JUMP_IF_TRUE) {
// Can't ever combine, so don't don't bother being adaptive.
SPECIALIZATION_FAIL(COMPARE_OP, SPEC_FAIL_NOT_FOLLOWED_BY_COND_JUMP);
SPECIALIZATION_FAIL(COMPARE_OP, SPEC_FAIL_COMPARE_OP_NOT_FOLLOWED_BY_COND_JUMP);
*instr = _Py_MAKECODEUNIT(COMPARE_OP, adaptive->original_oparg);
goto failure;
}
@ -1872,13 +1880,13 @@ _Py_Specialize_CompareOp(PyObject *lhs, PyObject *rhs,
goto success;
}
else {
SPECIALIZATION_FAIL(COMPARE_OP, SPEC_FAIL_BIG_INT);
SPECIALIZATION_FAIL(COMPARE_OP, SPEC_FAIL_COMPARE_OP_BIG_INT);
goto failure;
}
}
if (PyUnicode_CheckExact(lhs)) {
if (op != Py_EQ && op != Py_NE) {
SPECIALIZATION_FAIL(COMPARE_OP, SPEC_FAIL_STRING_COMPARE);
SPECIALIZATION_FAIL(COMPARE_OP, SPEC_FAIL_COMPARE_OP_STRING);
goto failure;
}
else {
@ -1901,48 +1909,48 @@ int
_PySpecialization_ClassifyIterator(PyObject *iter)
{
if (PyGen_CheckExact(iter)) {
return SPEC_FAIL_ITER_GENERATOR;
return SPEC_FAIL_FOR_ITER_GENERATOR;
}
if (PyCoro_CheckExact(iter)) {
return SPEC_FAIL_ITER_COROUTINE;
return SPEC_FAIL_FOR_ITER_COROUTINE;
}
if (PyAsyncGen_CheckExact(iter)) {
return SPEC_FAIL_ITER_ASYNC_GENERATOR;
return SPEC_FAIL_FOR_ITER_ASYNC_GENERATOR;
}
PyTypeObject *t = _Py_TYPE(iter);
if (t == &PyListIter_Type) {
return SPEC_FAIL_ITER_LIST;
return SPEC_FAIL_FOR_ITER_LIST;
}
if (t == &PyTupleIter_Type) {
return SPEC_FAIL_ITER_TUPLE;
return SPEC_FAIL_FOR_ITER_TUPLE;
}
if (t == &PyDictIterKey_Type) {
return SPEC_FAIL_ITER_DICT_KEYS;
return SPEC_FAIL_FOR_ITER_DICT_KEYS;
}
if (t == &PyDictIterValue_Type) {
return SPEC_FAIL_ITER_DICT_VALUES;
return SPEC_FAIL_FOR_ITER_DICT_VALUES;
}
if (t == &PyDictIterItem_Type) {
return SPEC_FAIL_ITER_DICT_ITEMS;
return SPEC_FAIL_FOR_ITER_DICT_ITEMS;
}
if (t == &PySetIter_Type) {
return SPEC_FAIL_ITER_SET;
return SPEC_FAIL_FOR_ITER_SET;
}
if (t == &PyUnicodeIter_Type) {
return SPEC_FAIL_ITER_STRING;
return SPEC_FAIL_FOR_ITER_STRING;
}
if (t == &PyBytesIter_Type) {
return SPEC_FAIL_ITER_BYTES;
return SPEC_FAIL_FOR_ITER_BYTES;
}
if (t == &PyRangeIter_Type) {
return SPEC_FAIL_ITER_RANGE;
return SPEC_FAIL_FOR_ITER_RANGE;
}
if (t == &PyEnum_Type) {
return SPEC_FAIL_ITER_ENUMERATE;
return SPEC_FAIL_FOR_ITER_ENUMERATE;
}
if (strncmp(t->tp_name, "itertools", 8) == 0) {
return SPEC_FAIL_ITER_ITERTOOLS;
return SPEC_FAIL_FOR_ITER_ITERTOOLS;
}
return SPEC_FAIL_OTHER;
}
@ -1951,10 +1959,10 @@ int
_PySpecialization_ClassifySequence(PyObject *seq)
{
if (PyTuple_CheckExact(seq)) {
return SPEC_FAIL_TUPLE;
return SPEC_FAIL_UNPACK_SEQUENCE_TUPLE;
}
if (PyList_CheckExact(seq)) {
return SPEC_FAIL_LIST;
return SPEC_FAIL_UNPACK_SEQUENCE_LIST;
}
return SPEC_FAIL_OTHER;
}