Why is `co_code_adaptive` in `PyCodeObject` cast to a `uint16_t` pointer in `_PyCode_CODE` macro?

Question

I was exploring the Python 3.11 source code and came across the _PyCode_CODE macro. I noticed that within this macro, the co_code_adaptive member of PyCodeObject is cast to a uint16_t* pointer. However, co_code_adaptive is defined as a char array of length 1.


/*******************************************/
// code in code.h
/*******************************************/
#define _PyCode_CODE(co) ((const uint16_t *)(co)->co_code_adaptive)

#define _PyCode_DEF(SIZE) {                                                    \
    // ...                                                                     \
    char co_code_adaptive[(SIZE)];                                             \
}
/* Bytecode object */
struct PyCodeObject _PyCode_DEF(1);

/*******************************************/
// code in specialize.c
/*******************************************/
void
_PyCode_Quicken(PyCodeObject *code)
{
    _Py_QuickenedCount++;
    int previous_opcode = -1;
    _Py_CODEUNIT *instructions = _PyCode_CODE(code);
    for (int i = 0; i < Py_SIZE(code); i++) {
        int opcode = _Py_OPCODE(instructions[i]);
// ...
}

This casting seems like it might introduce memory access risks, as char and uint16_t have different type sizes and alignment requirements. Why did the Python developers choose to implement it this way? How is memory safety ensured in this context?

Specifically, in the specialize.c file, within the _PyCode_Quicken function, this macro is used to define a uint16_t* pointer named instructions. The code then accesses memory using the [] operator. How does Python ensure that these memory accesses are valid?

Any insights into the underlying design decisions or documentation explaining this approach would be greatly appreciated.

Since co_code_adaptive is at the end of the struct (based on what you showed), could it be the case that *code is "over-allocated" such that there is enough memory for a uint16_t? — ikegami
– ikegami, Commented Nov 7, 2024 at 12:48
The cast to uint16_t * allows Python 3.11 to efficiently handle adaptive bytecode instructions, leveraging 2-byte units for improved performance while ensuring memory safety through controlled allocation and alignment. This design choice is an optimization specific to Python’s updated bytecode handling in Python 3.11 — Fatima Mir
– Fatima Mir, Commented Nov 7, 2024 at 12:48
@Fatima Mir, You sure sound like an "AI". All words, no substance. Use of AI is not allowed here. — ikegami
– ikegami, Commented Nov 7, 2024 at 12:50
@ikegami Thank you for your response! I'm curious to know if the idea that co_code_adaptive might be "over-allocated" is based on a reasonable assumption or if there is specific code evidence or implementation detail supporting it. If there are any relevant code snippets or documentation, could you please share them? Thanks a lot! — stdiohero
– stdiohero, Commented Nov 8, 2024 at 4:43

bob_costas · Accepted Answer · 2024-11-11 20:16:41Z

For Python, each bitcode instruction is a two-byte object¹ with an opcode and a corresponding argument:

typedef struct _CodeUnit {
    uint8_t opcode;
    uint8_t oparg;
} _CodeUnit;

The actual PyCodeObject struct is allocated using the "flexible array member" idiom in C to reduce allocations (without the idiom, we would need one allocation for the PyCodeObject struct and one for the compiled bitcode). This pattern is used often in the implementation.

This means a PyCodeObject with its corresponding code can be allocated like this:

PyCodeObject *code = malloc(sizeof(PyCodeObject) + 2*instruction_count);

The number of instructions is encoded in the ob_size member given by PyVarObject. This is what Py_SIZE retrieves in the loop over instructions.

So, the accesses are valid by construction.

^{1. For the purposes of this answer, I'm ignoring inline caches that are used for some instructions.}

Collectives™ on Stack Overflow

Why is `co_code_adaptive` in `PyCodeObject` cast to a `uint16_t` pointer in `_PyCode_CODE` macro?

1 Answer 1

Comments

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Related