First commit.

Signed-off-by: Matthew A Johnson <matjoh@microsoft.com>

Author: matajoh

.gitignore

@@ -156,3 +156,6 @@ Python/frozen_modules/MANIFEST
 # Ignore ./python binary on Unix but still look into ./Python/ directory.
 /python
 !/Python/
+
+# Ignore the build directory.
+build*

Doc/c-api/typeobj.rst

@@ -2591,9 +2591,9 @@ Slot Type typedefs
    The purpose of this function is to separate memory allocation from memory
    initialization.  It should return a pointer to a block of memory of adequate
    length for the instance, suitably aligned, and initialized to zeros, but with
-   :c:member:`~PyObject.ob_refcnt` set to ``1`` and :c:member:`~PyObject.ob_type` set to the type argument.  If
+   :c:member:`~PyObject.ob_refcnt` set to ``2`` and :c:member:`~PyObject.ob_type` set to the type argument.  If
    the type's :c:member:`~PyTypeObject.tp_itemsize` is non-zero, the object's :c:member:`~PyVarObject.ob_size` field
-   should be initialized to *nitems* and the length of the allocated memory block
+   should be initialized to *nitems * 2* and the length of the allocated memory block
    should be ``tp_basicsize + nitems*tp_itemsize``, rounded up to a multiple of
    ``sizeof(void*)``; otherwise, *nitems* is not used and the length of the block
    should be :c:member:`~PyTypeObject.tp_basicsize`.

Doc/conf.py

@@ -215,6 +215,7 @@
     ('c:data', 'PyExc_UnicodeError'),
     ('c:data', 'PyExc_UnicodeTranslateError'),
     ('c:data', 'PyExc_ValueError'),
+    ('c:data', 'PyExc_NotWriteableError'),
     ('c:data', 'PyExc_ZeroDivisionError'),
     # C API: Standard Python warning classes
     ('c:data', 'PyExc_BytesWarning'),

Doc/data/stable_abi.dat

@@ -168,6 +168,13 @@ PyAPI_FUNC(void) _Py_NO_RETURN _Py_FatalErrorFormat(
     const char *format,
     ...);
 
+PyAPI_FUNC(PyObject *) _PyErr_WriteToImmutable(const char* file, int line, PyObject *obj);
+#define PyErr_WriteToImmutable(obj) _PyErr_WriteToImmutable(__FILE__, __LINE__, _PyObject_CAST(obj))
+
+PyAPI_FUNC(PyObject *) _PyErr_WriteToImmutableKey(const char* file, int line, PyObject *key);
+#define PyErr_WriteToImmutableKey(key) _PyErr_WriteToImmutableKey(__FILE__, __LINE__, _PyObject_CAST(key))
+
+
 extern PyObject *_PyErr_SetImportErrorWithNameFrom(
         PyObject *,
         PyObject *,

Include/cpython/pyerrors.h

@@ -24,14 +24,24 @@ typedef struct {
     /* Cached hash code of me_key. */
     Py_hash_t me_hash;
     PyObject *me_key;
-    PyObject *me_value; /* This field is only meaningful for combined tables */
+    PyObject *_me_value; /* This field is only meaningful for combined tables */
 } PyDictKeyEntry;
 
 typedef struct {
     PyObject *me_key;   /* The key must be Unicode and have hash. */
-    PyObject *me_value; /* This field is only meaningful for combined tables */
+    PyObject *_me_value; /* This field is only meaningful for combined tables */
 } PyDictUnicodeEntry;
 
+#define _PyDictEntry_IsImmutable(entry) (((uintptr_t)((entry)->_me_value)) & 0x1)
+#define _PyDictEntry_SetImmutable(entry) ((entry)->_me_value = (PyObject*)((uintptr_t)(entry)->_me_value | 0x1))
+#define _PyDictEntry_Hash(entry) ((entry)->me_hash)
+#define _PyDictEntry_Key(entry) ((entry)->me_key)
+#define _PyDictEntry_Value(entry) ((PyObject*)((((uintptr_t)((entry)->_me_value)) >> 1) << 1))
+#define _PyDictEntry_SetValue(entry, value) ((entry)->_me_value = value)
+#define _PyDictEntry_IsEmpty(entry) ((entry)->_me_value == NULL)
+
+extern PyObject *_PyDict_IsKeyImmutable(PyObject* op, PyObject* key);
+
 extern PyDictKeysObject *_PyDict_NewKeysForClass(void);
 extern PyObject *_PyDict_FromKeys(PyObject *, PyObject *, PyObject *);
 
@@ -50,6 +60,7 @@ extern Py_ssize_t _Py_dict_lookup(PyDictObject *mp, PyObject *key, Py_hash_t has
 extern Py_ssize_t _PyDict_LookupIndex(PyDictObject *, PyObject *);
 extern Py_ssize_t _PyDictKeys_StringLookup(PyDictKeysObject* dictkeys, PyObject *key);
 extern PyObject *_PyDict_LoadGlobal(PyDictObject *, PyDictObject *, PyObject *);
+extern PyObject *_PyDict_SetKeyImmutable(PyDictObject *mp, PyObject *key);
 
 /* Consumes references to key and value */
 extern int _PyDict_SetItem_Take2(PyDictObject *op, PyObject *key, PyObject *value);

Include/internal/pycore_dict.h

@@ -198,7 +198,7 @@ _PyFrame_MakeAndSetFrameObject(_PyInterpreterFrame *frame);
 
 /* Gets the PyFrameObject for this frame, lazily
  * creating it if necessary.
- * Returns a borrowed referennce */
+ * Returns a borrowed reference */
 static inline PyFrameObject *
 _PyFrame_GetFrameObject(_PyInterpreterFrame *frame)
 {

Include/internal/pycore_frame.h

@@ -0,0 +1,22 @@
+#ifndef Py_FREEZE_H
+#define Py_FREEZE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+PyObject* _Py_Freeze(PyObject*);
+#define Py_Freeze(op) _Py_Freeze(_PyObject_CAST(op))
+
+PyObject* _Py_FreezeGlobals(void);
+
+bool _Py_GlobalsImmutable_Check(void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_FREEZE_H */

Include/internal/pycore_immutability.h

@@ -71,7 +71,7 @@ static inline void _Py_RefcntAdd(PyObject* op, Py_ssize_t n)
 static inline void _Py_SetImmortal(PyObject *op)
 {
     if (op) {
-        op->ob_refcnt = _Py_IMMORTAL_REFCNT;
+        op->ob_refcnt = (op->ob_refcnt & _Py_IMMUTABLE_MASK) | _Py_IMMORTAL_REFCNT;
     }
 }
 #define _Py_SetImmortal(op) _Py_SetImmortal(_PyObject_CAST(op))
@@ -80,7 +80,8 @@ static inline void _Py_SetImmortal(PyObject *op)
 static inline void _Py_ClearImmortal(PyObject *op)
 {
     if (op) {
-        assert(op->ob_refcnt == _Py_IMMORTAL_REFCNT);
+        assert((op->ob_refcnt & _Py_REFCNT_MASK) == _Py_IMMORTAL_REFCNT);
+        // note this also clears the _Py_IMMUTABLE_FLAG, if set
         op->ob_refcnt = 1;
         Py_DECREF(op);
     }
@@ -91,6 +92,17 @@ static inline void _Py_ClearImmortal(PyObject *op)
         op = NULL; \
     } while (0)
 
+static inline void _Py_SetImmutable(PyObject *op)
+{
+    if(op) {
+        op->ob_refcnt |= _Py_IMMUTABLE_FLAG;
+    }
+}
+#define _Py_SetImmutable(op) _Py_SetImmutable(_PyObject_CAST(op))
+
+#define Py_CHECKWRITE(op) ((op) && (!_Py_IsImmutable(op)))
+#define Py_REQUIREWRITE(op, msg) {if (Py_CHECKWRITE(op)) { _PyObject_ASSERT_FAILED_MSG(op, msg); }}
+
 static inline void
 _Py_DECREF_SPECIALIZED(PyObject *op, const destructor destruct)
 {
@@ -101,10 +113,10 @@ _Py_DECREF_SPECIALIZED(PyObject *op, const destructor destruct)
 #ifdef Py_REF_DEBUG
     _Py_DEC_REFTOTAL(_PyInterpreterState_GET());
 #endif
-    if (--op->ob_refcnt != 0) {
-        assert(op->ob_refcnt > 0);
-    }
-    else {
+    assert((op->ob_refcnt & _Py_REFCNT_MASK) > 0);
+    op->ob_refcnt -= 1;
+
+    if((op->ob_refcnt & _Py_REFCNT_MASK) == 0) {
 #ifdef Py_TRACE_REFS
         _Py_ForgetReference(op);
 #endif
@@ -122,12 +134,12 @@ _Py_DECREF_NO_DEALLOC(PyObject *op)
 #ifdef Py_REF_DEBUG
     _Py_DEC_REFTOTAL(_PyInterpreterState_GET());
 #endif
-    op->ob_refcnt--;
 #ifdef Py_DEBUG
-    if (op->ob_refcnt <= 0) {
+    if ((op->ob_refcnt & _Py_REFCNT_MASK) == 0) {
         _Py_FatalRefcountError("Expected a positive remaining refcount");
     }
 #endif
+    op->ob_refcnt -= 1;
 }
 
 #ifdef Py_REF_DEBUG

Include/internal/pycore_object.h

@@ -78,6 +78,25 @@ whose size is determined when the object is allocated.
 /* PyObject_HEAD defines the initial segment of every PyObject. */
 #define PyObject_HEAD                   PyObject ob_base;
 
+/*
+Immutability:
+
+Immutability is tracked in the top bit of the reference count. The immutability
+system also uses the second-to-top bit for managing immutable graphs.
+*/
+
+#if SIZEOF_VOID_P > 4
+#define _Py_REFCNT_MASK 0xFFFFFFFF
+#define _Py_IMMUTABLE_MASK 0xC000000000000000
+#define _Py_IMMUTABLE_FLAG 0x8000000000000000
+#define _Py_IMMUTABLE_SCC_FLAG 0x4000000000000000
+#else
+#define _Py_REFCNT_MASK 0x3FFFFFFF
+#define _Py_IMMUTABLE_MASK 0xC0000000
+#define _Py_IMMUTABLE_FLAG 0x80000000
+#define _Py_IMMUTABLE_SCC_FLAG 0x40000000
+#endif
+
 /*
 Immortalization:
 
@@ -112,17 +131,17 @@ be done by checking the bit sign flag in the lower 32 bits.
 #else
 /*
 In 32 bit systems, an object will be marked as immortal by setting all of the
-lower 30 bits of the reference count field, which is equal to: 0x3FFFFFFF
+lower 28 bits of the reference count field, which is equal to: 0x0FFFFFFF.
 
-Using the lower 30 bits makes the value backwards compatible by allowing
+Using the lower 28 bits makes the value backwards compatible by allowing
 C-Extensions without the updated checks in Py_INCREF and Py_DECREF to safely
 increase and decrease the objects reference count. The object would lose its
 immortality, but the execution would still be correct.
 
 Reference count increases and decreases will first go through an immortality
 check by comparing the reference count field to the immortality reference count.
 */
-#define _Py_IMMORTAL_REFCNT (UINT_MAX >> 2)
+#define _Py_IMMORTAL_REFCNT (UINT_MAX >> 4)
 #endif
 
 // Make all internal uses of PyObject_HEAD_INIT immortal while preserving the
@@ -208,7 +227,7 @@ PyAPI_FUNC(int) Py_Is(PyObject *x, PyObject *y);
 
 
 static inline Py_ssize_t Py_REFCNT(PyObject *ob) {
-    return ob->ob_refcnt;
+    return ob->ob_refcnt & _Py_REFCNT_MASK;
 }
 #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000
 #  define Py_REFCNT(ob) Py_REFCNT(_PyObject_CAST(ob))
@@ -242,7 +261,7 @@ static inline Py_ALWAYS_INLINE int _Py_IsImmortal(PyObject *op)
 #if SIZEOF_VOID_P > 4
     return _Py_CAST(PY_INT32_T, op->ob_refcnt) < 0;
 #else
-    return op->ob_refcnt == _Py_IMMORTAL_REFCNT;
+    return (op->ob_refcnt & _Py_REFCNT_MASK) == _Py_IMMORTAL_REFCNT;
 #endif
 }
 #define _Py_IsImmortal(op) _Py_IsImmortal(_PyObject_CAST(op))
@@ -254,6 +273,15 @@ static inline int Py_IS_TYPE(PyObject *ob, PyTypeObject *type) {
 #  define Py_IS_TYPE(ob, type) Py_IS_TYPE(_PyObject_CAST(ob), (type))
 #endif
 
+static inline Py_ALWAYS_INLINE int _Py_IsImmutable(PyObject *op)
+{
+#if SIZEOF_VOID_P > 4
+    return _Py_CAST(PY_INT64_T, op->ob_refcnt) < 0;
+#else
+    return _Py_CAST(PY_INT32_T, op->ob_refcnt) < 0;
+#endif
+}
+#define _Py_IsImmutable(op) _Py_IsImmutable(_PyObject_CAST(op))
 
 static inline void Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt) {
     // This immortal check is for code that is unaware of immortal objects.
@@ -263,7 +291,7 @@ static inline void Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt) {
     if (_Py_IsImmortal(ob)) {
         return;
     }
-    ob->ob_refcnt = refcnt;
+    ob->ob_refcnt = (ob->ob_refcnt & _Py_IMMUTABLE_MASK) | (refcnt & _Py_REFCNT_MASK);
 }
 #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < 0x030b0000
 #  define Py_SET_REFCNT(ob, refcnt) Py_SET_REFCNT(_PyObject_CAST(ob), (refcnt))
@@ -687,7 +715,8 @@ static inline void Py_DECREF(const char *filename, int lineno, PyObject *op)
     }
     _Py_DECREF_STAT_INC();
     _Py_DECREF_DecRefTotal();
-    if (--op->ob_refcnt == 0) {
+    op->ob_refcnt -= 1;
+    if ((op->ob_refcnt & _Py_REFCNT_MASK) == 0) {
         _Py_Dealloc(op);
     }
 }
@@ -702,7 +731,8 @@ static inline Py_ALWAYS_INLINE void Py_DECREF(PyObject *op)
         return;
     }
     _Py_DECREF_STAT_INC();
-    if (--op->ob_refcnt == 0) {
+    op->ob_refcnt -= 1;
+    if ((op->ob_refcnt & _Py_REFCNT_MASK) == 0) {
         _Py_Dealloc(op);
     }
 }