/* Execute compiled code */

/* XXX TO DO:

XXX speed up searching for keywords by using a dictionary

XXX document it!

*/

/* enable more aggressive intra-module optimizations, where available */

#define PY_LOCAL_AGGRESSIVE

#include "Python.h"

#include "pycore_object.h"

#include "pycore_pystate.h"

#include "pycore_tupleobject.h"

#include "code.h"

#include "dictobject.h"

#include "frameobject.h"

#include "opcode.h"

#include "pydtrace.h"

#include "setobject.h"

#include "structmember.h"

#include <ctype.h>

#ifdef Py_DEBUG

/* For debugging the interpreter: */

#define LLTRACE 1 /* Low-level trace feature */

#define CHECKEXC 1 /* Double-check exception checking */

#endif

#if !defined(Py_BUILD_CORE)

# error "ceval.c must be build with Py_BUILD_CORE define for best performance"

#endif

/* Private API for the LOAD_METHOD opcode. */

extern int _PyObject_GetMethod(PyObject *, PyObject *, PyObject **);

typedef PyObject *(*callproc)(PyObject *, PyObject *, PyObject *);

/* Forward declarations */

Py_LOCAL_INLINE(PyObject *) call_function(PyObject ***, Py_ssize_t,

PyObject *);

static PyObject * do_call_core(PyObject *, PyObject *, PyObject *);

#ifdef LLTRACE

static int lltrace;

static int prtrace(PyObject *, const char *);

#endif

static int call_trace(Py_tracefunc, PyObject *,

PyThreadState *, PyFrameObject *,

int, PyObject *);

static int call_trace_protected(Py_tracefunc, PyObject *,

PyThreadState *, PyFrameObject *,

int, PyObject *);

static void call_exc_trace(Py_tracefunc, PyObject *,

PyThreadState *, PyFrameObject *);

static int maybe_call_line_trace(Py_tracefunc, PyObject *,

PyThreadState *, PyFrameObject *,

int *, int *, int *);

static void maybe_dtrace_line(PyFrameObject *, int *, int *, int *);

static void dtrace_function_entry(PyFrameObject *);

static void dtrace_function_return(PyFrameObject *);

static PyObject * cmp_outcome(int, PyObject *, PyObject *);

static PyObject * import_name(PyFrameObject *, PyObject *, PyObject *,

PyObject *);

static PyObject * import_from(PyObject *, PyObject *);

static int import_all_from(PyObject *, PyObject *);

static void format_exc_check_arg(PyObject *, const char *, PyObject *);

static void format_exc_unbound(PyCodeObject *co, int oparg);

static PyObject * unicode_concatenate(PyObject *, PyObject *,

PyFrameObject *, const _Py_CODEUNIT *);

static PyObject * special_lookup(PyObject *, _Py_Identifier *);

static int check_args_iterable(PyObject *func, PyObject *vararg);

static void format_kwargs_error(PyObject *func, PyObject *kwargs);

static void format_awaitable_error(PyTypeObject *, int);

static inline void exit_thread_if_finalizing(PyThreadState *);

#define NAME_ERROR_MSG \

"name '%.200s' is not defined"

#define UNBOUNDLOCAL_ERROR_MSG \

"local variable '%.200s' referenced before assignment"

#define UNBOUNDFREE_ERROR_MSG \

"free variable '%.200s' referenced before assignment" \

" in enclosing scope"

/* Dynamic execution profile */

#ifdef DYNAMIC_EXECUTION_PROFILE

#ifdef DXPAIRS

static long dxpairs[257][256];

#define dxp dxpairs[256]

#else

static long dxp[256];

#endif

#endif

#define GIL_REQUEST _Py_atomic_load_relaxed(&_PyRuntime.ceval.gil_drop_request)

/* This can set eval_breaker to 0 even though gil_drop_request became

1. We believe this is all right because the eval loop will release

the GIL eventually anyway. */

#define COMPUTE_EVAL_BREAKER() \

_Py_atomic_store_relaxed( \

&_PyRuntime.ceval.eval_breaker, \

GIL_REQUEST | \

_Py_atomic_load_relaxed(&_PyRuntime.ceval.signals_pending) | \

_Py_atomic_load_relaxed(&_PyRuntime.ceval.pending.calls_to_do) | \

_PyRuntime.ceval.pending.async_exc)

#define SET_GIL_DROP_REQUEST() \

do { \

_Py_atomic_store_relaxed(&_PyRuntime.ceval.gil_drop_request, 1); \

_Py_atomic_store_relaxed(&_PyRuntime.ceval.eval_breaker, 1); \

} while (0)

#define RESET_GIL_DROP_REQUEST() \

do { \

_Py_atomic_store_relaxed(&_PyRuntime.ceval.gil_drop_request, 0); \

COMPUTE_EVAL_BREAKER(); \

} while (0)

/* Pending calls are only modified under pending_lock */

#define SIGNAL_PENDING_CALLS() \

do { \

_Py_atomic_store_relaxed(&_PyRuntime.ceval.pending.calls_to_do, 1); \

_Py_atomic_store_relaxed(&_PyRuntime.ceval.eval_breaker, 1); \

} while (0)

#define UNSIGNAL_PENDING_CALLS() \

do { \

_Py_atomic_store_relaxed(&_PyRuntime.ceval.pending.calls_to_do, 0); \

COMPUTE_EVAL_BREAKER(); \

} while (0)

#define SIGNAL_PENDING_SIGNALS() \

do { \

_Py_atomic_store_relaxed(&_PyRuntime.ceval.signals_pending, 1); \

_Py_atomic_store_relaxed(&_PyRuntime.ceval.eval_breaker, 1); \

} while (0)

#define UNSIGNAL_PENDING_SIGNALS() \

do { \

_Py_atomic_store_relaxed(&_PyRuntime.ceval.signals_pending, 0); \

COMPUTE_EVAL_BREAKER(); \

} while (0)

#define SIGNAL_ASYNC_EXC() \

do { \

_PyRuntime.ceval.pending.async_exc = 1; \

_Py_atomic_store_relaxed(&_PyRuntime.ceval.eval_breaker, 1); \

} while (0)

#define UNSIGNAL_ASYNC_EXC() \

do { \

_PyRuntime.ceval.pending.async_exc = 0; \

COMPUTE_EVAL_BREAKER(); \

} while (0)

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#include "pythread.h"

#include "ceval_gil.h"

int

PyEval_ThreadsInitialized(void)

{

return gil_created();

}

void

PyEval_InitThreads(void)

{

if (gil_created()) {

return;

}

PyThread_init_thread();

create_gil();

take_gil(_PyThreadState_GET());

_PyRuntime.ceval.pending.lock = PyThread_allocate_lock();

if (_PyRuntime.ceval.pending.lock == NULL) {

Py_FatalError("Can't initialize threads for pending calls");

}

}

void

_PyEval_FiniThreads(void)

{

if (!gil_created()) {

return;

}

destroy_gil();

assert(!gil_created());

if (_PyRuntime.ceval.pending.lock != NULL) {

PyThread_free_lock(_PyRuntime.ceval.pending.lock);

_PyRuntime.ceval.pending.lock = NULL;

}

}

static inline void

exit_thread_if_finalizing(PyThreadState *tstate)

{

/* _Py_Finalizing is protected by the GIL */

if (_Py_IsFinalizing() && !_Py_CURRENTLY_FINALIZING(tstate)) {

drop_gil(tstate);

PyThread_exit_thread();

Py_UNREACHABLE();

}

}

void

PyEval_AcquireLock(void)

{

PyThreadState *tstate = _PyThreadState_GET();

if (tstate == NULL)

Py_FatalError("PyEval_AcquireLock: current thread state is NULL");

take_gil(tstate);

exit_thread_if_finalizing(tstate);

}

void

PyEval_ReleaseLock(void)

{

/* This function must succeed when the current thread state is NULL.

We therefore avoid PyThreadState_Get() which dumps a fatal error

in debug mode.

*/

drop_gil(_PyThreadState_GET());

}

void

PyEval_AcquireThread(PyThreadState *tstate)

{

if (tstate == NULL)

Py_FatalError("PyEval_AcquireThread: NULL new thread state");

/* Check someone has called PyEval_InitThreads() to create the lock */

assert(gil_created());

take_gil(tstate);

exit_thread_if_finalizing(tstate);

if (PyThreadState_Swap(tstate) != NULL)

Py_FatalError(

"PyEval_AcquireThread: non-NULL old thread state");

}

void

PyEval_ReleaseThread(PyThreadState *tstate)

{

if (tstate == NULL)

Py_FatalError("PyEval_ReleaseThread: NULL thread state");

if (PyThreadState_Swap(NULL) != tstate)

Py_FatalError("PyEval_ReleaseThread: wrong thread state");

drop_gil(tstate);

}

/* This function is called from PyOS_AfterFork_Child to destroy all threads

* which are not running in the child process, and clear internal locks

* which might be held by those threads.

*/

void

PyEval_ReInitThreads(void)

{

PyThreadState *current_tstate = _PyThreadState_GET();

if (!gil_created())

return;

recreate_gil();

take_gil(current_tstate);

_PyRuntime.ceval.pending.lock = PyThread_allocate_lock();

if (_PyRuntime.ceval.pending.lock == NULL) {

Py_FatalError("Can't initialize threads for pending calls");

}

/* Destroy all threads except the current one */

_PyThreadState_DeleteExcept(current_tstate);

}

/* This function is used to signal that async exceptions are waiting to be

raised. */

void

_PyEval_SignalAsyncExc(void)

{

SIGNAL_ASYNC_EXC();

}

PyThreadState *

PyEval_SaveThread(void)

{

PyThreadState *tstate = PyThreadState_Swap(NULL);

if (tstate == NULL)

Py_FatalError("PyEval_SaveThread: NULL tstate");

assert(gil_created());

drop_gil(tstate);

return tstate;

}

void

PyEval_RestoreThread(PyThreadState *tstate)

{

if (tstate == NULL)

Py_FatalError("PyEval_RestoreThread: NULL tstate");

assert(gil_created());

int err = errno;

take_gil(tstate);

exit_thread_if_finalizing(tstate);

errno = err;

PyThreadState_Swap(tstate);

}

/* Mechanism whereby asynchronously executing callbacks (e.g. UNIX

signal handlers or Mac I/O completion routines) can schedule calls

to a function to be called synchronously.

The synchronous function is called with one void* argument.

It should return 0 for success or -1 for failure -- failure should

be accompanied by an exception.

If registry succeeds, the registry function returns 0; if it fails

(e.g. due to too many pending calls) it returns -1 (without setting

an exception condition).

Note that because registry may occur from within signal handlers,

or other asynchronous events, calling malloc() is unsafe!

Any thread can schedule pending calls, but only the main thread

will execute them.

There is no facility to schedule calls to a particular thread, but

that should be easy to change, should that ever be required. In

that case, the static variables here should go into the python

threadstate.

*/

void

_PyEval_SignalReceived(void)

{

/* bpo-30703: Function called when the C signal handler of Python gets a

signal. We cannot queue a callback using Py_AddPendingCall() since

that function is not async-signal-safe. */

SIGNAL_PENDING_SIGNALS();

}

/* Push one item onto the queue while holding the lock. */

static int

_push_pending_call(struct _pending_calls *pending,

int (*func)(void *), void *arg)

{

int i = pending->last;

int j = (i + 1) % NPENDINGCALLS;

if (j == pending->first) {

return -1; /* Queue full */

}

pending->calls[i].func = func;

pending->calls[i].arg = arg;

pending->last = j;

return 0;

}

/* Pop one item off the queue while holding the lock. */

static void

_pop_pending_call(struct _pending_calls *pending,

int (**func)(void *), void **arg)

{

int i = pending->first;

if (i == pending->last) {

return; /* Queue empty */

}

*func = pending->calls[i].func;

*arg = pending->calls[i].arg;

pending->first = (i + 1) % NPENDINGCALLS;

}

/* This implementation is thread-safe. It allows

scheduling to be made from any thread, and even from an executing

callback.

*/

int

Py_AddPendingCall(int (*func)(void *), void *arg)

{

struct _pending_calls *pending = &_PyRuntime.ceval.pending;

PyThread_acquire_lock(pending->lock, WAIT_LOCK);

if (pending->finishing) {

PyThread_release_lock(pending->lock);

PyObject *exc, *val, *tb;

PyErr_Fetch(&exc, &val, &tb);

PyErr_SetString(PyExc_SystemError,

"Py_AddPendingCall: cannot add pending calls "

"(Python shutting down)");

PyErr_Print();

PyErr_Restore(exc, val, tb);

return -1;

}

int result = _push_pending_call(pending, func, arg);

PyThread_release_lock(pending->lock);

/* signal main loop */

SIGNAL_PENDING_CALLS();

return result;

}

static int

handle_signals(void)

{

/* Only handle signals on main thread. PyEval_InitThreads must

* have been called already.

*/

if (PyThread_get_thread_ident() != _PyRuntime.main_thread) {

return 0;

}

/*

* Ensure that the thread isn't currently running some other

* interpreter.

*/

if (_PyInterpreterState_GET_UNSAFE() != _PyRuntime.interpreters.main) {

return 0;

}

UNSIGNAL_PENDING_SIGNALS();

if (_PyErr_CheckSignals() < 0) {

SIGNAL_PENDING_SIGNALS(); /* We're not done yet */

return -1;

}

return 0;

}

static int

make_pending_calls(struct _pending_calls* pending)

{

static int busy = 0;

/* only service pending calls on main thread */

if (PyThread_get_thread_ident() != _PyRuntime.main_thread) {

return 0;

}

/* don't perform recursive pending calls */

if (busy) {

return 0;

}

busy = 1;

/* unsignal before starting to call callbacks, so that any callback

added in-between re-signals */

UNSIGNAL_PENDING_CALLS();

int res = 0;

/* perform a bounded number of calls, in case of recursion */

for (int i=0; i<NPENDINGCALLS; i++) {

int (*func)(void *) = NULL;

void *arg = NULL;

/* pop one item off the queue while holding the lock */

PyThread_acquire_lock(pending->lock, WAIT_LOCK);

_pop_pending_call(pending, &func, &arg);

PyThread_release_lock(pending->lock);

/* having released the lock, perform the callback */

if (func == NULL) {

break;

}

res = func(arg);

if (res) {

goto error;

}

}

busy = 0;

return res;

error:

busy = 0;

SIGNAL_PENDING_CALLS();

return res;

}

void

_Py_FinishPendingCalls(void)

{

struct _pending_calls *pending = &_PyRuntime.ceval.pending;

assert(PyGILState_Check());

PyThread_acquire_lock(pending->lock, WAIT_LOCK);

pending->finishing = 1;

PyThread_release_lock(pending->lock);

if (!_Py_atomic_load_relaxed(&(pending->calls_to_do))) {

return;

}

if (make_pending_calls(pending) < 0) {

PyObject *exc, *val, *tb;

PyErr_Fetch(&exc, &val, &tb);

PyErr_BadInternalCall();

_PyErr_ChainExceptions(exc, val, tb);

PyErr_Print();

}

}

/* Py_MakePendingCalls() is a simple wrapper for the sake

of backward-compatibility. */

int

Py_MakePendingCalls(void)

{

assert(PyGILState_Check());

/* Python signal handler doesn't really queue a callback: it only signals

that a signal was received, see _PyEval_SignalReceived(). */

int res = handle_signals();

if (res != 0) {

return res;

}

res = make_pending_calls(&_PyRuntime.ceval.pending);

if (res != 0) {

return res;

}

return 0;

}

/* The interpreter's recursion limit */

#ifndef Py_DEFAULT_RECURSION_LIMIT

#define Py_DEFAULT_RECURSION_LIMIT 1000

#endif

int _Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT;

void

_PyEval_Initialize(struct _ceval_runtime_state *state)

{

state->recursion_limit = Py_DEFAULT_RECURSION_LIMIT;

_Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT;

_gil_initialize(&state->gil);

}

int

Py_GetRecursionLimit(void)

{

return _PyRuntime.ceval.recursion_limit;

}

void

Py_SetRecursionLimit(int new_limit)

{

_PyRuntime.ceval.recursion_limit = new_limit;

_Py_CheckRecursionLimit = _PyRuntime.ceval.recursion_limit;

}

/* the macro Py_EnterRecursiveCall() only calls _Py_CheckRecursiveCall()

if the recursion_depth reaches _Py_CheckRecursionLimit.

If USE_STACKCHECK, the macro decrements _Py_CheckRecursionLimit

to guarantee that _Py_CheckRecursiveCall() is regularly called.

Without USE_STACKCHECK, there is no need for this. */

int

_Py_CheckRecursiveCall(const char *where)

{

PyThreadState *tstate = _PyThreadState_GET();

int recursion_limit = _PyRuntime.ceval.recursion_limit;

#ifdef USE_STACKCHECK

tstate->stackcheck_counter = 0;

if (PyOS_CheckStack()) {

--tstate->recursion_depth;

PyErr_SetString(PyExc_MemoryError, "Stack overflow");

return -1;

}

/* Needed for ABI backwards-compatibility (see bpo-31857) */

_Py_CheckRecursionLimit = recursion_limit;

#endif

if (tstate->recursion_critical)

/* Somebody asked that we don't check for recursion. */

return 0;

if (tstate->overflowed) {

if (tstate->recursion_depth > recursion_limit + 50) {

/* Overflowing while handling an overflow. Give up. */

Py_FatalError("Cannot recover from stack overflow.");

}

return 0;

}

if (tstate->recursion_depth > recursion_limit) {

--tstate->recursion_depth;

tstate->overflowed = 1;

PyErr_Format(PyExc_RecursionError,

"maximum recursion depth exceeded%s",

where);

return -1;

}

return 0;

}

static int do_raise(PyObject *, PyObject *);

static int unpack_iterable(PyObject *, int, int, PyObject **);

#define _Py_TracingPossible _PyRuntime.ceval.tracing_possible

PyObject *

PyEval_EvalCode(PyObject *co, PyObject *globals, PyObject *locals)

{

return PyEval_EvalCodeEx(co,

globals, locals,

(PyObject **)NULL, 0,

(PyObject **)NULL, 0,

(PyObject **)NULL, 0,

NULL, NULL);

}

/* Interpreter main loop */

PyObject *

PyEval_EvalFrame(PyFrameObject *f) {

/* This is for backward compatibility with extension modules that

used this API; core interpreter code should call

PyEval_EvalFrameEx() */

return PyEval_EvalFrameEx(f, 0);

}

PyObject *

PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)

{

PyInterpreterState *interp = _PyInterpreterState_GET_UNSAFE();

return interp->eval_frame(f, throwflag);

}

PyObject* _Py_HOT_FUNCTION

_PyEval_EvalFrameDefault(PyFrameObject *f, int throwflag)

{

#ifdef DXPAIRS

int lastopcode = 0;

#endif

PyObject **stack_pointer; /* Next free slot in value stack */

const _Py_CODEUNIT *next_instr;

int opcode; /* Current opcode */

int oparg; /* Current opcode argument, if any */

PyObject **fastlocals, **freevars;

PyObject *retval = NULL; /* Return value */

PyThreadState *tstate = _PyThreadState_GET();

_Py_atomic_int *eval_breaker = &_PyRuntime.ceval.eval_breaker;

PyCodeObject *co;

/* when tracing we set things up so that

not (instr_lb <= current_bytecode_offset < instr_ub)

is true when the line being executed has changed. The

initial values are such as to make this false the first

time it is tested. */

int instr_ub = -1, instr_lb = 0, instr_prev = -1;

const _Py_CODEUNIT *first_instr;

PyObject *names;

PyObject *consts;

#ifdef LLTRACE

_Py_IDENTIFIER(__ltrace__);

#endif

/* Computed GOTOs, or

the-optimization-commonly-but-improperly-known-as-"threaded code"

using gcc's labels-as-values extension

(http://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html).

The traditional bytecode evaluation loop uses a "switch" statement, which

decent compilers will optimize as a single indirect branch instruction

combined with a lookup table of jump addresses. However, since the

indirect jump instruction is shared by all opcodes, the CPU will have a

hard time making the right prediction for where to jump next (actually,

it will be always wrong except in the uncommon case of a sequence of

several identical opcodes).

"Threaded code" in contrast, uses an explicit jump table and an explicit

indirect jump instruction at the end of each opcode. Since the jump

instruction is at a different address for each opcode, the CPU will make a

separate prediction for each of these instructions, which is equivalent to

predicting the second opcode of each opcode pair. These predictions have

a much better chance to turn out valid, especially in small bytecode loops.

A mispredicted branch on a modern CPU flushes the whole pipeline and

can cost several CPU cycles (depending on the pipeline depth),

and potentially many more instructions (depending on the pipeline width).

A correctly predicted branch, however, is nearly free.

At the time of this writing, the "threaded code" version is up to 15-20%

faster than the normal "switch" version, depending on the compiler and the

CPU architecture.

We disable the optimization if DYNAMIC_EXECUTION_PROFILE is defined,

because it would render the measurements invalid.

NOTE: care must be taken that the compiler doesn't try to "optimize" the

indirect jumps by sharing them between all opcodes. Such optimizations

can be disabled on gcc by using the -fno-gcse flag (or possibly

-fno-crossjumping).

*/

#ifdef DYNAMIC_EXECUTION_PROFILE

#undef USE_COMPUTED_GOTOS

#define USE_COMPUTED_GOTOS 0

#endif

#ifdef HAVE_COMPUTED_GOTOS

#ifndef USE_COMPUTED_GOTOS

#define USE_COMPUTED_GOTOS 1

#endif

#else

#if defined(USE_COMPUTED_GOTOS) && USE_COMPUTED_GOTOS

#error "Computed gotos are not supported on this compiler."

#endif

#undef USE_COMPUTED_GOTOS

#define USE_COMPUTED_GOTOS 0

#endif

#if USE_COMPUTED_GOTOS

/* Import the static jump table */

#include "opcode_targets.h"

#define TARGET(op) \

op: \

TARGET_##op

#define DISPATCH() \

{ \

if (!_Py_atomic_load_relaxed(eval_breaker)) { \

FAST_DISPATCH(); \

} \

continue; \

}

#ifdef LLTRACE

#define FAST_DISPATCH() \

{ \

if (!lltrace && !_Py_TracingPossible && !PyDTrace_LINE_ENABLED()) { \

f->f_lasti = INSTR_OFFSET(); \

NEXTOPARG(); \

goto *opcode_targets[opcode]; \

} \

goto fast_next_opcode; \

}

#else

#define FAST_DISPATCH() \

{ \

if (!_Py_TracingPossible && !PyDTrace_LINE_ENABLED()) { \

f->f_lasti = INSTR_OFFSET(); \

NEXTOPARG(); \

goto *opcode_targets[opcode]; \

} \

goto fast_next_opcode; \

}

#endif

#else

#define TARGET(op) op

#define DISPATCH() continue

#define FAST_DISPATCH() goto fast_next_opcode

#endif

/* Tuple access macros */

#ifndef Py_DEBUG

#define GETITEM(v, i) PyTuple_GET_ITEM((PyTupleObject *)(v), (i))

#else

#define GETITEM(v, i) PyTuple_GetItem((v), (i))

#endif

/* Code access macros */

/* The integer overflow is checked by an assertion below. */

#define INSTR_OFFSET() \

(sizeof(_Py_CODEUNIT) * (int)(next_instr - first_instr))

#define NEXTOPARG() do { \

_Py_CODEUNIT word = *next_instr; \

opcode = _Py_OPCODE(word); \

oparg = _Py_OPARG(word); \

next_instr++; \

} while (0)

#define JUMPTO(x) (next_instr = first_instr + (x) / sizeof(_Py_CODEUNIT))

#define JUMPBY(x) (next_instr += (x) / sizeof(_Py_CODEUNIT))

/* OpCode prediction macros

Some opcodes tend to come in pairs thus making it possible to

predict the second code when the first is run. For example,

COMPARE_OP is often followed by POP_JUMP_IF_FALSE or POP_JUMP_IF_TRUE.

Verifying the prediction costs a single high-speed test of a register

variable against a constant. If the pairing was good, then the

processor's own internal branch predication has a high likelihood of

success, resulting in a nearly zero-overhead transition to the

next opcode. A successful prediction saves a trip through the eval-loop

including its unpredictable switch-case branch. Combined with the

processor's internal branch prediction, a successful PREDICT has the

effect of making the two opcodes run as if they were a single new opcode

with the bodies combined.

If collecting opcode statistics, your choices are to either keep the

predictions turned-on and interpret the results as if some opcodes

had been combined or turn-off predictions so that the opcode frequency

counter updates for both opcodes.

Opcode prediction is disabled with threaded code, since the latter allows

the CPU to record separate branch prediction information for each

opcode.

*/

#if defined(DYNAMIC_EXECUTION_PROFILE) || USE_COMPUTED_GOTOS

#define PREDICT(op) if (0) goto PRED_##op

#else

#define PREDICT(op) \

do{ \

_Py_CODEUNIT word = *next_instr; \

opcode = _Py_OPCODE(word); \

if (opcode == op){ \

oparg = _Py_OPARG(word); \

next_instr++; \

goto PRED_##op; \

} \

} while(0)

#endif

#define PREDICTED(op) PRED_##op:

/* Stack manipulation macros */

/* The stack can grow at most MAXINT deep, as co_nlocals and

co_stacksize are ints. */

#define STACK_LEVEL() ((int)(stack_pointer - f->f_valuestack))

#define EMPTY() (STACK_LEVEL() == 0)

#define TOP() (stack_pointer[-1])

#define SECOND() (stack_pointer[-2])

#define THIRD() (stack_pointer[-3])

#define FOURTH() (stack_pointer[-4])

#define PEEK(n) (stack_pointer[-(n)])

#define SET_TOP(v) (stack_pointer[-1] = (v))

#define SET_SECOND(v) (stack_pointer[-2] = (v))

#define SET_THIRD(v) (stack_pointer[-3] = (v))

#define SET_FOURTH(v) (stack_pointer[-4] = (v))

#define SET_VALUE(n, v) (stack_pointer[-(n)] = (v))

#define BASIC_STACKADJ(n) (stack_pointer += n)

#define BASIC_PUSH(v) (*stack_pointer++ = (v))

#define BASIC_POP() (*--stack_pointer)

#ifdef LLTRACE

#define PUSH(v) { (void)(BASIC_PUSH(v), \

lltrace && prtrace(TOP(), "push")); \

assert(STACK_LEVEL() <= co->co_stacksize); }

#define POP() ((void)(lltrace && prtrace(TOP(), "pop")), \

BASIC_POP())

#define STACK_GROW(n) do { \

assert(n >= 0); \

(void)(BASIC_STACKADJ(n), \

lltrace && prtrace(TOP(), "stackadj")); \

assert(STACK_LEVEL() <= co->co_stacksize); \

} while (0)

#define STACK_SHRINK(n) do { \

assert(n >= 0); \

(void)(lltrace && prtrace(TOP(), "stackadj")); \

(void)(BASIC_STACKADJ(-n)); \

assert(STACK_LEVEL() <= co->co_stacksize); \

} while (0)

#define EXT_POP(STACK_POINTER) ((void)(lltrace && \

prtrace((STACK_POINTER)[-1], "ext_pop")), \

*--(STACK_POINTER))

#else

#define PUSH(v) BASIC_PUSH(v)

#define POP() BASIC_POP()

#define STACK_GROW(n) BASIC_STACKADJ(n)

#define STACK_SHRINK(n) BASIC_STACKADJ(-n)

#define EXT_POP(STACK_POINTER) (*--(STACK_POINTER))

#endif

/* Local variable macros */

#define GETLOCAL(i) (fastlocals[i])

/* The SETLOCAL() macro must not DECREF the local variable in-place and

then store the new value; it must copy the old value to a temporary

value, then store the new value, and then DECREF the temporary value.

This is because it is possible that during the DECREF the frame is

accessed by other code (e.g. a __del__ method or gc.collect()) and the

variable would be pointing to already-freed memory. */

#define SETLOCAL(i, value) do { PyObject *tmp = GETLOCAL(i); \

GETLOCAL(i) = value; \

Py_XDECREF(tmp); } while (0)

#define UNWIND_BLOCK(b) \

while (STACK_LEVEL() > (b)->b_level) { \

PyObject *v = POP(); \

Py_XDECREF(v); \

}

#define UNWIND_EXCEPT_HANDLER(b) \

do { \

PyObject *type, *value, *traceback; \

_PyErr_StackItem *exc_info; \

assert(STACK_LEVEL() >= (b)->b_level + 3); \

while (STACK_LEVEL() > (b)->b_level + 3) { \

value = POP(); \

Py_XDECREF(value); \

} \

exc_info = tstate->exc_info; \

type = exc_info->exc_type; \

value = exc_info->exc_value; \

traceback = exc_info->exc_traceback; \

exc_info->exc_type = POP(); \

exc_info->exc_value = POP(); \

exc_info->exc_traceback = POP(); \

Py_XDECREF(type); \

Py_XDECREF(value); \

Py_XDECREF(traceback); \

} while(0)

/* Start of code */

/* push frame */

if (Py_EnterRecursiveCall(""))

return NULL;

tstate->frame = f;

if (tstate->use_tracing) {

if (tstate->c_tracefunc != NULL) {

/* tstate->c_tracefunc, if defined, is a

function that will be called on *every* entry

to a code block. Its return value, if not

None, is a function that will be called at

the start of each executed line of code.

(Actually, the function must return itself

in order to continue tracing.) The trace

functions are called with three arguments:

a pointer to the current frame, a string

indicating why the function is called, and

an argument which depends on the situation.

The global trace function is also called

whenever an exception is detected. */

if (call_trace_protected(tstate->c_tracefunc,

tstate->c_traceobj,

tstate, f, PyTrace_CALL, Py_None)) {

/* Trace function raised an error */

goto exit_eval_frame;

}

}

if (tstate->c_profilefunc != NULL) {

/* Similar for c_profilefunc, except it needn't

return itself and isn't called for "line" events */

if (call_trace_protected(tstate->c_profilefunc,

tstate->c_profileobj,

tstate, f, PyTrace_CALL, Py_None)) {

/* Profile function raised an error */

goto exit_eval_frame;

}

}

}

if (PyDTrace_FUNCTION_ENTRY_ENABLED())

dtrace_function_entry(f);

co = f->f_code;

names = co->co_names;

consts = co->co_consts;

fastlocals = f->f_localsplus;

freevars = f->f_localsplus + co->co_nlocals;

assert(PyBytes_Check(co->co_code));

assert(PyBytes_GET_SIZE(co->co_code) <= INT_MAX);

assert(PyBytes_GET_SIZE(co->co_code) % sizeof(_Py_CODEUNIT) == 0);

assert(_Py_IS_ALIGNED(PyBytes_AS_STRING(co->co_code), sizeof(_Py_CODEUNIT)));

first_instr = (_Py_CODEUNIT *) PyBytes_AS_STRING(co->co_code);

/*

f->f_lasti refers to the index of the last instruction,

unless it's -1 in which case next_instr should be first_instr.

YIELD_FROM sets f_lasti to itself, in order to repeatedly yield

multiple values.

When the PREDICT() macros are enabled, some opcode pairs follow in

direct succession without updating f->f_lasti. A successful

prediction effectively links the two codes together as if they

were a single new opcode; accordingly,f->f_lasti will point to

the first code in the pair (for instance, GET_ITER followed by

FOR_ITER is effectively a single opcode and f->f_lasti will point

to the beginning of the combined pair.)