LCOV - code coverage report
Current view: top level - Include/internal - pycore_code.h (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 58 66 87.9 %
Date: 2023-03-20 08:15:36 Functions: 15 17 88.2 %
Branches: 8 12 66.7 %

           Branch data     Line data    Source code
       1                 :            : #ifndef Py_INTERNAL_CODE_H
       2                 :            : #define Py_INTERNAL_CODE_H
       3                 :            : #ifdef __cplusplus
       4                 :            : extern "C" {
       5                 :            : #endif
       6                 :            : 
       7                 :            : #define CODE_MAX_WATCHERS 8
       8                 :            : 
       9                 :            : /* PEP 659
      10                 :            :  * Specialization and quickening structs and helper functions
      11                 :            :  */
      12                 :            : 
      13                 :            : 
      14                 :            : // Inline caches. If you change the number of cache entries for an instruction,
      15                 :            : // you must *also* update the number of cache entries in Lib/opcode.py and bump
      16                 :            : // the magic number in Lib/importlib/_bootstrap_external.py!
      17                 :            : 
      18                 :            : #define CACHE_ENTRIES(cache) (sizeof(cache)/sizeof(_Py_CODEUNIT))
      19                 :            : 
      20                 :            : typedef struct {
      21                 :            :     uint16_t counter;
      22                 :            :     uint16_t index;
      23                 :            :     uint16_t module_keys_version;
      24                 :            :     uint16_t builtin_keys_version;
      25                 :            : } _PyLoadGlobalCache;
      26                 :            : 
      27                 :            : #define INLINE_CACHE_ENTRIES_LOAD_GLOBAL CACHE_ENTRIES(_PyLoadGlobalCache)
      28                 :            : 
      29                 :            : typedef struct {
      30                 :            :     uint16_t counter;
      31                 :            : } _PyBinaryOpCache;
      32                 :            : 
      33                 :            : #define INLINE_CACHE_ENTRIES_BINARY_OP CACHE_ENTRIES(_PyBinaryOpCache)
      34                 :            : 
      35                 :            : typedef struct {
      36                 :            :     uint16_t counter;
      37                 :            : } _PyUnpackSequenceCache;
      38                 :            : 
      39                 :            : #define INLINE_CACHE_ENTRIES_UNPACK_SEQUENCE \
      40                 :            :     CACHE_ENTRIES(_PyUnpackSequenceCache)
      41                 :            : 
      42                 :            : typedef struct {
      43                 :            :     uint16_t counter;
      44                 :            : } _PyCompareOpCache;
      45                 :            : 
      46                 :            : #define INLINE_CACHE_ENTRIES_COMPARE_OP CACHE_ENTRIES(_PyCompareOpCache)
      47                 :            : 
      48                 :            : typedef struct {
      49                 :            :     uint16_t counter;
      50                 :            :     uint16_t type_version[2];
      51                 :            :     uint16_t func_version;
      52                 :            : } _PyBinarySubscrCache;
      53                 :            : 
      54                 :            : #define INLINE_CACHE_ENTRIES_BINARY_SUBSCR CACHE_ENTRIES(_PyBinarySubscrCache)
      55                 :            : 
      56                 :            : typedef struct {
      57                 :            :     uint16_t counter;
      58                 :            :     uint16_t version[2];
      59                 :            :     uint16_t index;
      60                 :            : } _PyAttrCache;
      61                 :            : 
      62                 :            : typedef struct {
      63                 :            :     uint16_t counter;
      64                 :            :     uint16_t type_version[2];
      65                 :            :     uint16_t keys_version[2];
      66                 :            :     uint16_t descr[4];
      67                 :            : } _PyLoadMethodCache;
      68                 :            : 
      69                 :            : 
      70                 :            : // MUST be the max(_PyAttrCache, _PyLoadMethodCache)
      71                 :            : #define INLINE_CACHE_ENTRIES_LOAD_ATTR CACHE_ENTRIES(_PyLoadMethodCache)
      72                 :            : 
      73                 :            : #define INLINE_CACHE_ENTRIES_STORE_ATTR CACHE_ENTRIES(_PyAttrCache)
      74                 :            : 
      75                 :            : typedef struct {
      76                 :            :     uint16_t counter;
      77                 :            :     uint16_t func_version[2];
      78                 :            :     uint16_t min_args;
      79                 :            : } _PyCallCache;
      80                 :            : 
      81                 :            : #define INLINE_CACHE_ENTRIES_CALL CACHE_ENTRIES(_PyCallCache)
      82                 :            : 
      83                 :            : typedef struct {
      84                 :            :     uint16_t counter;
      85                 :            : } _PyStoreSubscrCache;
      86                 :            : 
      87                 :            : #define INLINE_CACHE_ENTRIES_STORE_SUBSCR CACHE_ENTRIES(_PyStoreSubscrCache)
      88                 :            : 
      89                 :            : typedef struct {
      90                 :            :     uint16_t counter;
      91                 :            : } _PyForIterCache;
      92                 :            : 
      93                 :            : #define INLINE_CACHE_ENTRIES_FOR_ITER CACHE_ENTRIES(_PyForIterCache)
      94                 :            : 
      95                 :            : typedef struct {
      96                 :            :     uint16_t counter;
      97                 :            : } _PySendCache;
      98                 :            : 
      99                 :            : #define INLINE_CACHE_ENTRIES_SEND CACHE_ENTRIES(_PySendCache)
     100                 :            : 
     101                 :            : // Borrowed references to common callables:
     102                 :            : struct callable_cache {
     103                 :            :     PyObject *isinstance;
     104                 :            :     PyObject *len;
     105                 :            :     PyObject *list_append;
     106                 :            :     PyObject *object__getattribute__;
     107                 :            : };
     108                 :            : 
     109                 :            : /* "Locals plus" for a code object is the set of locals + cell vars +
     110                 :            :  * free vars.  This relates to variable names as well as offsets into
     111                 :            :  * the "fast locals" storage array of execution frames.  The compiler
     112                 :            :  * builds the list of names, their offsets, and the corresponding
     113                 :            :  * kind of local.
     114                 :            :  *
     115                 :            :  * Those kinds represent the source of the initial value and the
     116                 :            :  * variable's scope (as related to closures).  A "local" is an
     117                 :            :  * argument or other variable defined in the current scope.  A "free"
     118                 :            :  * variable is one that is defined in an outer scope and comes from
     119                 :            :  * the function's closure.  A "cell" variable is a local that escapes
     120                 :            :  * into an inner function as part of a closure, and thus must be
     121                 :            :  * wrapped in a cell.  Any "local" can also be a "cell", but the
     122                 :            :  * "free" kind is mutually exclusive with both.
     123                 :            :  */
     124                 :            : 
     125                 :            : // Note that these all fit within a byte, as do combinations.
     126                 :            : // Later, we will use the smaller numbers to differentiate the different
     127                 :            : // kinds of locals (e.g. pos-only arg, varkwargs, local-only).
     128                 :            : #define CO_FAST_LOCAL   0x20
     129                 :            : #define CO_FAST_CELL    0x40
     130                 :            : #define CO_FAST_FREE    0x80
     131                 :            : 
     132                 :            : typedef unsigned char _PyLocals_Kind;
     133                 :            : 
     134                 :            : static inline _PyLocals_Kind
     135                 :     190727 : _PyLocals_GetKind(PyObject *kinds, int i)
     136                 :            : {
     137                 :            :     assert(PyBytes_Check(kinds));
     138                 :            :     assert(0 <= i && i < PyBytes_GET_SIZE(kinds));
     139                 :     190727 :     char *ptr = PyBytes_AS_STRING(kinds);
     140                 :     190727 :     return (_PyLocals_Kind)(ptr[i]);
     141                 :            : }
     142                 :            : 
     143                 :            : static inline void
     144                 :      25043 : _PyLocals_SetKind(PyObject *kinds, int i, _PyLocals_Kind kind)
     145                 :            : {
     146                 :            :     assert(PyBytes_Check(kinds));
     147                 :            :     assert(0 <= i && i < PyBytes_GET_SIZE(kinds));
     148                 :      25043 :     char *ptr = PyBytes_AS_STRING(kinds);
     149                 :      25043 :     ptr[i] = (char) kind;
     150                 :      25043 : }
     151                 :            : 
     152                 :            : 
     153                 :            : struct _PyCodeConstructor {
     154                 :            :     /* metadata */
     155                 :            :     PyObject *filename;
     156                 :            :     PyObject *name;
     157                 :            :     PyObject *qualname;
     158                 :            :     int flags;
     159                 :            : 
     160                 :            :     /* the code */
     161                 :            :     PyObject *code;
     162                 :            :     int firstlineno;
     163                 :            :     PyObject *linetable;
     164                 :            : 
     165                 :            :     /* used by the code */
     166                 :            :     PyObject *consts;
     167                 :            :     PyObject *names;
     168                 :            : 
     169                 :            :     /* mapping frame offsets to information */
     170                 :            :     PyObject *localsplusnames;  // Tuple of strings
     171                 :            :     PyObject *localspluskinds;  // Bytes object, one byte per variable
     172                 :            : 
     173                 :            :     /* args (within varnames) */
     174                 :            :     int argcount;
     175                 :            :     int posonlyargcount;
     176                 :            :     // XXX Replace argcount with posorkwargcount (argcount - posonlyargcount).
     177                 :            :     int kwonlyargcount;
     178                 :            : 
     179                 :            :     /* needed to create the frame */
     180                 :            :     int stacksize;
     181                 :            : 
     182                 :            :     /* used by the eval loop */
     183                 :            :     PyObject *exceptiontable;
     184                 :            : };
     185                 :            : 
     186                 :            : // Using an "arguments struct" like this is helpful for maintainability
     187                 :            : // in a case such as this with many parameters.  It does bear a risk:
     188                 :            : // if the struct changes and callers are not updated properly then the
     189                 :            : // compiler will not catch problems (like a missing argument).  This can
     190                 :            : // cause hard-to-debug problems.  The risk is mitigated by the use of
     191                 :            : // check_code() in codeobject.c.  However, we may decide to switch
     192                 :            : // back to a regular function signature.  Regardless, this approach
     193                 :            : // wouldn't be appropriate if this weren't a strictly internal API.
     194                 :            : // (See the comments in https://github.com/python/cpython/pull/26258.)
     195                 :            : PyAPI_FUNC(int) _PyCode_Validate(struct _PyCodeConstructor *);
     196                 :            : PyAPI_FUNC(PyCodeObject *) _PyCode_New(struct _PyCodeConstructor *);
     197                 :            : 
     198                 :            : 
     199                 :            : /* Private API */
     200                 :            : 
     201                 :            : /* Getters for internal PyCodeObject data. */
     202                 :            : extern PyObject* _PyCode_GetVarnames(PyCodeObject *);
     203                 :            : extern PyObject* _PyCode_GetCellvars(PyCodeObject *);
     204                 :            : extern PyObject* _PyCode_GetFreevars(PyCodeObject *);
     205                 :            : extern PyObject* _PyCode_GetCode(PyCodeObject *);
     206                 :            : 
     207                 :            : /** API for initializing the line number tables. */
     208                 :            : extern int _PyCode_InitAddressRange(PyCodeObject* co, PyCodeAddressRange *bounds);
     209                 :            : 
     210                 :            : /** Out of process API for initializing the location table. */
     211                 :            : extern void _PyLineTable_InitAddressRange(
     212                 :            :     const char *linetable,
     213                 :            :     Py_ssize_t length,
     214                 :            :     int firstlineno,
     215                 :            :     PyCodeAddressRange *range);
     216                 :            : 
     217                 :            : /** API for traversing the line number table. */
     218                 :            : extern int _PyLineTable_NextAddressRange(PyCodeAddressRange *range);
     219                 :            : extern int _PyLineTable_PreviousAddressRange(PyCodeAddressRange *range);
     220                 :            : 
     221                 :            : /* Specialization functions */
     222                 :            : 
     223                 :            : extern void _Py_Specialize_LoadAttr(PyObject *owner, _Py_CODEUNIT *instr,
     224                 :            :                                     PyObject *name);
     225                 :            : extern void _Py_Specialize_StoreAttr(PyObject *owner, _Py_CODEUNIT *instr,
     226                 :            :                                      PyObject *name);
     227                 :            : extern void _Py_Specialize_LoadGlobal(PyObject *globals, PyObject *builtins,
     228                 :            :                                       _Py_CODEUNIT *instr, PyObject *name);
     229                 :            : extern void _Py_Specialize_BinarySubscr(PyObject *sub, PyObject *container,
     230                 :            :                                         _Py_CODEUNIT *instr);
     231                 :            : extern void _Py_Specialize_StoreSubscr(PyObject *container, PyObject *sub,
     232                 :            :                                        _Py_CODEUNIT *instr);
     233                 :            : extern void _Py_Specialize_Call(PyObject *callable, _Py_CODEUNIT *instr,
     234                 :            :                                 int nargs, PyObject *kwnames);
     235                 :            : extern void _Py_Specialize_BinaryOp(PyObject *lhs, PyObject *rhs, _Py_CODEUNIT *instr,
     236                 :            :                                     int oparg, PyObject **locals);
     237                 :            : extern void _Py_Specialize_CompareAndBranch(PyObject *lhs, PyObject *rhs,
     238                 :            :                                      _Py_CODEUNIT *instr, int oparg);
     239                 :            : extern void _Py_Specialize_UnpackSequence(PyObject *seq, _Py_CODEUNIT *instr,
     240                 :            :                                           int oparg);
     241                 :            : extern void _Py_Specialize_ForIter(PyObject *iter, _Py_CODEUNIT *instr, int oparg);
     242                 :            : extern void _Py_Specialize_Send(PyObject *receiver, _Py_CODEUNIT *instr);
     243                 :            : 
     244                 :            : /* Finalizer function for static codeobjects used in deepfreeze.py */
     245                 :            : extern void _PyStaticCode_Fini(PyCodeObject *co);
     246                 :            : /* Function to intern strings of codeobjects and quicken the bytecode */
     247                 :            : extern int _PyStaticCode_Init(PyCodeObject *co);
     248                 :            : 
     249                 :            : #ifdef Py_STATS
     250                 :            : 
     251                 :            : 
     252                 :            : #define STAT_INC(opname, name) do { if (_py_stats) _py_stats->opcode_stats[opname].specialization.name++; } while (0)
     253                 :            : #define STAT_DEC(opname, name) do { if (_py_stats) _py_stats->opcode_stats[opname].specialization.name--; } while (0)
     254                 :            : #define OPCODE_EXE_INC(opname) do { if (_py_stats) _py_stats->opcode_stats[opname].execution_count++; } while (0)
     255                 :            : #define CALL_STAT_INC(name) do { if (_py_stats) _py_stats->call_stats.name++; } while (0)
     256                 :            : #define OBJECT_STAT_INC(name) do { if (_py_stats) _py_stats->object_stats.name++; } while (0)
     257                 :            : #define OBJECT_STAT_INC_COND(name, cond) \
     258                 :            :     do { if (_py_stats && cond) _py_stats->object_stats.name++; } while (0)
     259                 :            : #define EVAL_CALL_STAT_INC(name) do { if (_py_stats) _py_stats->call_stats.eval_calls[name]++; } while (0)
     260                 :            : #define EVAL_CALL_STAT_INC_IF_FUNCTION(name, callable) \
     261                 :            :     do { if (_py_stats && PyFunction_Check(callable)) _py_stats->call_stats.eval_calls[name]++; } while (0)
     262                 :            : 
     263                 :            : // Used by the _opcode extension which is built as a shared library
     264                 :            : PyAPI_FUNC(PyObject*) _Py_GetSpecializationStats(void);
     265                 :            : 
     266                 :            : #else
     267                 :            : #define STAT_INC(opname, name) ((void)0)
     268                 :            : #define STAT_DEC(opname, name) ((void)0)
     269                 :            : #define OPCODE_EXE_INC(opname) ((void)0)
     270                 :            : #define CALL_STAT_INC(name) ((void)0)
     271                 :            : #define OBJECT_STAT_INC(name) ((void)0)
     272                 :            : #define OBJECT_STAT_INC_COND(name, cond) ((void)0)
     273                 :            : #define EVAL_CALL_STAT_INC(name) ((void)0)
     274                 :            : #define EVAL_CALL_STAT_INC_IF_FUNCTION(name, callable) ((void)0)
     275                 :            : #endif  // !Py_STATS
     276                 :            : 
     277                 :            : // Utility functions for reading/writing 32/64-bit values in the inline caches.
     278                 :            : // Great care should be taken to ensure that these functions remain correct and
     279                 :            : // performant! They should compile to just "move" instructions on all supported
     280                 :            : // compilers and platforms.
     281                 :            : 
     282                 :            : // We use memcpy to let the C compiler handle unaligned accesses and endianness
     283                 :            : // issues for us. It also seems to produce better code than manual copying for
     284                 :            : // most compilers (see https://blog.regehr.org/archives/959 for more info).
     285                 :            : 
     286                 :            : static inline void
     287                 :      26870 : write_u32(uint16_t *p, uint32_t val)
     288                 :            : {
     289                 :      26870 :     memcpy(p, &val, sizeof(val));
     290                 :      26870 : }
     291                 :            : 
     292                 :            : static inline void
     293                 :            : write_u64(uint16_t *p, uint64_t val)
     294                 :            : {
     295                 :            :     memcpy(p, &val, sizeof(val));
     296                 :            : }
     297                 :            : 
     298                 :            : static inline void
     299                 :       3060 : write_obj(uint16_t *p, PyObject *val)
     300                 :            : {
     301                 :       3060 :     memcpy(p, &val, sizeof(val));
     302                 :       3060 : }
     303                 :            : 
     304                 :            : static inline uint16_t
     305                 :   24693037 : read_u16(uint16_t *p)
     306                 :            : {
     307                 :   24693037 :     return *p;
     308                 :            : }
     309                 :            : 
     310                 :            : static inline uint32_t
     311                 :   11900004 : read_u32(uint16_t *p)
     312                 :            : {
     313                 :            :     uint32_t val;
     314                 :   11900004 :     memcpy(&val, p, sizeof(val));
     315                 :   11900004 :     return val;
     316                 :            : }
     317                 :            : 
     318                 :            : static inline uint64_t
     319                 :            : read_u64(uint16_t *p)
     320                 :            : {
     321                 :            :     uint64_t val;
     322                 :            :     memcpy(&val, p, sizeof(val));
     323                 :            :     return val;
     324                 :            : }
     325                 :            : 
     326                 :            : static inline PyObject *
     327                 :    3820716 : read_obj(uint16_t *p)
     328                 :            : {
     329                 :            :     PyObject *val;
     330                 :    3820716 :     memcpy(&val, p, sizeof(val));
     331                 :    3820716 :     return val;
     332                 :            : }
     333                 :            : 
     334                 :            : /* See Objects/exception_handling_notes.txt for details.
     335                 :            :  */
     336                 :            : static inline unsigned char *
     337                 :     632007 : parse_varint(unsigned char *p, int *result) {
     338                 :     632007 :     int val = p[0] & 63;
     339         [ +  + ]:     840162 :     while (p[0] & 64) {
     340                 :     208155 :         p++;
     341                 :     208155 :         val = (val << 6) | (p[0] & 63);
     342                 :            :     }
     343                 :     632007 :     *result = val;
     344                 :     632007 :     return p+1;
     345                 :            : }
     346                 :            : 
     347                 :            : static inline int
     348                 :     159368 : write_varint(uint8_t *ptr, unsigned int val)
     349                 :            : {
     350                 :     159368 :     int written = 1;
     351         [ +  + ]:     170950 :     while (val >= 64) {
     352                 :      11582 :         *ptr++ = 64 | (val & 63);
     353                 :      11582 :         val >>= 6;
     354                 :      11582 :         written++;
     355                 :            :     }
     356                 :     159368 :     *ptr = val;
     357                 :     159368 :     return written;
     358                 :            : }
     359                 :            : 
     360                 :            : static inline int
     361                 :      40241 : write_signed_varint(uint8_t *ptr, int val)
     362                 :            : {
     363         [ +  + ]:      40241 :     if (val < 0) {
     364                 :      10839 :         val = ((-val)<<1) | 1;
     365                 :            :     }
     366                 :            :     else {
     367                 :      29402 :         val = val << 1;
     368                 :            :     }
     369                 :      40241 :     return write_varint(ptr, val);
     370                 :            : }
     371                 :            : 
     372                 :            : static inline int
     373                 :     286095 : write_location_entry_start(uint8_t *ptr, int code, int length)
     374                 :            : {
     375                 :            :     assert((code & 15) == code);
     376                 :     286095 :     *ptr = 128 | (code << 3) | (length - 1);
     377                 :     286095 :     return 1;
     378                 :            : }
     379                 :            : 
     380                 :            : 
     381                 :            : /** Counters
     382                 :            :  * The first 16-bit value in each inline cache is a counter.
     383                 :            :  * When counting misses, the counter is treated as a simple unsigned value.
     384                 :            :  *
     385                 :            :  * When counting executions until the next specialization attempt,
     386                 :            :  * exponential backoff is used to reduce the number of specialization failures.
     387                 :            :  * The high 12 bits store the counter, the low 4 bits store the backoff exponent.
     388                 :            :  * On a specialization failure, the backoff exponent is incremented and the
     389                 :            :  * counter set to (2**backoff - 1).
     390                 :            :  * Backoff == 6 -> starting counter == 63, backoff == 10 -> starting counter == 1023.
     391                 :            :  */
     392                 :            : 
     393                 :            : /* With a 16-bit counter, we have 12 bits for the counter value, and 4 bits for the backoff */
     394                 :            : #define ADAPTIVE_BACKOFF_BITS 4
     395                 :            : 
     396                 :            : // A value of 1 means that we attempt to specialize the *second* time each
     397                 :            : // instruction is executed. Executing twice is a much better indicator of
     398                 :            : // "hotness" than executing once, but additional warmup delays only prevent
     399                 :            : // specialization. Most types stabilize by the second execution, too:
     400                 :            : #define ADAPTIVE_WARMUP_VALUE 1
     401                 :            : #define ADAPTIVE_WARMUP_BACKOFF 1
     402                 :            : 
     403                 :            : // A value of 52 means that we attempt to re-specialize after 53 misses (a prime
     404                 :            : // number, useful for avoiding artifacts if every nth value is a different type
     405                 :            : // or something). Setting the backoff to 0 means that the counter is reset to
     406                 :            : // the same state as a warming-up instruction (value == 1, backoff == 1) after
     407                 :            : // deoptimization. This isn't strictly necessary, but it is bit easier to reason
     408                 :            : // about when thinking about the opcode transitions as a state machine:
     409                 :            : #define ADAPTIVE_COOLDOWN_VALUE 52
     410                 :            : #define ADAPTIVE_COOLDOWN_BACKOFF 0
     411                 :            : 
     412                 :            : #define MAX_BACKOFF_VALUE (16 - ADAPTIVE_BACKOFF_BITS)
     413                 :            : 
     414                 :            : 
     415                 :            : static inline uint16_t
     416                 :     405661 : adaptive_counter_bits(int value, int backoff) {
     417                 :     811322 :     return (value << ADAPTIVE_BACKOFF_BITS) |
     418                 :     405661 :         (backoff & ((1<<ADAPTIVE_BACKOFF_BITS)-1));
     419                 :            : }
     420                 :            : 
     421                 :            : static inline uint16_t
     422                 :     332738 : adaptive_counter_warmup(void) {
     423                 :     332738 :     return adaptive_counter_bits(ADAPTIVE_WARMUP_VALUE,
     424                 :            :                                  ADAPTIVE_WARMUP_BACKOFF);
     425                 :            : }
     426                 :            : 
     427                 :            : static inline uint16_t
     428                 :      50003 : adaptive_counter_cooldown(void) {
     429                 :      50003 :     return adaptive_counter_bits(ADAPTIVE_COOLDOWN_VALUE,
     430                 :            :                                  ADAPTIVE_COOLDOWN_BACKOFF);
     431                 :            : }
     432                 :            : 
     433                 :            : static inline uint16_t
     434                 :      22920 : adaptive_counter_backoff(uint16_t counter) {
     435                 :      22920 :     unsigned int backoff = counter & ((1<<ADAPTIVE_BACKOFF_BITS)-1);
     436                 :      22920 :     backoff++;
     437         [ +  + ]:      22920 :     if (backoff > MAX_BACKOFF_VALUE) {
     438                 :       2422 :         backoff = MAX_BACKOFF_VALUE;
     439                 :            :     }
     440                 :      22920 :     unsigned int value = (1 << backoff) - 1;
     441                 :      22920 :     return adaptive_counter_bits(value, backoff);
     442                 :            : }
     443                 :            : 
     444                 :            : 
     445                 :            : /* Line array cache for tracing */
     446                 :            : 
     447                 :            : extern int _PyCode_CreateLineArray(PyCodeObject *co);
     448                 :            : 
     449                 :            : static inline int
     450                 :          0 : _PyCode_InitLineArray(PyCodeObject *co)
     451                 :            : {
     452         [ #  # ]:          0 :     if (co->_co_linearray) {
     453                 :          0 :         return 0;
     454                 :            :     }
     455                 :          0 :     return _PyCode_CreateLineArray(co);
     456                 :            : }
     457                 :            : 
     458                 :            : static inline int
     459                 :          0 : _PyCode_LineNumberFromArray(PyCodeObject *co, int index)
     460                 :            : {
     461                 :            :     assert(co->_co_linearray != NULL);
     462                 :            :     assert(index >= 0);
     463                 :            :     assert(index < Py_SIZE(co));
     464         [ #  # ]:          0 :     if (co->_co_linearray_entry_size == 2) {
     465                 :          0 :         return ((int16_t *)co->_co_linearray)[index];
     466                 :            :     }
     467                 :            :     else {
     468                 :            :         assert(co->_co_linearray_entry_size == 4);
     469                 :          0 :         return ((int32_t *)co->_co_linearray)[index];
     470                 :            :     }
     471                 :            : }
     472                 :            : 
     473                 :            : typedef struct _PyShimCodeDef {
     474                 :            :     const uint8_t *code;
     475                 :            :     int codelen;
     476                 :            :     int stacksize;
     477                 :            :     const char *cname;
     478                 :            : } _PyShimCodeDef;
     479                 :            : 
     480                 :            : extern PyCodeObject *
     481                 :            : _Py_MakeShimCode(const _PyShimCodeDef *code);
     482                 :            : 
     483                 :            : extern uint32_t _Py_next_func_version;
     484                 :            : 
     485                 :            : 
     486                 :            : /* Comparison bit masks. */
     487                 :            : 
     488                 :            : /* Note this evaluates its arguments twice each */
     489                 :            : #define COMPARISON_BIT(x, y) (1 << (2 * ((x) >= (y)) + ((x) <= (y))))
     490                 :            : 
     491                 :            : /*
     492                 :            :  * The following bits are chosen so that the value of
     493                 :            :  * COMPARSION_BIT(left, right)
     494                 :            :  * masked by the values below will be non-zero if the
     495                 :            :  * comparison is true, and zero if it is false */
     496                 :            : 
     497                 :            : /* This is for values that are unordered, ie. NaN, not types that are unordered, e.g. sets */
     498                 :            : #define COMPARISON_UNORDERED 1
     499                 :            : 
     500                 :            : #define COMPARISON_LESS_THAN 2
     501                 :            : #define COMPARISON_GREATER_THAN 4
     502                 :            : #define COMPARISON_EQUALS 8
     503                 :            : 
     504                 :            : #define COMPARISON_NOT_EQUALS (COMPARISON_UNORDERED | COMPARISON_LESS_THAN | COMPARISON_GREATER_THAN)
     505                 :            : 
     506                 :            : 
     507                 :            : #ifdef __cplusplus
     508                 :            : }
     509                 :            : #endif
     510                 :            : #endif /* !Py_INTERNAL_CODE_H */

Generated by: LCOV version 1.14