blob: d6dba56b3c3857c2ad6f9871722e8307ef9a9ad9 [file] [log] [blame]
Guido van Rossumf70e43a1991-02-19 12:39:46 +00001
Guido van Rossum3f5da241990-12-20 15:06:42 +00002/* Execute compiled code */
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003
Guido van Rossum681d79a1995-07-18 14:51:37 +00004/* XXX TO DO:
Guido van Rossum681d79a1995-07-18 14:51:37 +00005 XXX speed up searching for keywords by using a dictionary
Guido van Rossum681d79a1995-07-18 14:51:37 +00006 XXX document it!
7 */
8
Thomas Wouters477c8d52006-05-27 19:21:47 +00009/* enable more aggressive intra-module optimizations, where available */
10#define PY_LOCAL_AGGRESSIVE
11
Guido van Rossumb209a111997-04-29 18:18:01 +000012#include "Python.h"
Guido van Rossum10dc2e81990-11-18 17:27:39 +000013
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000014#include "code.h"
Guido van Rossum3f5da241990-12-20 15:06:42 +000015#include "frameobject.h"
Guido van Rossum10dc2e81990-11-18 17:27:39 +000016#include "opcode.h"
Tim Peters6d6c1a32001-08-02 04:15:00 +000017#include "structmember.h"
Guido van Rossum10dc2e81990-11-18 17:27:39 +000018
Guido van Rossumc6004111993-11-05 10:22:19 +000019#include <ctype.h>
20
Thomas Wouters477c8d52006-05-27 19:21:47 +000021#ifndef WITH_TSC
Michael W. Hudson75eabd22005-01-18 15:56:11 +000022
23#define READ_TIMESTAMP(var)
24
25#else
Martin v. Löwisf30d60e2004-06-08 08:17:44 +000026
27typedef unsigned long long uint64;
28
Ezio Melotti13925002011-03-16 11:05:33 +020029/* PowerPC support.
David Malcolmf1397ad2011-01-06 17:01:36 +000030 "__ppc__" appears to be the preprocessor definition to detect on OS X, whereas
31 "__powerpc__" appears to be the correct one for Linux with GCC
32*/
33#if defined(__ppc__) || defined (__powerpc__)
Michael W. Hudson800ba232004-08-12 18:19:17 +000034
Michael W. Hudson75eabd22005-01-18 15:56:11 +000035#define READ_TIMESTAMP(var) ppc_getcounter(&var)
Michael W. Hudson800ba232004-08-12 18:19:17 +000036
37static void
38ppc_getcounter(uint64 *v)
39{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000040 register unsigned long tbu, tb, tbu2;
Michael W. Hudson800ba232004-08-12 18:19:17 +000041
42 loop:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000043 asm volatile ("mftbu %0" : "=r" (tbu) );
44 asm volatile ("mftb %0" : "=r" (tb) );
45 asm volatile ("mftbu %0" : "=r" (tbu2));
46 if (__builtin_expect(tbu != tbu2, 0)) goto loop;
Michael W. Hudson800ba232004-08-12 18:19:17 +000047
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000048 /* The slightly peculiar way of writing the next lines is
49 compiled better by GCC than any other way I tried. */
50 ((long*)(v))[0] = tbu;
51 ((long*)(v))[1] = tb;
Michael W. Hudson800ba232004-08-12 18:19:17 +000052}
53
Mark Dickinsona25b1312009-10-31 10:18:44 +000054#elif defined(__i386__)
55
56/* this is for linux/x86 (and probably any other GCC/x86 combo) */
Michael W. Hudson800ba232004-08-12 18:19:17 +000057
Michael W. Hudson75eabd22005-01-18 15:56:11 +000058#define READ_TIMESTAMP(val) \
59 __asm__ __volatile__("rdtsc" : "=A" (val))
Michael W. Hudson800ba232004-08-12 18:19:17 +000060
Mark Dickinsona25b1312009-10-31 10:18:44 +000061#elif defined(__x86_64__)
62
63/* for gcc/x86_64, the "A" constraint in DI mode means *either* rax *or* rdx;
64 not edx:eax as it does for i386. Since rdtsc puts its result in edx:eax
65 even in 64-bit mode, we need to use "a" and "d" for the lower and upper
66 32-bit pieces of the result. */
67
68#define READ_TIMESTAMP(val) \
69 __asm__ __volatile__("rdtsc" : \
70 "=a" (((int*)&(val))[0]), "=d" (((int*)&(val))[1]));
71
72
73#else
74
75#error "Don't know how to implement timestamp counter for this architecture"
76
Michael W. Hudson800ba232004-08-12 18:19:17 +000077#endif
78
Thomas Wouters477c8d52006-05-27 19:21:47 +000079void dump_tsc(int opcode, int ticked, uint64 inst0, uint64 inst1,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000080 uint64 loop0, uint64 loop1, uint64 intr0, uint64 intr1)
Martin v. Löwisf30d60e2004-06-08 08:17:44 +000081{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000082 uint64 intr, inst, loop;
83 PyThreadState *tstate = PyThreadState_Get();
84 if (!tstate->interp->tscdump)
85 return;
86 intr = intr1 - intr0;
87 inst = inst1 - inst0 - intr;
88 loop = loop1 - loop0 - intr;
89 fprintf(stderr, "opcode=%03d t=%d inst=%06lld loop=%06lld\n",
Stefan Krahb7e10102010-06-23 18:42:39 +000090 opcode, ticked, inst, loop);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +000091}
Michael W. Hudson800ba232004-08-12 18:19:17 +000092
Martin v. Löwisf30d60e2004-06-08 08:17:44 +000093#endif
94
Guido van Rossum04691fc1992-08-12 15:35:34 +000095/* Turn this on if your compiler chokes on the big switch: */
Guido van Rossum1ae940a1995-01-02 19:04:15 +000096/* #define CASE_TOO_BIG 1 */
Guido van Rossum04691fc1992-08-12 15:35:34 +000097
Guido van Rossum408027e1996-12-30 16:17:54 +000098#ifdef Py_DEBUG
Guido van Rossum96a42c81992-01-12 02:29:51 +000099/* For debugging the interpreter: */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000100#define LLTRACE 1 /* Low-level trace feature */
101#define CHECKEXC 1 /* Double-check exception checking */
Guido van Rossum10dc2e81990-11-18 17:27:39 +0000102#endif
103
Jeremy Hylton52820442001-01-03 23:52:36 +0000104typedef PyObject *(*callproc)(PyObject *, PyObject *, PyObject *);
Guido van Rossum5b722181993-03-30 17:46:03 +0000105
Guido van Rossum374a9221991-04-04 10:40:29 +0000106/* Forward declarations */
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000107#ifdef WITH_TSC
Thomas Wouters477c8d52006-05-27 19:21:47 +0000108static PyObject * call_function(PyObject ***, int, uint64*, uint64*);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000109#else
Thomas Wouters477c8d52006-05-27 19:21:47 +0000110static PyObject * call_function(PyObject ***, int);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000111#endif
Thomas Wouters477c8d52006-05-27 19:21:47 +0000112static PyObject * fast_function(PyObject *, PyObject ***, int, int, int);
113static PyObject * do_call(PyObject *, PyObject ***, int, int);
114static PyObject * ext_do_call(PyObject *, PyObject ***, int, int, int);
Thomas Wouters8ce81f72007-09-20 18:22:40 +0000115static PyObject * update_keyword_args(PyObject *, int, PyObject ***,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000116 PyObject *);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000117static PyObject * update_star_args(int, int, PyObject *, PyObject ***);
118static PyObject * load_args(PyObject ***, int);
Jeremy Hylton52820442001-01-03 23:52:36 +0000119#define CALL_FLAG_VAR 1
120#define CALL_FLAG_KW 2
121
Guido van Rossum0a066c01992-03-27 17:29:15 +0000122#ifdef LLTRACE
Guido van Rossumc2e20742006-02-27 22:32:47 +0000123static int lltrace;
Tim Petersdbd9ba62000-07-09 03:09:57 +0000124static int prtrace(PyObject *, char *);
Guido van Rossum0a066c01992-03-27 17:29:15 +0000125#endif
Fred Drake5755ce62001-06-27 19:19:46 +0000126static int call_trace(Py_tracefunc, PyObject *, PyFrameObject *,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000127 int, PyObject *);
Amaury Forgeot d'Arcf05149a2007-11-13 01:05:30 +0000128static int call_trace_protected(Py_tracefunc, PyObject *,
Stefan Krahb7e10102010-06-23 18:42:39 +0000129 PyFrameObject *, int, PyObject *);
Fred Drake5755ce62001-06-27 19:19:46 +0000130static void call_exc_trace(Py_tracefunc, PyObject *, PyFrameObject *);
Tim Peters8a5c3c72004-04-05 19:36:21 +0000131static int maybe_call_line_trace(Py_tracefunc, PyObject *,
Stefan Krahb7e10102010-06-23 18:42:39 +0000132 PyFrameObject *, int *, int *, int *);
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000133
Thomas Wouters477c8d52006-05-27 19:21:47 +0000134static PyObject * cmp_outcome(int, PyObject *, PyObject *);
135static PyObject * import_from(PyObject *, PyObject *);
Thomas Wouters52152252000-08-17 22:55:00 +0000136static int import_all_from(PyObject *, PyObject *);
Neal Norwitzda059e32007-08-26 05:33:45 +0000137static void format_exc_check_arg(PyObject *, const char *, PyObject *);
Amaury Forgeot d'Arcba117ef2010-09-10 21:39:53 +0000138static void format_exc_unbound(PyCodeObject *co, int oparg);
Victor Stinnerd2a915d2011-10-02 20:34:20 +0200139static PyObject * unicode_concatenate(PyObject *, PyObject *,
140 PyFrameObject *, unsigned char *);
Benjamin Petersonce798522012-01-22 11:24:29 -0500141static PyObject * special_lookup(PyObject *, _Py_Identifier *);
Guido van Rossum374a9221991-04-04 10:40:29 +0000142
Paul Prescode68140d2000-08-30 20:25:01 +0000143#define NAME_ERROR_MSG \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000144 "name '%.200s' is not defined"
Paul Prescode68140d2000-08-30 20:25:01 +0000145#define UNBOUNDLOCAL_ERROR_MSG \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000146 "local variable '%.200s' referenced before assignment"
Jeremy Hyltonc76770c2001-04-13 16:51:46 +0000147#define UNBOUNDFREE_ERROR_MSG \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000148 "free variable '%.200s' referenced before assignment" \
149 " in enclosing scope"
Guido van Rossum374a9221991-04-04 10:40:29 +0000150
Guido van Rossum950361c1997-01-24 13:49:28 +0000151/* Dynamic execution profile */
152#ifdef DYNAMIC_EXECUTION_PROFILE
153#ifdef DXPAIRS
154static long dxpairs[257][256];
155#define dxp dxpairs[256]
156#else
157static long dxp[256];
158#endif
159#endif
160
Jeremy Hylton985eba52003-02-05 23:13:00 +0000161/* Function call profile */
162#ifdef CALL_PROFILE
163#define PCALL_NUM 11
164static int pcall[PCALL_NUM];
165
166#define PCALL_ALL 0
167#define PCALL_FUNCTION 1
168#define PCALL_FAST_FUNCTION 2
169#define PCALL_FASTER_FUNCTION 3
170#define PCALL_METHOD 4
171#define PCALL_BOUND_METHOD 5
172#define PCALL_CFUNCTION 6
173#define PCALL_TYPE 7
174#define PCALL_GENERATOR 8
175#define PCALL_OTHER 9
176#define PCALL_POP 10
177
178/* Notes about the statistics
179
180 PCALL_FAST stats
181
182 FAST_FUNCTION means no argument tuple needs to be created.
183 FASTER_FUNCTION means that the fast-path frame setup code is used.
184
185 If there is a method call where the call can be optimized by changing
186 the argument tuple and calling the function directly, it gets recorded
187 twice.
188
189 As a result, the relationship among the statistics appears to be
190 PCALL_ALL == PCALL_FUNCTION + PCALL_METHOD - PCALL_BOUND_METHOD +
191 PCALL_CFUNCTION + PCALL_TYPE + PCALL_GENERATOR + PCALL_OTHER
192 PCALL_FUNCTION > PCALL_FAST_FUNCTION > PCALL_FASTER_FUNCTION
193 PCALL_METHOD > PCALL_BOUND_METHOD
194*/
195
196#define PCALL(POS) pcall[POS]++
197
198PyObject *
199PyEval_GetCallStats(PyObject *self)
200{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000201 return Py_BuildValue("iiiiiiiiiii",
202 pcall[0], pcall[1], pcall[2], pcall[3],
203 pcall[4], pcall[5], pcall[6], pcall[7],
204 pcall[8], pcall[9], pcall[10]);
Jeremy Hylton985eba52003-02-05 23:13:00 +0000205}
206#else
207#define PCALL(O)
208
209PyObject *
210PyEval_GetCallStats(PyObject *self)
211{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000212 Py_INCREF(Py_None);
213 return Py_None;
Jeremy Hylton985eba52003-02-05 23:13:00 +0000214}
215#endif
216
Tim Peters5ca576e2001-06-18 22:08:13 +0000217
Benjamin Petersond2be5b42010-09-10 22:47:02 +0000218#ifdef WITH_THREAD
219#define GIL_REQUEST _Py_atomic_load_relaxed(&gil_drop_request)
220#else
221#define GIL_REQUEST 0
222#endif
223
Jeffrey Yasskin39370832010-05-03 19:29:34 +0000224/* This can set eval_breaker to 0 even though gil_drop_request became
225 1. We believe this is all right because the eval loop will release
226 the GIL eventually anyway. */
Antoine Pitrou074e5ed2009-11-10 19:50:40 +0000227#define COMPUTE_EVAL_BREAKER() \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000228 _Py_atomic_store_relaxed( \
229 &eval_breaker, \
Benjamin Petersond2be5b42010-09-10 22:47:02 +0000230 GIL_REQUEST | \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000231 _Py_atomic_load_relaxed(&pendingcalls_to_do) | \
232 pending_async_exc)
Antoine Pitrou074e5ed2009-11-10 19:50:40 +0000233
Benjamin Petersond2be5b42010-09-10 22:47:02 +0000234#ifdef WITH_THREAD
235
Antoine Pitrou074e5ed2009-11-10 19:50:40 +0000236#define SET_GIL_DROP_REQUEST() \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000237 do { \
238 _Py_atomic_store_relaxed(&gil_drop_request, 1); \
239 _Py_atomic_store_relaxed(&eval_breaker, 1); \
240 } while (0)
Antoine Pitrou074e5ed2009-11-10 19:50:40 +0000241
242#define RESET_GIL_DROP_REQUEST() \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000243 do { \
244 _Py_atomic_store_relaxed(&gil_drop_request, 0); \
245 COMPUTE_EVAL_BREAKER(); \
246 } while (0)
Antoine Pitrou074e5ed2009-11-10 19:50:40 +0000247
Benjamin Petersond2be5b42010-09-10 22:47:02 +0000248#endif
249
Jeffrey Yasskin39370832010-05-03 19:29:34 +0000250/* Pending calls are only modified under pending_lock */
Antoine Pitrou074e5ed2009-11-10 19:50:40 +0000251#define SIGNAL_PENDING_CALLS() \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000252 do { \
253 _Py_atomic_store_relaxed(&pendingcalls_to_do, 1); \
254 _Py_atomic_store_relaxed(&eval_breaker, 1); \
255 } while (0)
Antoine Pitrou074e5ed2009-11-10 19:50:40 +0000256
257#define UNSIGNAL_PENDING_CALLS() \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000258 do { \
259 _Py_atomic_store_relaxed(&pendingcalls_to_do, 0); \
260 COMPUTE_EVAL_BREAKER(); \
261 } while (0)
Antoine Pitrou074e5ed2009-11-10 19:50:40 +0000262
263#define SIGNAL_ASYNC_EXC() \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000264 do { \
265 pending_async_exc = 1; \
266 _Py_atomic_store_relaxed(&eval_breaker, 1); \
267 } while (0)
Antoine Pitrou074e5ed2009-11-10 19:50:40 +0000268
269#define UNSIGNAL_ASYNC_EXC() \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000270 do { pending_async_exc = 0; COMPUTE_EVAL_BREAKER(); } while (0)
Antoine Pitrou074e5ed2009-11-10 19:50:40 +0000271
272
Guido van Rossume59214e1994-08-30 08:01:59 +0000273#ifdef WITH_THREAD
Guido van Rossumff4949e1992-08-05 19:58:53 +0000274
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000275#ifdef HAVE_ERRNO_H
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000276#include <errno.h>
Guido van Rossum2571cc81999-04-07 16:07:23 +0000277#endif
Guido van Rossum49b56061998-10-01 20:42:43 +0000278#include "pythread.h"
Guido van Rossumff4949e1992-08-05 19:58:53 +0000279
Benjamin Petersone5bf3832009-01-17 23:43:58 +0000280static PyThread_type_lock pending_lock = 0; /* for pending calls */
Guido van Rossuma9672091994-09-14 13:31:22 +0000281static long main_thread = 0;
Antoine Pitrou074e5ed2009-11-10 19:50:40 +0000282/* This single variable consolidates all requests to break out of the fast path
283 in the eval loop. */
Jeffrey Yasskin39370832010-05-03 19:29:34 +0000284static _Py_atomic_int eval_breaker = {0};
285/* Request for dropping the GIL */
286static _Py_atomic_int gil_drop_request = {0};
287/* Request for running pending calls. */
288static _Py_atomic_int pendingcalls_to_do = {0};
289/* Request for looking at the `async_exc` field of the current thread state.
290 Guarded by the GIL. */
291static int pending_async_exc = 0;
Antoine Pitrou074e5ed2009-11-10 19:50:40 +0000292
293#include "ceval_gil.h"
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000294
Tim Peters7f468f22004-10-11 02:40:51 +0000295int
296PyEval_ThreadsInitialized(void)
297{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000298 return gil_created();
Tim Peters7f468f22004-10-11 02:40:51 +0000299}
300
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000301void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000302PyEval_InitThreads(void)
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000303{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000304 if (gil_created())
305 return;
306 create_gil();
307 take_gil(PyThreadState_GET());
308 main_thread = PyThread_get_thread_ident();
309 if (!pending_lock)
310 pending_lock = PyThread_allocate_lock();
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000311}
Guido van Rossumff4949e1992-08-05 19:58:53 +0000312
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000313void
Antoine Pitrou1df15362010-09-13 14:16:46 +0000314_PyEval_FiniThreads(void)
315{
316 if (!gil_created())
317 return;
318 destroy_gil();
319 assert(!gil_created());
320}
321
322void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000323PyEval_AcquireLock(void)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000324{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000325 PyThreadState *tstate = PyThreadState_GET();
326 if (tstate == NULL)
327 Py_FatalError("PyEval_AcquireLock: current thread state is NULL");
328 take_gil(tstate);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000329}
330
331void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000332PyEval_ReleaseLock(void)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000333{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000334 /* This function must succeed when the current thread state is NULL.
335 We therefore avoid PyThreadState_GET() which dumps a fatal error
336 in debug mode.
337 */
338 drop_gil((PyThreadState*)_Py_atomic_load_relaxed(
339 &_PyThreadState_Current));
Guido van Rossum25ce5661997-08-02 03:10:38 +0000340}
341
342void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000343PyEval_AcquireThread(PyThreadState *tstate)
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000344{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000345 if (tstate == NULL)
346 Py_FatalError("PyEval_AcquireThread: NULL new thread state");
347 /* Check someone has called PyEval_InitThreads() to create the lock */
348 assert(gil_created());
349 take_gil(tstate);
350 if (PyThreadState_Swap(tstate) != NULL)
351 Py_FatalError(
352 "PyEval_AcquireThread: non-NULL old thread state");
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000353}
354
355void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000356PyEval_ReleaseThread(PyThreadState *tstate)
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000357{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000358 if (tstate == NULL)
359 Py_FatalError("PyEval_ReleaseThread: NULL thread state");
360 if (PyThreadState_Swap(NULL) != tstate)
361 Py_FatalError("PyEval_ReleaseThread: wrong thread state");
362 drop_gil(tstate);
Guido van Rossum9cc8a201997-07-19 19:55:50 +0000363}
Guido van Rossumfee3a2d2000-08-27 17:34:07 +0000364
Antoine Pitrou8408cea2013-05-05 23:47:09 +0200365/* This function is called from PyOS_AfterFork to destroy all threads which are
366 * not running in the child process, and clear internal locks which might be
367 * held by those threads. (This could also be done using pthread_atfork
368 * mechanism, at least for the pthreads implementation.) */
Guido van Rossumfee3a2d2000-08-27 17:34:07 +0000369
370void
371PyEval_ReInitThreads(void)
372{
Martin v. Löwisbd928fe2011-10-14 10:20:37 +0200373 _Py_IDENTIFIER(_after_fork);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000374 PyObject *threading, *result;
Antoine Pitrou8408cea2013-05-05 23:47:09 +0200375 PyThreadState *current_tstate = PyThreadState_GET();
Jesse Nollera8513972008-07-17 16:49:17 +0000376
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000377 if (!gil_created())
378 return;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000379 recreate_gil();
380 pending_lock = PyThread_allocate_lock();
Antoine Pitrou8408cea2013-05-05 23:47:09 +0200381 take_gil(current_tstate);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000382 main_thread = PyThread_get_thread_ident();
Jesse Nollera8513972008-07-17 16:49:17 +0000383
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000384 /* Update the threading module with the new state.
385 */
Antoine Pitrou8408cea2013-05-05 23:47:09 +0200386 threading = PyMapping_GetItemString(current_tstate->interp->modules,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000387 "threading");
388 if (threading == NULL) {
389 /* threading not imported */
390 PyErr_Clear();
391 return;
392 }
Martin v. Löwisafe55bb2011-10-09 10:38:36 +0200393 result = _PyObject_CallMethodId(threading, &PyId__after_fork, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000394 if (result == NULL)
395 PyErr_WriteUnraisable(threading);
396 else
397 Py_DECREF(result);
398 Py_DECREF(threading);
Antoine Pitrou8408cea2013-05-05 23:47:09 +0200399
400 /* Destroy all threads except the current one */
401 _PyThreadState_DeleteExcept(current_tstate);
Guido van Rossumfee3a2d2000-08-27 17:34:07 +0000402}
Antoine Pitrou074e5ed2009-11-10 19:50:40 +0000403
404#else
Jeffrey Yasskin39370832010-05-03 19:29:34 +0000405static _Py_atomic_int eval_breaker = {0};
Antoine Pitrou074e5ed2009-11-10 19:50:40 +0000406static int pending_async_exc = 0;
407#endif /* WITH_THREAD */
408
409/* This function is used to signal that async exceptions are waiting to be
410 raised, therefore it is also useful in non-threaded builds. */
411
412void
413_PyEval_SignalAsyncExc(void)
414{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000415 SIGNAL_ASYNC_EXC();
Antoine Pitrou074e5ed2009-11-10 19:50:40 +0000416}
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000417
Guido van Rossumff4949e1992-08-05 19:58:53 +0000418/* Functions save_thread and restore_thread are always defined so
419 dynamically loaded modules needn't be compiled separately for use
420 with and without threads: */
421
Guido van Rossum2fca21f71997-07-18 23:56:58 +0000422PyThreadState *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000423PyEval_SaveThread(void)
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000424{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000425 PyThreadState *tstate = PyThreadState_Swap(NULL);
426 if (tstate == NULL)
427 Py_FatalError("PyEval_SaveThread: NULL tstate");
Guido van Rossume59214e1994-08-30 08:01:59 +0000428#ifdef WITH_THREAD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000429 if (gil_created())
430 drop_gil(tstate);
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000431#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000432 return tstate;
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000433}
434
435void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000436PyEval_RestoreThread(PyThreadState *tstate)
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000437{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000438 if (tstate == NULL)
439 Py_FatalError("PyEval_RestoreThread: NULL tstate");
Guido van Rossume59214e1994-08-30 08:01:59 +0000440#ifdef WITH_THREAD
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000441 if (gil_created()) {
442 int err = errno;
443 take_gil(tstate);
Antoine Pitrou0d5e52d2011-05-04 20:02:30 +0200444 /* _Py_Finalizing is protected by the GIL */
445 if (_Py_Finalizing && tstate != _Py_Finalizing) {
446 drop_gil(tstate);
447 PyThread_exit_thread();
448 assert(0); /* unreachable */
449 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000450 errno = err;
451 }
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000452#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000453 PyThreadState_Swap(tstate);
Guido van Rossum1984f1e1992-08-04 12:41:02 +0000454}
455
456
Guido van Rossuma9672091994-09-14 13:31:22 +0000457/* Mechanism whereby asynchronously executing callbacks (e.g. UNIX
458 signal handlers or Mac I/O completion routines) can schedule calls
459 to a function to be called synchronously.
460 The synchronous function is called with one void* argument.
461 It should return 0 for success or -1 for failure -- failure should
462 be accompanied by an exception.
463
464 If registry succeeds, the registry function returns 0; if it fails
465 (e.g. due to too many pending calls) it returns -1 (without setting
466 an exception condition).
467
468 Note that because registry may occur from within signal handlers,
469 or other asynchronous events, calling malloc() is unsafe!
470
471#ifdef WITH_THREAD
472 Any thread can schedule pending calls, but only the main thread
473 will execute them.
Benjamin Petersone5bf3832009-01-17 23:43:58 +0000474 There is no facility to schedule calls to a particular thread, but
475 that should be easy to change, should that ever be required. In
476 that case, the static variables here should go into the python
477 threadstate.
Guido van Rossuma9672091994-09-14 13:31:22 +0000478#endif
Benjamin Petersone5bf3832009-01-17 23:43:58 +0000479*/
Guido van Rossuma9672091994-09-14 13:31:22 +0000480
Benjamin Petersone5bf3832009-01-17 23:43:58 +0000481#ifdef WITH_THREAD
482
483/* The WITH_THREAD implementation is thread-safe. It allows
484 scheduling to be made from any thread, and even from an executing
485 callback.
486 */
487
488#define NPENDINGCALLS 32
489static struct {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000490 int (*func)(void *);
491 void *arg;
Benjamin Petersone5bf3832009-01-17 23:43:58 +0000492} pendingcalls[NPENDINGCALLS];
493static int pendingfirst = 0;
494static int pendinglast = 0;
Benjamin Petersone5bf3832009-01-17 23:43:58 +0000495
496int
497Py_AddPendingCall(int (*func)(void *), void *arg)
498{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000499 int i, j, result=0;
500 PyThread_type_lock lock = pending_lock;
Benjamin Petersone5bf3832009-01-17 23:43:58 +0000501
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000502 /* try a few times for the lock. Since this mechanism is used
503 * for signal handling (on the main thread), there is a (slim)
504 * chance that a signal is delivered on the same thread while we
505 * hold the lock during the Py_MakePendingCalls() function.
506 * This avoids a deadlock in that case.
507 * Note that signals can be delivered on any thread. In particular,
508 * on Windows, a SIGINT is delivered on a system-created worker
509 * thread.
510 * We also check for lock being NULL, in the unlikely case that
511 * this function is called before any bytecode evaluation takes place.
512 */
513 if (lock != NULL) {
514 for (i = 0; i<100; i++) {
515 if (PyThread_acquire_lock(lock, NOWAIT_LOCK))
516 break;
517 }
518 if (i == 100)
519 return -1;
520 }
521
522 i = pendinglast;
523 j = (i + 1) % NPENDINGCALLS;
524 if (j == pendingfirst) {
525 result = -1; /* Queue full */
526 } else {
527 pendingcalls[i].func = func;
528 pendingcalls[i].arg = arg;
529 pendinglast = j;
530 }
531 /* signal main loop */
532 SIGNAL_PENDING_CALLS();
533 if (lock != NULL)
534 PyThread_release_lock(lock);
535 return result;
Benjamin Petersone5bf3832009-01-17 23:43:58 +0000536}
537
538int
539Py_MakePendingCalls(void)
540{
Charles-François Natalif23339a2011-07-23 18:15:43 +0200541 static int busy = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000542 int i;
543 int r = 0;
Benjamin Petersone5bf3832009-01-17 23:43:58 +0000544
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000545 if (!pending_lock) {
546 /* initial allocation of the lock */
547 pending_lock = PyThread_allocate_lock();
548 if (pending_lock == NULL)
549 return -1;
550 }
Benjamin Petersone5bf3832009-01-17 23:43:58 +0000551
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000552 /* only service pending calls on main thread */
553 if (main_thread && PyThread_get_thread_ident() != main_thread)
554 return 0;
555 /* don't perform recursive pending calls */
Charles-François Natalif23339a2011-07-23 18:15:43 +0200556 if (busy)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000557 return 0;
Charles-François Natalif23339a2011-07-23 18:15:43 +0200558 busy = 1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000559 /* perform a bounded number of calls, in case of recursion */
560 for (i=0; i<NPENDINGCALLS; i++) {
561 int j;
562 int (*func)(void *);
563 void *arg = NULL;
564
565 /* pop one item off the queue while holding the lock */
566 PyThread_acquire_lock(pending_lock, WAIT_LOCK);
567 j = pendingfirst;
568 if (j == pendinglast) {
569 func = NULL; /* Queue empty */
570 } else {
571 func = pendingcalls[j].func;
572 arg = pendingcalls[j].arg;
573 pendingfirst = (j + 1) % NPENDINGCALLS;
574 }
575 if (pendingfirst != pendinglast)
576 SIGNAL_PENDING_CALLS();
577 else
578 UNSIGNAL_PENDING_CALLS();
579 PyThread_release_lock(pending_lock);
580 /* having released the lock, perform the callback */
581 if (func == NULL)
582 break;
583 r = func(arg);
584 if (r)
585 break;
586 }
Charles-François Natalif23339a2011-07-23 18:15:43 +0200587 busy = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000588 return r;
Benjamin Petersone5bf3832009-01-17 23:43:58 +0000589}
590
591#else /* if ! defined WITH_THREAD */
592
593/*
594 WARNING! ASYNCHRONOUSLY EXECUTING CODE!
595 This code is used for signal handling in python that isn't built
596 with WITH_THREAD.
597 Don't use this implementation when Py_AddPendingCalls() can happen
598 on a different thread!
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000599
Guido van Rossuma9672091994-09-14 13:31:22 +0000600 There are two possible race conditions:
Benjamin Petersone5bf3832009-01-17 23:43:58 +0000601 (1) nested asynchronous calls to Py_AddPendingCall()
602 (2) AddPendingCall() calls made while pending calls are being processed.
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000603
Benjamin Petersone5bf3832009-01-17 23:43:58 +0000604 (1) is very unlikely because typically signal delivery
605 is blocked during signal handling. So it should be impossible.
606 (2) is a real possibility.
Guido van Rossuma9672091994-09-14 13:31:22 +0000607 The current code is safe against (2), but not against (1).
608 The safety against (2) is derived from the fact that only one
Benjamin Petersone5bf3832009-01-17 23:43:58 +0000609 thread is present, interrupted by signals, and that the critical
610 section is protected with the "busy" variable. On Windows, which
611 delivers SIGINT on a system thread, this does not hold and therefore
612 Windows really shouldn't use this version.
613 The two threads could theoretically wiggle around the "busy" variable.
Guido van Rossuma027efa1997-05-05 20:56:21 +0000614*/
Guido van Rossum8861b741996-07-30 16:49:37 +0000615
Guido van Rossuma9672091994-09-14 13:31:22 +0000616#define NPENDINGCALLS 32
617static struct {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000618 int (*func)(void *);
619 void *arg;
Guido van Rossuma9672091994-09-14 13:31:22 +0000620} pendingcalls[NPENDINGCALLS];
621static volatile int pendingfirst = 0;
622static volatile int pendinglast = 0;
Benjamin Peterson08ec84c2010-05-30 14:49:32 +0000623static _Py_atomic_int pendingcalls_to_do = {0};
Guido van Rossuma9672091994-09-14 13:31:22 +0000624
625int
Thomas Wouters334fb892000-07-25 12:56:38 +0000626Py_AddPendingCall(int (*func)(void *), void *arg)
Guido van Rossuma9672091994-09-14 13:31:22 +0000627{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000628 static volatile int busy = 0;
629 int i, j;
630 /* XXX Begin critical section */
631 if (busy)
632 return -1;
633 busy = 1;
634 i = pendinglast;
635 j = (i + 1) % NPENDINGCALLS;
636 if (j == pendingfirst) {
637 busy = 0;
638 return -1; /* Queue full */
639 }
640 pendingcalls[i].func = func;
641 pendingcalls[i].arg = arg;
642 pendinglast = j;
Skip Montanarod581d772002-09-03 20:10:45 +0000643
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000644 SIGNAL_PENDING_CALLS();
645 busy = 0;
646 /* XXX End critical section */
647 return 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000648}
649
Guido van Rossum180d7b41994-09-29 09:45:57 +0000650int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000651Py_MakePendingCalls(void)
Guido van Rossuma9672091994-09-14 13:31:22 +0000652{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000653 static int busy = 0;
654 if (busy)
655 return 0;
656 busy = 1;
657 UNSIGNAL_PENDING_CALLS();
658 for (;;) {
659 int i;
660 int (*func)(void *);
661 void *arg;
662 i = pendingfirst;
663 if (i == pendinglast)
664 break; /* Queue empty */
665 func = pendingcalls[i].func;
666 arg = pendingcalls[i].arg;
667 pendingfirst = (i + 1) % NPENDINGCALLS;
668 if (func(arg) < 0) {
669 busy = 0;
670 SIGNAL_PENDING_CALLS(); /* We're not done yet */
671 return -1;
672 }
673 }
674 busy = 0;
675 return 0;
Guido van Rossuma9672091994-09-14 13:31:22 +0000676}
677
Benjamin Petersone5bf3832009-01-17 23:43:58 +0000678#endif /* WITH_THREAD */
679
Guido van Rossuma9672091994-09-14 13:31:22 +0000680
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000681/* The interpreter's recursion limit */
682
Hye-Shik Changb6fa2812005-04-04 15:49:02 +0000683#ifndef Py_DEFAULT_RECURSION_LIMIT
684#define Py_DEFAULT_RECURSION_LIMIT 1000
685#endif
686static int recursion_limit = Py_DEFAULT_RECURSION_LIMIT;
687int _Py_CheckRecursionLimit = Py_DEFAULT_RECURSION_LIMIT;
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000688
Vladimir Marangozov7bd25be2000-09-01 11:07:19 +0000689int
690Py_GetRecursionLimit(void)
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000691{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000692 return recursion_limit;
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000693}
694
Vladimir Marangozov7bd25be2000-09-01 11:07:19 +0000695void
696Py_SetRecursionLimit(int new_limit)
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000697{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000698 recursion_limit = new_limit;
699 _Py_CheckRecursionLimit = recursion_limit;
Jeremy Hyltonee5adfb2000-08-31 19:23:01 +0000700}
701
Armin Rigo2b3eb402003-10-28 12:05:48 +0000702/* the macro Py_EnterRecursiveCall() only calls _Py_CheckRecursiveCall()
703 if the recursion_depth reaches _Py_CheckRecursionLimit.
704 If USE_STACKCHECK, the macro decrements _Py_CheckRecursionLimit
705 to guarantee that _Py_CheckRecursiveCall() is regularly called.
706 Without USE_STACKCHECK, there is no need for this. */
707int
708_Py_CheckRecursiveCall(char *where)
709{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000710 PyThreadState *tstate = PyThreadState_GET();
Armin Rigo2b3eb402003-10-28 12:05:48 +0000711
712#ifdef USE_STACKCHECK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000713 if (PyOS_CheckStack()) {
714 --tstate->recursion_depth;
715 PyErr_SetString(PyExc_MemoryError, "Stack overflow");
716 return -1;
717 }
Armin Rigo2b3eb402003-10-28 12:05:48 +0000718#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000719 _Py_CheckRecursionLimit = recursion_limit;
720 if (tstate->recursion_critical)
721 /* Somebody asked that we don't check for recursion. */
722 return 0;
723 if (tstate->overflowed) {
724 if (tstate->recursion_depth > recursion_limit + 50) {
725 /* Overflowing while handling an overflow. Give up. */
726 Py_FatalError("Cannot recover from stack overflow.");
727 }
728 return 0;
729 }
730 if (tstate->recursion_depth > recursion_limit) {
731 --tstate->recursion_depth;
732 tstate->overflowed = 1;
733 PyErr_Format(PyExc_RuntimeError,
734 "maximum recursion depth exceeded%s",
735 where);
736 return -1;
737 }
738 return 0;
Armin Rigo2b3eb402003-10-28 12:05:48 +0000739}
740
Guido van Rossum374a9221991-04-04 10:40:29 +0000741/* Status code for main loop (reason for stack unwind) */
Raymond Hettinger7c958652004-04-06 10:11:10 +0000742enum why_code {
Stefan Krahb7e10102010-06-23 18:42:39 +0000743 WHY_NOT = 0x0001, /* No error */
744 WHY_EXCEPTION = 0x0002, /* Exception occurred */
Stefan Krahb7e10102010-06-23 18:42:39 +0000745 WHY_RETURN = 0x0008, /* 'return' statement */
746 WHY_BREAK = 0x0010, /* 'break' statement */
747 WHY_CONTINUE = 0x0020, /* 'continue' statement */
748 WHY_YIELD = 0x0040, /* 'yield' operator */
749 WHY_SILENCED = 0x0080 /* Exception silenced by 'with' */
Raymond Hettinger7c958652004-04-06 10:11:10 +0000750};
Guido van Rossum374a9221991-04-04 10:40:29 +0000751
Benjamin Peterson87880242011-07-03 16:48:31 -0500752static void save_exc_state(PyThreadState *, PyFrameObject *);
753static void swap_exc_state(PyThreadState *, PyFrameObject *);
754static void restore_and_clear_exc_state(PyThreadState *, PyFrameObject *);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -0400755static int do_raise(PyObject *, PyObject *);
Guido van Rossum0368b722007-05-11 16:50:42 +0000756static int unpack_iterable(PyObject *, int, int, PyObject **);
Guido van Rossum1aa14831997-01-21 05:34:20 +0000757
Jeffrey Yasskin008d8ef2008-12-06 17:09:27 +0000758/* Records whether tracing is on for any thread. Counts the number of
759 threads for which tstate->c_tracefunc is non-NULL, so if the value
760 is 0, we know we don't have to check this thread's c_tracefunc.
761 This speeds up the if statement in PyEval_EvalFrameEx() after
762 fast_next_opcode*/
763static int _Py_TracingPossible = 0;
764
Antoine Pitrou074e5ed2009-11-10 19:50:40 +0000765
Guido van Rossum374a9221991-04-04 10:40:29 +0000766
Guido van Rossumb209a111997-04-29 18:18:01 +0000767PyObject *
Martin v. Löwis4d0d4712010-12-03 20:14:31 +0000768PyEval_EvalCode(PyObject *co, PyObject *globals, PyObject *locals)
Guido van Rossum681d79a1995-07-18 14:51:37 +0000769{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000770 return PyEval_EvalCodeEx(co,
771 globals, locals,
772 (PyObject **)NULL, 0,
773 (PyObject **)NULL, 0,
774 (PyObject **)NULL, 0,
775 NULL, NULL);
Guido van Rossum681d79a1995-07-18 14:51:37 +0000776}
777
778
779/* Interpreter main loop */
780
Martin v. Löwis8d97e332004-06-27 15:43:12 +0000781PyObject *
Phillip J. Eby0d6615f2005-08-02 00:46:46 +0000782PyEval_EvalFrame(PyFrameObject *f) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000783 /* This is for backward compatibility with extension modules that
784 used this API; core interpreter code should call
785 PyEval_EvalFrameEx() */
786 return PyEval_EvalFrameEx(f, 0);
Phillip J. Eby0d6615f2005-08-02 00:46:46 +0000787}
788
789PyObject *
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000790PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
Guido van Rossum374a9221991-04-04 10:40:29 +0000791{
Guido van Rossum950361c1997-01-24 13:49:28 +0000792#ifdef DXPAIRS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000793 int lastopcode = 0;
Guido van Rossum950361c1997-01-24 13:49:28 +0000794#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000795 register PyObject **stack_pointer; /* Next free slot in value stack */
796 register unsigned char *next_instr;
797 register int opcode; /* Current opcode */
798 register int oparg; /* Current opcode argument, if any */
799 register enum why_code why; /* Reason for block stack unwind */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000800 register PyObject **fastlocals, **freevars;
801 PyObject *retval = NULL; /* Return value */
802 PyThreadState *tstate = PyThreadState_GET();
803 PyCodeObject *co;
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000804
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000805 /* when tracing we set things up so that
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000806
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000807 not (instr_lb <= current_bytecode_offset < instr_ub)
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000808
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000809 is true when the line being executed has changed. The
810 initial values are such as to make this false the first
811 time it is tested. */
812 int instr_ub = -1, instr_lb = 0, instr_prev = -1;
Michael W. Hudsondd32a912002-08-15 14:59:02 +0000813
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000814 unsigned char *first_instr;
815 PyObject *names;
816 PyObject *consts;
Guido van Rossum374a9221991-04-04 10:40:29 +0000817
Brett Cannon368b4b72012-04-02 12:17:59 -0400818#ifdef LLTRACE
Victor Stinner3c1e4812012-03-26 22:10:51 +0200819 _Py_IDENTIFIER(__ltrace__);
Brett Cannon368b4b72012-04-02 12:17:59 -0400820#endif
Victor Stinner3c1e4812012-03-26 22:10:51 +0200821
Antoine Pitroub52ec782009-01-25 16:34:23 +0000822/* Computed GOTOs, or
823 the-optimization-commonly-but-improperly-known-as-"threaded code"
824 using gcc's labels-as-values extension
825 (http://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html).
826
827 The traditional bytecode evaluation loop uses a "switch" statement, which
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000828 decent compilers will optimize as a single indirect branch instruction
Antoine Pitroub52ec782009-01-25 16:34:23 +0000829 combined with a lookup table of jump addresses. However, since the
830 indirect jump instruction is shared by all opcodes, the CPU will have a
831 hard time making the right prediction for where to jump next (actually,
832 it will be always wrong except in the uncommon case of a sequence of
833 several identical opcodes).
834
835 "Threaded code" in contrast, uses an explicit jump table and an explicit
836 indirect jump instruction at the end of each opcode. Since the jump
837 instruction is at a different address for each opcode, the CPU will make a
838 separate prediction for each of these instructions, which is equivalent to
839 predicting the second opcode of each opcode pair. These predictions have
840 a much better chance to turn out valid, especially in small bytecode loops.
841
842 A mispredicted branch on a modern CPU flushes the whole pipeline and
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000843 can cost several CPU cycles (depending on the pipeline depth),
Antoine Pitroub52ec782009-01-25 16:34:23 +0000844 and potentially many more instructions (depending on the pipeline width).
845 A correctly predicted branch, however, is nearly free.
846
847 At the time of this writing, the "threaded code" version is up to 15-20%
848 faster than the normal "switch" version, depending on the compiler and the
849 CPU architecture.
850
851 We disable the optimization if DYNAMIC_EXECUTION_PROFILE is defined,
852 because it would render the measurements invalid.
853
854
855 NOTE: care must be taken that the compiler doesn't try to "optimize" the
856 indirect jumps by sharing them between all opcodes. Such optimizations
857 can be disabled on gcc by using the -fno-gcse flag (or possibly
858 -fno-crossjumping).
859*/
860
Antoine Pitrou042b1282010-08-13 21:15:58 +0000861#ifdef DYNAMIC_EXECUTION_PROFILE
Antoine Pitroub52ec782009-01-25 16:34:23 +0000862#undef USE_COMPUTED_GOTOS
Antoine Pitrou042b1282010-08-13 21:15:58 +0000863#define USE_COMPUTED_GOTOS 0
Antoine Pitroub52ec782009-01-25 16:34:23 +0000864#endif
865
Antoine Pitrou042b1282010-08-13 21:15:58 +0000866#ifdef HAVE_COMPUTED_GOTOS
867 #ifndef USE_COMPUTED_GOTOS
868 #define USE_COMPUTED_GOTOS 1
869 #endif
870#else
871 #if defined(USE_COMPUTED_GOTOS) && USE_COMPUTED_GOTOS
872 #error "Computed gotos are not supported on this compiler."
873 #endif
874 #undef USE_COMPUTED_GOTOS
875 #define USE_COMPUTED_GOTOS 0
876#endif
877
878#if USE_COMPUTED_GOTOS
Antoine Pitroub52ec782009-01-25 16:34:23 +0000879/* Import the static jump table */
880#include "opcode_targets.h"
881
882/* This macro is used when several opcodes defer to the same implementation
883 (e.g. SETUP_LOOP, SETUP_FINALLY) */
884#define TARGET_WITH_IMPL(op, impl) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000885 TARGET_##op: \
886 opcode = op; \
887 if (HAS_ARG(op)) \
888 oparg = NEXTARG(); \
889 case op: \
890 goto impl; \
Antoine Pitroub52ec782009-01-25 16:34:23 +0000891
892#define TARGET(op) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000893 TARGET_##op: \
894 opcode = op; \
895 if (HAS_ARG(op)) \
896 oparg = NEXTARG(); \
897 case op:
Antoine Pitroub52ec782009-01-25 16:34:23 +0000898
899
900#define DISPATCH() \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000901 { \
902 if (!_Py_atomic_load_relaxed(&eval_breaker)) { \
903 FAST_DISPATCH(); \
904 } \
905 continue; \
906 }
Antoine Pitroub52ec782009-01-25 16:34:23 +0000907
908#ifdef LLTRACE
909#define FAST_DISPATCH() \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000910 { \
911 if (!lltrace && !_Py_TracingPossible) { \
912 f->f_lasti = INSTR_OFFSET(); \
913 goto *opcode_targets[*next_instr++]; \
914 } \
915 goto fast_next_opcode; \
916 }
Antoine Pitroub52ec782009-01-25 16:34:23 +0000917#else
918#define FAST_DISPATCH() \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000919 { \
920 if (!_Py_TracingPossible) { \
921 f->f_lasti = INSTR_OFFSET(); \
922 goto *opcode_targets[*next_instr++]; \
923 } \
924 goto fast_next_opcode; \
925 }
Antoine Pitroub52ec782009-01-25 16:34:23 +0000926#endif
927
928#else
929#define TARGET(op) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000930 case op:
Antoine Pitroub52ec782009-01-25 16:34:23 +0000931#define TARGET_WITH_IMPL(op, impl) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000932 /* silence compiler warnings about `impl` unused */ \
933 if (0) goto impl; \
934 case op:
Antoine Pitroub52ec782009-01-25 16:34:23 +0000935#define DISPATCH() continue
936#define FAST_DISPATCH() goto fast_next_opcode
937#endif
938
939
Neal Norwitza81d2202002-07-14 00:27:26 +0000940/* Tuple access macros */
941
942#ifndef Py_DEBUG
943#define GETITEM(v, i) PyTuple_GET_ITEM((PyTupleObject *)(v), (i))
944#else
945#define GETITEM(v, i) PyTuple_GetItem((v), (i))
946#endif
947
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000948#ifdef WITH_TSC
949/* Use Pentium timestamp counter to mark certain events:
950 inst0 -- beginning of switch statement for opcode dispatch
951 inst1 -- end of switch statement (may be skipped)
952 loop0 -- the top of the mainloop
Thomas Wouters477c8d52006-05-27 19:21:47 +0000953 loop1 -- place where control returns again to top of mainloop
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000954 (may be skipped)
955 intr1 -- beginning of long interruption
956 intr2 -- end of long interruption
957
958 Many opcodes call out to helper C functions. In some cases, the
959 time in those functions should be counted towards the time for the
960 opcode, but not in all cases. For example, a CALL_FUNCTION opcode
961 calls another Python function; there's no point in charge all the
962 bytecode executed by the called function to the caller.
963
964 It's hard to make a useful judgement statically. In the presence
965 of operator overloading, it's impossible to tell if a call will
966 execute new Python code or not.
967
968 It's a case-by-case judgement. I'll use intr1 for the following
969 cases:
970
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000971 IMPORT_STAR
972 IMPORT_FROM
973 CALL_FUNCTION (and friends)
974
975 */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000976 uint64 inst0, inst1, loop0, loop1, intr0 = 0, intr1 = 0;
977 int ticked = 0;
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000978
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000979 READ_TIMESTAMP(inst0);
980 READ_TIMESTAMP(inst1);
981 READ_TIMESTAMP(loop0);
982 READ_TIMESTAMP(loop1);
Michael W. Hudson800ba232004-08-12 18:19:17 +0000983
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000984 /* shut up the compiler */
985 opcode = 0;
Martin v. Löwisf30d60e2004-06-08 08:17:44 +0000986#endif
987
Guido van Rossum374a9221991-04-04 10:40:29 +0000988/* Code access macros */
989
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000990#define INSTR_OFFSET() ((int)(next_instr - first_instr))
991#define NEXTOP() (*next_instr++)
992#define NEXTARG() (next_instr += 2, (next_instr[-1]<<8) + next_instr[-2])
993#define PEEKARG() ((next_instr[2]<<8) + next_instr[1])
994#define JUMPTO(x) (next_instr = first_instr + (x))
995#define JUMPBY(x) (next_instr += (x))
Guido van Rossum374a9221991-04-04 10:40:29 +0000996
Raymond Hettingerf606f872003-03-16 03:11:04 +0000997/* OpCode prediction macros
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000998 Some opcodes tend to come in pairs thus making it possible to
999 predict the second code when the first is run. For example,
1000 COMPARE_OP is often followed by JUMP_IF_FALSE or JUMP_IF_TRUE. And,
1001 those opcodes are often followed by a POP_TOP.
Raymond Hettingerf606f872003-03-16 03:11:04 +00001002
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001003 Verifying the prediction costs a single high-speed test of a register
1004 variable against a constant. If the pairing was good, then the
1005 processor's own internal branch predication has a high likelihood of
1006 success, resulting in a nearly zero-overhead transition to the
1007 next opcode. A successful prediction saves a trip through the eval-loop
1008 including its two unpredictable branches, the HAS_ARG test and the
1009 switch-case. Combined with the processor's internal branch prediction,
1010 a successful PREDICT has the effect of making the two opcodes run as if
1011 they were a single new opcode with the bodies combined.
Raymond Hettingerf606f872003-03-16 03:11:04 +00001012
Georg Brandl86b2fb92008-07-16 03:43:04 +00001013 If collecting opcode statistics, your choices are to either keep the
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001014 predictions turned-on and interpret the results as if some opcodes
1015 had been combined or turn-off predictions so that the opcode frequency
1016 counter updates for both opcodes.
Antoine Pitroub52ec782009-01-25 16:34:23 +00001017
1018 Opcode prediction is disabled with threaded code, since the latter allows
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001019 the CPU to record separate branch prediction information for each
1020 opcode.
Antoine Pitroub52ec782009-01-25 16:34:23 +00001021
Raymond Hettingerf606f872003-03-16 03:11:04 +00001022*/
1023
Antoine Pitrou042b1282010-08-13 21:15:58 +00001024#if defined(DYNAMIC_EXECUTION_PROFILE) || USE_COMPUTED_GOTOS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001025#define PREDICT(op) if (0) goto PRED_##op
1026#define PREDICTED(op) PRED_##op:
1027#define PREDICTED_WITH_ARG(op) PRED_##op:
Raymond Hettingera7216982004-02-08 19:59:27 +00001028#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001029#define PREDICT(op) if (*next_instr == op) goto PRED_##op
1030#define PREDICTED(op) PRED_##op: next_instr++
1031#define PREDICTED_WITH_ARG(op) PRED_##op: oparg = PEEKARG(); next_instr += 3
Antoine Pitroub52ec782009-01-25 16:34:23 +00001032#endif
1033
Raymond Hettingerf606f872003-03-16 03:11:04 +00001034
Guido van Rossum374a9221991-04-04 10:40:29 +00001035/* Stack manipulation macros */
1036
Martin v. Löwis18e16552006-02-15 17:27:45 +00001037/* The stack can grow at most MAXINT deep, as co_nlocals and
1038 co_stacksize are ints. */
Stefan Krahb7e10102010-06-23 18:42:39 +00001039#define STACK_LEVEL() ((int)(stack_pointer - f->f_valuestack))
1040#define EMPTY() (STACK_LEVEL() == 0)
1041#define TOP() (stack_pointer[-1])
1042#define SECOND() (stack_pointer[-2])
1043#define THIRD() (stack_pointer[-3])
1044#define FOURTH() (stack_pointer[-4])
1045#define PEEK(n) (stack_pointer[-(n)])
1046#define SET_TOP(v) (stack_pointer[-1] = (v))
1047#define SET_SECOND(v) (stack_pointer[-2] = (v))
1048#define SET_THIRD(v) (stack_pointer[-3] = (v))
1049#define SET_FOURTH(v) (stack_pointer[-4] = (v))
1050#define SET_VALUE(n, v) (stack_pointer[-(n)] = (v))
1051#define BASIC_STACKADJ(n) (stack_pointer += n)
1052#define BASIC_PUSH(v) (*stack_pointer++ = (v))
1053#define BASIC_POP() (*--stack_pointer)
Guido van Rossum374a9221991-04-04 10:40:29 +00001054
Guido van Rossum96a42c81992-01-12 02:29:51 +00001055#ifdef LLTRACE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001056#define PUSH(v) { (void)(BASIC_PUSH(v), \
Stefan Krahb7e10102010-06-23 18:42:39 +00001057 lltrace && prtrace(TOP(), "push")); \
1058 assert(STACK_LEVEL() <= co->co_stacksize); }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001059#define POP() ((void)(lltrace && prtrace(TOP(), "pop")), \
Stefan Krahb7e10102010-06-23 18:42:39 +00001060 BASIC_POP())
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001061#define STACKADJ(n) { (void)(BASIC_STACKADJ(n), \
Stefan Krahb7e10102010-06-23 18:42:39 +00001062 lltrace && prtrace(TOP(), "stackadj")); \
1063 assert(STACK_LEVEL() <= co->co_stacksize); }
Christian Heimes0449f632007-12-15 01:27:15 +00001064#define EXT_POP(STACK_POINTER) ((void)(lltrace && \
Stefan Krahb7e10102010-06-23 18:42:39 +00001065 prtrace((STACK_POINTER)[-1], "ext_pop")), \
1066 *--(STACK_POINTER))
Guido van Rossum374a9221991-04-04 10:40:29 +00001067#else
Stefan Krahb7e10102010-06-23 18:42:39 +00001068#define PUSH(v) BASIC_PUSH(v)
1069#define POP() BASIC_POP()
1070#define STACKADJ(n) BASIC_STACKADJ(n)
Guido van Rossumc2e20742006-02-27 22:32:47 +00001071#define EXT_POP(STACK_POINTER) (*--(STACK_POINTER))
Guido van Rossum374a9221991-04-04 10:40:29 +00001072#endif
1073
Guido van Rossum681d79a1995-07-18 14:51:37 +00001074/* Local variable macros */
1075
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001076#define GETLOCAL(i) (fastlocals[i])
Guido van Rossumcfbf1a32002-03-28 20:17:52 +00001077
1078/* The SETLOCAL() macro must not DECREF the local variable in-place and
1079 then store the new value; it must copy the old value to a temporary
1080 value, then store the new value, and then DECREF the temporary value.
1081 This is because it is possible that during the DECREF the frame is
1082 accessed by other code (e.g. a __del__ method or gc.collect()) and the
1083 variable would be pointing to already-freed memory. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001084#define SETLOCAL(i, value) do { PyObject *tmp = GETLOCAL(i); \
Stefan Krahb7e10102010-06-23 18:42:39 +00001085 GETLOCAL(i) = value; \
1086 Py_XDECREF(tmp); } while (0)
Guido van Rossum681d79a1995-07-18 14:51:37 +00001087
Benjamin Petersoneec3d712008-06-11 15:59:43 +00001088
1089#define UNWIND_BLOCK(b) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001090 while (STACK_LEVEL() > (b)->b_level) { \
1091 PyObject *v = POP(); \
1092 Py_XDECREF(v); \
1093 }
Benjamin Petersoneec3d712008-06-11 15:59:43 +00001094
1095#define UNWIND_EXCEPT_HANDLER(b) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001096 { \
1097 PyObject *type, *value, *traceback; \
1098 assert(STACK_LEVEL() >= (b)->b_level + 3); \
1099 while (STACK_LEVEL() > (b)->b_level + 3) { \
1100 value = POP(); \
1101 Py_XDECREF(value); \
1102 } \
1103 type = tstate->exc_type; \
1104 value = tstate->exc_value; \
1105 traceback = tstate->exc_traceback; \
1106 tstate->exc_type = POP(); \
1107 tstate->exc_value = POP(); \
1108 tstate->exc_traceback = POP(); \
1109 Py_XDECREF(type); \
1110 Py_XDECREF(value); \
1111 Py_XDECREF(traceback); \
1112 }
Benjamin Petersoneec3d712008-06-11 15:59:43 +00001113
Guido van Rossuma027efa1997-05-05 20:56:21 +00001114/* Start of code */
1115
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001116 /* push frame */
1117 if (Py_EnterRecursiveCall(""))
1118 return NULL;
Guido van Rossum8861b741996-07-30 16:49:37 +00001119
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001120 tstate->frame = f;
Tim Peters5ca576e2001-06-18 22:08:13 +00001121
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001122 if (tstate->use_tracing) {
1123 if (tstate->c_tracefunc != NULL) {
1124 /* tstate->c_tracefunc, if defined, is a
1125 function that will be called on *every* entry
1126 to a code block. Its return value, if not
1127 None, is a function that will be called at
1128 the start of each executed line of code.
1129 (Actually, the function must return itself
1130 in order to continue tracing.) The trace
1131 functions are called with three arguments:
1132 a pointer to the current frame, a string
1133 indicating why the function is called, and
1134 an argument which depends on the situation.
1135 The global trace function is also called
1136 whenever an exception is detected. */
1137 if (call_trace_protected(tstate->c_tracefunc,
1138 tstate->c_traceobj,
1139 f, PyTrace_CALL, Py_None)) {
1140 /* Trace function raised an error */
1141 goto exit_eval_frame;
1142 }
1143 }
1144 if (tstate->c_profilefunc != NULL) {
1145 /* Similar for c_profilefunc, except it needn't
1146 return itself and isn't called for "line" events */
1147 if (call_trace_protected(tstate->c_profilefunc,
1148 tstate->c_profileobj,
1149 f, PyTrace_CALL, Py_None)) {
1150 /* Profile function raised an error */
1151 goto exit_eval_frame;
1152 }
1153 }
1154 }
Neil Schemenauer6c0f2002001-09-04 19:03:35 +00001155
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001156 co = f->f_code;
1157 names = co->co_names;
1158 consts = co->co_consts;
1159 fastlocals = f->f_localsplus;
1160 freevars = f->f_localsplus + co->co_nlocals;
1161 first_instr = (unsigned char*) PyBytes_AS_STRING(co->co_code);
1162 /* An explanation is in order for the next line.
Michael W. Hudson019a78e2002-11-08 12:53:11 +00001163
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001164 f->f_lasti now refers to the index of the last instruction
1165 executed. You might think this was obvious from the name, but
1166 this wasn't always true before 2.3! PyFrame_New now sets
1167 f->f_lasti to -1 (i.e. the index *before* the first instruction)
1168 and YIELD_VALUE doesn't fiddle with f_lasti any more. So this
1169 does work. Promise.
Benjamin Peterson2afe6ae2012-03-15 15:37:39 -05001170 YIELD_FROM sets f_lasti to itself, in order to repeated yield
1171 multiple values.
Thomas Wouters902d6eb2007-01-09 23:18:33 +00001172
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001173 When the PREDICT() macros are enabled, some opcode pairs follow in
1174 direct succession without updating f->f_lasti. A successful
1175 prediction effectively links the two codes together as if they
1176 were a single new opcode; accordingly,f->f_lasti will point to
1177 the first code in the pair (for instance, GET_ITER followed by
1178 FOR_ITER is effectively a single opcode and f->f_lasti will point
1179 at to the beginning of the combined pair.)
1180 */
1181 next_instr = first_instr + f->f_lasti + 1;
1182 stack_pointer = f->f_stacktop;
1183 assert(stack_pointer != NULL);
1184 f->f_stacktop = NULL; /* remains NULL unless yield suspends frame */
Michael W. Hudson019a78e2002-11-08 12:53:11 +00001185
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001186 if (co->co_flags & CO_GENERATOR && !throwflag) {
1187 if (f->f_exc_type != NULL && f->f_exc_type != Py_None) {
1188 /* We were in an except handler when we left,
1189 restore the exception state which was put aside
1190 (see YIELD_VALUE). */
Benjamin Peterson87880242011-07-03 16:48:31 -05001191 swap_exc_state(tstate, f);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001192 }
Benjamin Peterson87880242011-07-03 16:48:31 -05001193 else
1194 save_exc_state(tstate, f);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001195 }
Benjamin Petersoneec3d712008-06-11 15:59:43 +00001196
Tim Peters5ca576e2001-06-18 22:08:13 +00001197#ifdef LLTRACE
Victor Stinner3c1e4812012-03-26 22:10:51 +02001198 lltrace = _PyDict_GetItemId(f->f_globals, &PyId___ltrace__) != NULL;
Tim Peters5ca576e2001-06-18 22:08:13 +00001199#endif
Guido van Rossumac7be682001-01-17 15:42:30 +00001200
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001201 why = WHY_NOT;
Guido van Rossumac7be682001-01-17 15:42:30 +00001202
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001203 if (throwflag) /* support for generator.throw() */
1204 goto error;
Thomas Wouters477c8d52006-05-27 19:21:47 +00001205
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001206 for (;;) {
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00001207#ifdef WITH_TSC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001208 if (inst1 == 0) {
1209 /* Almost surely, the opcode executed a break
1210 or a continue, preventing inst1 from being set
1211 on the way out of the loop.
1212 */
1213 READ_TIMESTAMP(inst1);
1214 loop1 = inst1;
1215 }
1216 dump_tsc(opcode, ticked, inst0, inst1, loop0, loop1,
1217 intr0, intr1);
1218 ticked = 0;
1219 inst1 = 0;
1220 intr0 = 0;
1221 intr1 = 0;
1222 READ_TIMESTAMP(loop0);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00001223#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001224 assert(stack_pointer >= f->f_valuestack); /* else underflow */
1225 assert(STACK_LEVEL() <= co->co_stacksize); /* else overflow */
Michael W. Hudsondd32a912002-08-15 14:59:02 +00001226
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001227 /* Do periodic things. Doing this every time through
1228 the loop would add too much overhead, so we do it
1229 only every Nth instruction. We also do it if
1230 ``pendingcalls_to_do'' is set, i.e. when an asynchronous
1231 event needs attention (e.g. a signal handler or
1232 async I/O handler); see Py_AddPendingCall() and
1233 Py_MakePendingCalls() above. */
Guido van Rossumac7be682001-01-17 15:42:30 +00001234
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001235 if (_Py_atomic_load_relaxed(&eval_breaker)) {
1236 if (*next_instr == SETUP_FINALLY) {
1237 /* Make the last opcode before
Ezio Melotti13925002011-03-16 11:05:33 +02001238 a try: finally: block uninterruptible. */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001239 goto fast_next_opcode;
1240 }
1241 tstate->tick_counter++;
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00001242#ifdef WITH_TSC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001243 ticked = 1;
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00001244#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001245 if (_Py_atomic_load_relaxed(&pendingcalls_to_do)) {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001246 if (Py_MakePendingCalls() < 0)
1247 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001248 }
Guido van Rossume59214e1994-08-30 08:01:59 +00001249#ifdef WITH_THREAD
Benjamin Petersond2be5b42010-09-10 22:47:02 +00001250 if (_Py_atomic_load_relaxed(&gil_drop_request)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001251 /* Give another thread a chance */
1252 if (PyThreadState_Swap(NULL) != tstate)
1253 Py_FatalError("ceval: tstate mix-up");
1254 drop_gil(tstate);
1255
1256 /* Other threads may run now */
1257
1258 take_gil(tstate);
1259 if (PyThreadState_Swap(tstate) != NULL)
1260 Py_FatalError("ceval: orphan tstate");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001261 }
Benjamin Petersond2be5b42010-09-10 22:47:02 +00001262#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001263 /* Check for asynchronous exceptions. */
1264 if (tstate->async_exc != NULL) {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001265 PyObject *exc = tstate->async_exc;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001266 tstate->async_exc = NULL;
1267 UNSIGNAL_ASYNC_EXC();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001268 PyErr_SetNone(exc);
1269 Py_DECREF(exc);
1270 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001271 }
1272 }
Guido van Rossum1984f1e1992-08-04 12:41:02 +00001273
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001274 fast_next_opcode:
1275 f->f_lasti = INSTR_OFFSET();
Guido van Rossumac7be682001-01-17 15:42:30 +00001276
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001277 /* line-by-line tracing support */
Michael W. Hudson019a78e2002-11-08 12:53:11 +00001278
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001279 if (_Py_TracingPossible &&
Benjamin Peterson51f46162013-01-23 08:38:47 -05001280 tstate->c_tracefunc != NULL && !tstate->tracing) {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001281 int err;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001282 /* see maybe_call_line_trace
1283 for expository comments */
1284 f->f_stacktop = stack_pointer;
Tim Peters8a5c3c72004-04-05 19:36:21 +00001285
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001286 err = maybe_call_line_trace(tstate->c_tracefunc,
1287 tstate->c_traceobj,
1288 f, &instr_lb, &instr_ub,
1289 &instr_prev);
1290 /* Reload possibly changed frame fields */
1291 JUMPTO(f->f_lasti);
1292 if (f->f_stacktop != NULL) {
1293 stack_pointer = f->f_stacktop;
1294 f->f_stacktop = NULL;
1295 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001296 if (err)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001297 /* trace function raised an exception */
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001298 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001299 }
Michael W. Hudson019a78e2002-11-08 12:53:11 +00001300
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001301 /* Extract opcode and argument */
Michael W. Hudson019a78e2002-11-08 12:53:11 +00001302
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001303 opcode = NEXTOP();
1304 oparg = 0; /* allows oparg to be stored in a register because
1305 it doesn't have to be remembered across a full loop */
1306 if (HAS_ARG(opcode))
1307 oparg = NEXTARG();
Stefan Krahb7e10102010-06-23 18:42:39 +00001308 dispatch_opcode:
Guido van Rossum950361c1997-01-24 13:49:28 +00001309#ifdef DYNAMIC_EXECUTION_PROFILE
1310#ifdef DXPAIRS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001311 dxpairs[lastopcode][opcode]++;
1312 lastopcode = opcode;
Guido van Rossum950361c1997-01-24 13:49:28 +00001313#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001314 dxp[opcode]++;
Guido van Rossum950361c1997-01-24 13:49:28 +00001315#endif
Guido van Rossum374a9221991-04-04 10:40:29 +00001316
Guido van Rossum96a42c81992-01-12 02:29:51 +00001317#ifdef LLTRACE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001318 /* Instruction tracing */
Guido van Rossumac7be682001-01-17 15:42:30 +00001319
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001320 if (lltrace) {
1321 if (HAS_ARG(opcode)) {
1322 printf("%d: %d, %d\n",
1323 f->f_lasti, opcode, oparg);
1324 }
1325 else {
1326 printf("%d: %d\n",
1327 f->f_lasti, opcode);
1328 }
1329 }
Guido van Rossum374a9221991-04-04 10:40:29 +00001330#endif
Michael W. Hudsondd32a912002-08-15 14:59:02 +00001331
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001332 /* Main switch on opcode */
1333 READ_TIMESTAMP(inst0);
Jeremy Hylton52820442001-01-03 23:52:36 +00001334
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001335 switch (opcode) {
Guido van Rossumac7be682001-01-17 15:42:30 +00001336
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001337 /* BEWARE!
1338 It is essential that any operation that fails sets either
1339 x to NULL, err to nonzero, or why to anything but WHY_NOT,
1340 and that no operation that succeeds does this! */
Guido van Rossumac7be682001-01-17 15:42:30 +00001341
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001342 TARGET(NOP)
1343 FAST_DISPATCH();
Raymond Hettinger9c18e812004-06-21 16:31:15 +00001344
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001345 TARGET(LOAD_FAST) {
1346 PyObject *value = GETLOCAL(oparg);
1347 if (value == NULL) {
1348 format_exc_check_arg(PyExc_UnboundLocalError,
1349 UNBOUNDLOCAL_ERROR_MSG,
1350 PyTuple_GetItem(co->co_varnames, oparg));
1351 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001352 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001353 Py_INCREF(value);
1354 PUSH(value);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001355 FAST_DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001356 }
1357
1358 TARGET(LOAD_CONST) {
1359 PyObject *value = GETITEM(consts, oparg);
1360 Py_INCREF(value);
1361 PUSH(value);
1362 FAST_DISPATCH();
1363 }
Neil Schemenauer63543862002-02-17 19:10:14 +00001364
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001365 PREDICTED_WITH_ARG(STORE_FAST);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001366 TARGET(STORE_FAST) {
1367 PyObject *value = POP();
1368 SETLOCAL(oparg, value);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001369 FAST_DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001370 }
Neil Schemenauer63543862002-02-17 19:10:14 +00001371
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001372 TARGET(POP_TOP) {
1373 PyObject *value = POP();
1374 Py_DECREF(value);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001375 FAST_DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001376 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001377
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001378 TARGET(ROT_TWO) {
1379 PyObject *top = TOP();
1380 PyObject *second = SECOND();
1381 SET_TOP(second);
1382 SET_SECOND(top);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001383 FAST_DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001384 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001385
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001386 TARGET(ROT_THREE) {
1387 PyObject *top = TOP();
1388 PyObject *second = SECOND();
1389 PyObject *third = THIRD();
1390 SET_TOP(second);
1391 SET_SECOND(third);
1392 SET_THIRD(top);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001393 FAST_DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001394 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001395
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001396 TARGET(DUP_TOP) {
1397 PyObject *top = TOP();
1398 Py_INCREF(top);
1399 PUSH(top);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001400 FAST_DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001401 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001402
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001403 TARGET(DUP_TOP_TWO) {
1404 PyObject *top = TOP();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001405 PyObject *second = SECOND();
Benjamin Petersonf208df32012-10-12 11:37:56 -04001406 Py_INCREF(top);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001407 Py_INCREF(second);
Antoine Pitrou74a69fa2010-09-04 18:43:52 +00001408 STACKADJ(2);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001409 SET_TOP(top);
1410 SET_SECOND(second);
Antoine Pitrou74a69fa2010-09-04 18:43:52 +00001411 FAST_DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001412 }
Thomas Wouters434d0822000-08-24 20:11:32 +00001413
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001414 TARGET(UNARY_POSITIVE) {
1415 PyObject *value = TOP();
1416 PyObject *res = PyNumber_Positive(value);
1417 Py_DECREF(value);
1418 SET_TOP(res);
1419 if (res == NULL)
1420 goto error;
1421 DISPATCH();
1422 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001423
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001424 TARGET(UNARY_NEGATIVE) {
1425 PyObject *value = TOP();
1426 PyObject *res = PyNumber_Negative(value);
1427 Py_DECREF(value);
1428 SET_TOP(res);
1429 if (res == NULL)
1430 goto error;
1431 DISPATCH();
1432 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001433
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001434 TARGET(UNARY_NOT) {
1435 PyObject *value = TOP();
1436 int err = PyObject_IsTrue(value);
1437 Py_DECREF(value);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001438 if (err == 0) {
1439 Py_INCREF(Py_True);
1440 SET_TOP(Py_True);
1441 DISPATCH();
1442 }
1443 else if (err > 0) {
1444 Py_INCREF(Py_False);
1445 SET_TOP(Py_False);
1446 err = 0;
1447 DISPATCH();
1448 }
1449 STACKADJ(-1);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001450 goto error;
1451 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001452
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001453 TARGET(UNARY_INVERT) {
1454 PyObject *value = TOP();
1455 PyObject *res = PyNumber_Invert(value);
1456 Py_DECREF(value);
1457 SET_TOP(res);
1458 if (res == NULL)
1459 goto error;
1460 DISPATCH();
1461 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001462
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001463 TARGET(BINARY_POWER) {
1464 PyObject *exp = POP();
1465 PyObject *base = TOP();
1466 PyObject *res = PyNumber_Power(base, exp, Py_None);
1467 Py_DECREF(base);
1468 Py_DECREF(exp);
1469 SET_TOP(res);
1470 if (res == NULL)
1471 goto error;
1472 DISPATCH();
1473 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001474
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001475 TARGET(BINARY_MULTIPLY) {
1476 PyObject *right = POP();
1477 PyObject *left = TOP();
1478 PyObject *res = PyNumber_Multiply(left, right);
1479 Py_DECREF(left);
1480 Py_DECREF(right);
1481 SET_TOP(res);
1482 if (res == NULL)
1483 goto error;
1484 DISPATCH();
1485 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001486
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001487 TARGET(BINARY_TRUE_DIVIDE) {
1488 PyObject *divisor = POP();
1489 PyObject *dividend = TOP();
1490 PyObject *quotient = PyNumber_TrueDivide(dividend, divisor);
1491 Py_DECREF(dividend);
1492 Py_DECREF(divisor);
1493 SET_TOP(quotient);
1494 if (quotient == NULL)
1495 goto error;
1496 DISPATCH();
1497 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001498
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001499 TARGET(BINARY_FLOOR_DIVIDE) {
1500 PyObject *divisor = POP();
1501 PyObject *dividend = TOP();
1502 PyObject *quotient = PyNumber_FloorDivide(dividend, divisor);
1503 Py_DECREF(dividend);
1504 Py_DECREF(divisor);
1505 SET_TOP(quotient);
1506 if (quotient == NULL)
1507 goto error;
1508 DISPATCH();
1509 }
Guido van Rossum4668b002001-08-08 05:00:18 +00001510
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001511 TARGET(BINARY_MODULO) {
1512 PyObject *divisor = POP();
1513 PyObject *dividend = TOP();
1514 PyObject *res = PyUnicode_CheckExact(dividend) ?
1515 PyUnicode_Format(dividend, divisor) :
1516 PyNumber_Remainder(dividend, divisor);
1517 Py_DECREF(divisor);
1518 Py_DECREF(dividend);
1519 SET_TOP(res);
1520 if (res == NULL)
1521 goto error;
1522 DISPATCH();
1523 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001524
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001525 TARGET(BINARY_ADD) {
1526 PyObject *right = POP();
1527 PyObject *left = TOP();
1528 PyObject *sum;
1529 if (PyUnicode_CheckExact(left) &&
1530 PyUnicode_CheckExact(right)) {
1531 sum = unicode_concatenate(left, right, f, next_instr);
Victor Stinnerd2a915d2011-10-02 20:34:20 +02001532 /* unicode_concatenate consumed the ref to v */
Victor Stinnerd2a915d2011-10-02 20:34:20 +02001533 }
1534 else {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001535 sum = PyNumber_Add(left, right);
1536 Py_DECREF(left);
Victor Stinnerd2a915d2011-10-02 20:34:20 +02001537 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001538 Py_DECREF(right);
1539 SET_TOP(sum);
1540 if (sum == NULL)
1541 goto error;
1542 DISPATCH();
1543 }
1544
1545 TARGET(BINARY_SUBTRACT) {
1546 PyObject *right = POP();
1547 PyObject *left = TOP();
1548 PyObject *diff = PyNumber_Subtract(left, right);
1549 Py_DECREF(right);
1550 Py_DECREF(left);
1551 SET_TOP(diff);
1552 if (diff == NULL)
1553 goto error;
1554 DISPATCH();
1555 }
1556
1557 TARGET(BINARY_SUBSCR) {
1558 PyObject *sub = POP();
1559 PyObject *container = TOP();
1560 PyObject *res = PyObject_GetItem(container, sub);
1561 Py_DECREF(container);
1562 Py_DECREF(sub);
1563 SET_TOP(res);
1564 if (res == NULL)
1565 goto error;
1566 DISPATCH();
1567 }
1568
1569 TARGET(BINARY_LSHIFT) {
1570 PyObject *right = POP();
1571 PyObject *left = TOP();
1572 PyObject *res = PyNumber_Lshift(left, right);
1573 Py_DECREF(left);
1574 Py_DECREF(right);
1575 SET_TOP(res);
1576 if (res == NULL)
1577 goto error;
1578 DISPATCH();
1579 }
1580
1581 TARGET(BINARY_RSHIFT) {
1582 PyObject *right = POP();
1583 PyObject *left = TOP();
1584 PyObject *res = PyNumber_Rshift(left, right);
1585 Py_DECREF(left);
1586 Py_DECREF(right);
1587 SET_TOP(res);
1588 if (res == NULL)
1589 goto error;
1590 DISPATCH();
1591 }
1592
1593 TARGET(BINARY_AND) {
1594 PyObject *right = POP();
1595 PyObject *left = TOP();
1596 PyObject *res = PyNumber_And(left, right);
1597 Py_DECREF(left);
1598 Py_DECREF(right);
1599 SET_TOP(res);
1600 if (res == NULL)
1601 goto error;
1602 DISPATCH();
1603 }
1604
1605 TARGET(BINARY_XOR) {
1606 PyObject *right = POP();
1607 PyObject *left = TOP();
1608 PyObject *res = PyNumber_Xor(left, right);
1609 Py_DECREF(left);
1610 Py_DECREF(right);
1611 SET_TOP(res);
1612 if (res == NULL)
1613 goto error;
1614 DISPATCH();
1615 }
1616
1617 TARGET(BINARY_OR) {
1618 PyObject *right = POP();
1619 PyObject *left = TOP();
1620 PyObject *res = PyNumber_Or(left, right);
1621 Py_DECREF(left);
1622 Py_DECREF(right);
1623 SET_TOP(res);
1624 if (res == NULL)
1625 goto error;
1626 DISPATCH();
1627 }
1628
1629 TARGET(LIST_APPEND) {
1630 PyObject *v = POP();
1631 PyObject *list = PEEK(oparg);
1632 int err;
1633 err = PyList_Append(list, v);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001634 Py_DECREF(v);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001635 if (err != 0)
1636 goto error;
1637 PREDICT(JUMP_ABSOLUTE);
1638 DISPATCH();
1639 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001640
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001641 TARGET(SET_ADD) {
1642 PyObject *v = POP();
1643 PyObject *set = stack_pointer[-oparg];
1644 int err;
1645 err = PySet_Add(set, v);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001646 Py_DECREF(v);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001647 if (err != 0)
1648 goto error;
1649 PREDICT(JUMP_ABSOLUTE);
1650 DISPATCH();
1651 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001652
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001653 TARGET(INPLACE_POWER) {
1654 PyObject *exp = POP();
1655 PyObject *base = TOP();
1656 PyObject *res = PyNumber_InPlacePower(base, exp, Py_None);
1657 Py_DECREF(base);
1658 Py_DECREF(exp);
1659 SET_TOP(res);
1660 if (res == NULL)
1661 goto error;
1662 DISPATCH();
1663 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001664
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001665 TARGET(INPLACE_MULTIPLY) {
1666 PyObject *right = POP();
1667 PyObject *left = TOP();
1668 PyObject *res = PyNumber_InPlaceMultiply(left, right);
1669 Py_DECREF(left);
1670 Py_DECREF(right);
1671 SET_TOP(res);
1672 if (res == NULL)
1673 goto error;
1674 DISPATCH();
1675 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001676
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001677 TARGET(INPLACE_TRUE_DIVIDE) {
1678 PyObject *divisor = POP();
1679 PyObject *dividend = TOP();
1680 PyObject *quotient = PyNumber_InPlaceTrueDivide(dividend, divisor);
1681 Py_DECREF(dividend);
1682 Py_DECREF(divisor);
1683 SET_TOP(quotient);
1684 if (quotient == NULL)
1685 goto error;
1686 DISPATCH();
1687 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001688
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001689 TARGET(INPLACE_FLOOR_DIVIDE) {
1690 PyObject *divisor = POP();
1691 PyObject *dividend = TOP();
1692 PyObject *quotient = PyNumber_InPlaceFloorDivide(dividend, divisor);
1693 Py_DECREF(dividend);
1694 Py_DECREF(divisor);
1695 SET_TOP(quotient);
1696 if (quotient == NULL)
1697 goto error;
1698 DISPATCH();
1699 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001700
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001701 TARGET(INPLACE_MODULO) {
1702 PyObject *right = POP();
1703 PyObject *left = TOP();
1704 PyObject *mod = PyNumber_InPlaceRemainder(left, right);
1705 Py_DECREF(left);
1706 Py_DECREF(right);
1707 SET_TOP(mod);
1708 if (mod == NULL)
1709 goto error;
1710 DISPATCH();
1711 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001712
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001713 TARGET(INPLACE_ADD) {
1714 PyObject *right = POP();
1715 PyObject *left = TOP();
1716 PyObject *sum;
1717 if (PyUnicode_CheckExact(left) && PyUnicode_CheckExact(right)) {
1718 sum = unicode_concatenate(left, right, f, next_instr);
Victor Stinnerd2a915d2011-10-02 20:34:20 +02001719 /* unicode_concatenate consumed the ref to v */
Victor Stinnerd2a915d2011-10-02 20:34:20 +02001720 }
1721 else {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001722 sum = PyNumber_InPlaceAdd(left, right);
1723 Py_DECREF(left);
Victor Stinnerd2a915d2011-10-02 20:34:20 +02001724 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001725 Py_DECREF(right);
1726 SET_TOP(sum);
1727 if (sum == NULL)
1728 goto error;
1729 DISPATCH();
1730 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001731
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001732 TARGET(INPLACE_SUBTRACT) {
1733 PyObject *right = POP();
1734 PyObject *left = TOP();
1735 PyObject *diff = PyNumber_InPlaceSubtract(left, right);
1736 Py_DECREF(left);
1737 Py_DECREF(right);
1738 SET_TOP(diff);
1739 if (diff == NULL)
1740 goto error;
1741 DISPATCH();
1742 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001743
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001744 TARGET(INPLACE_LSHIFT) {
1745 PyObject *right = POP();
1746 PyObject *left = TOP();
1747 PyObject *res = PyNumber_InPlaceLshift(left, right);
1748 Py_DECREF(left);
1749 Py_DECREF(right);
1750 SET_TOP(res);
1751 if (res == NULL)
1752 goto error;
1753 DISPATCH();
1754 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001755
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001756 TARGET(INPLACE_RSHIFT) {
1757 PyObject *right = POP();
1758 PyObject *left = TOP();
1759 PyObject *res = PyNumber_InPlaceRshift(left, right);
1760 Py_DECREF(left);
1761 Py_DECREF(right);
1762 SET_TOP(res);
1763 if (res == NULL)
1764 goto error;
1765 DISPATCH();
1766 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001767
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001768 TARGET(INPLACE_AND) {
1769 PyObject *right = POP();
1770 PyObject *left = TOP();
1771 PyObject *res = PyNumber_InPlaceAnd(left, right);
1772 Py_DECREF(left);
1773 Py_DECREF(right);
1774 SET_TOP(res);
1775 if (res == NULL)
1776 goto error;
1777 DISPATCH();
1778 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001779
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001780 TARGET(INPLACE_XOR) {
1781 PyObject *right = POP();
1782 PyObject *left = TOP();
1783 PyObject *res = PyNumber_InPlaceXor(left, right);
1784 Py_DECREF(left);
1785 Py_DECREF(right);
1786 SET_TOP(res);
1787 if (res == NULL)
1788 goto error;
1789 DISPATCH();
1790 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001791
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001792 TARGET(INPLACE_OR) {
1793 PyObject *right = POP();
1794 PyObject *left = TOP();
1795 PyObject *res = PyNumber_InPlaceOr(left, right);
1796 Py_DECREF(left);
1797 Py_DECREF(right);
1798 SET_TOP(res);
1799 if (res == NULL)
1800 goto error;
1801 DISPATCH();
1802 }
Thomas Wouters434d0822000-08-24 20:11:32 +00001803
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001804 TARGET(STORE_SUBSCR) {
1805 PyObject *sub = TOP();
1806 PyObject *container = SECOND();
1807 PyObject *v = THIRD();
1808 int err;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001809 STACKADJ(-3);
1810 /* v[w] = u */
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001811 err = PyObject_SetItem(container, sub, v);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001812 Py_DECREF(v);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001813 Py_DECREF(container);
1814 Py_DECREF(sub);
1815 if (err != 0)
1816 goto error;
1817 DISPATCH();
1818 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001819
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001820 TARGET(DELETE_SUBSCR) {
1821 PyObject *sub = TOP();
1822 PyObject *container = SECOND();
1823 int err;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001824 STACKADJ(-2);
1825 /* del v[w] */
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001826 err = PyObject_DelItem(container, sub);
1827 Py_DECREF(container);
1828 Py_DECREF(sub);
1829 if (err != 0)
1830 goto error;
1831 DISPATCH();
1832 }
Barry Warsaw23c9ec82000-08-21 15:44:01 +00001833
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001834 TARGET(PRINT_EXPR) {
1835 PyObject *value = POP();
1836 PyObject *hook = PySys_GetObject("displayhook");
Benjamin Petersonfe1bcb62012-10-12 11:40:01 -04001837 PyObject *res;
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001838 if (hook == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001839 PyErr_SetString(PyExc_RuntimeError,
1840 "lost sys.displayhook");
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001841 Py_DECREF(value);
1842 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001843 }
Benjamin Petersonfe1bcb62012-10-12 11:40:01 -04001844 res = PyObject_CallFunctionObjArgs(hook, value, NULL);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001845 Py_DECREF(value);
1846 if (res == NULL)
1847 goto error;
1848 Py_DECREF(res);
1849 DISPATCH();
1850 }
Moshe Zadkaf68f2fe2001-01-11 05:41:27 +00001851
Thomas Wouters434d0822000-08-24 20:11:32 +00001852#ifdef CASE_TOO_BIG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001853 default: switch (opcode) {
Thomas Wouters434d0822000-08-24 20:11:32 +00001854#endif
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001855 TARGET(RAISE_VARARGS) {
1856 PyObject *cause = NULL, *exc = NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001857 switch (oparg) {
1858 case 2:
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001859 cause = POP(); /* cause */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001860 case 1:
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001861 exc = POP(); /* exc */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001862 case 0: /* Fallthrough */
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001863 if (do_raise(exc, cause)) {
1864 why = WHY_EXCEPTION;
1865 goto fast_block_end;
1866 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001867 break;
1868 default:
1869 PyErr_SetString(PyExc_SystemError,
1870 "bad RAISE_VARARGS oparg");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001871 break;
1872 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001873 goto error;
1874 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001875
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001876 TARGET(STORE_LOCALS) {
1877 PyObject *locals = POP();
1878 PyObject *old = f->f_locals;
1879 Py_XDECREF(old);
1880 f->f_locals = locals;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001881 DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001882 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001883
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001884 TARGET(RETURN_VALUE) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001885 retval = POP();
1886 why = WHY_RETURN;
1887 goto fast_block_end;
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001888 }
Guido van Rossumdb3165e1993-10-18 17:06:59 +00001889
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001890 TARGET(YIELD_FROM) {
1891 PyObject *v = POP();
1892 PyObject *reciever = TOP();
1893 int err;
1894 if (PyGen_CheckExact(reciever)) {
1895 retval = _PyGen_Send((PyGenObject *)reciever, v);
Benjamin Peterson2afe6ae2012-03-15 15:37:39 -05001896 } else {
Benjamin Peterson302e7902012-03-20 23:17:04 -04001897 _Py_IDENTIFIER(send);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001898 if (v == Py_None)
1899 retval = Py_TYPE(reciever)->tp_iternext(reciever);
Benjamin Peterson2afe6ae2012-03-15 15:37:39 -05001900 else
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001901 retval = _PyObject_CallMethodId(reciever, &PyId_send, "O", v);
Benjamin Peterson2afe6ae2012-03-15 15:37:39 -05001902 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001903 Py_DECREF(v);
1904 if (retval == NULL) {
Benjamin Peterson2afe6ae2012-03-15 15:37:39 -05001905 PyObject *val;
Nick Coghlanc40bc092012-06-17 15:15:49 +10001906 err = _PyGen_FetchStopIterationValue(&val);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001907 if (err < 0)
1908 goto error;
1909 Py_DECREF(reciever);
1910 SET_TOP(val);
1911 DISPATCH();
Nick Coghlan1f7ce622012-01-13 21:43:40 +10001912 }
Benjamin Peterson2afe6ae2012-03-15 15:37:39 -05001913 /* x remains on stack, retval is value to be yielded */
Nick Coghlan1f7ce622012-01-13 21:43:40 +10001914 f->f_stacktop = stack_pointer;
1915 why = WHY_YIELD;
Benjamin Peterson2afe6ae2012-03-15 15:37:39 -05001916 /* and repeat... */
1917 f->f_lasti--;
Nick Coghlan1f7ce622012-01-13 21:43:40 +10001918 goto fast_yield;
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001919 }
Nick Coghlan1f7ce622012-01-13 21:43:40 +10001920
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001921 TARGET(YIELD_VALUE) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001922 retval = POP();
1923 f->f_stacktop = stack_pointer;
1924 why = WHY_YIELD;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001925 goto fast_yield;
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001926 }
Tim Peters5ca576e2001-06-18 22:08:13 +00001927
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001928 TARGET(POP_EXCEPT) {
1929 PyTryBlock *b = PyFrame_BlockPop(f);
1930 if (b->b_type != EXCEPT_HANDLER) {
1931 PyErr_SetString(PyExc_SystemError,
1932 "popped block is not an except handler");
1933 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001934 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001935 UNWIND_EXCEPT_HANDLER(b);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001936 DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001937 }
Benjamin Petersoneec3d712008-06-11 15:59:43 +00001938
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001939 TARGET(POP_BLOCK) {
1940 PyTryBlock *b = PyFrame_BlockPop(f);
1941 UNWIND_BLOCK(b);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001942 DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001943 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001944
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001945 PREDICTED(END_FINALLY);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001946 TARGET(END_FINALLY) {
1947 PyObject *status = POP();
1948 if (PyLong_Check(status)) {
1949 why = (enum why_code) PyLong_AS_LONG(status);
1950 assert(why != WHY_YIELD && why != WHY_EXCEPTION);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001951 if (why == WHY_RETURN ||
1952 why == WHY_CONTINUE)
1953 retval = POP();
1954 if (why == WHY_SILENCED) {
1955 /* An exception was silenced by 'with', we must
1956 manually unwind the EXCEPT_HANDLER block which was
1957 created when the exception was caught, otherwise
1958 the stack will be in an inconsistent state. */
1959 PyTryBlock *b = PyFrame_BlockPop(f);
1960 assert(b->b_type == EXCEPT_HANDLER);
1961 UNWIND_EXCEPT_HANDLER(b);
1962 why = WHY_NOT;
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001963 Py_DECREF(status);
1964 DISPATCH();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001965 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001966 Py_DECREF(status);
1967 goto fast_block_end;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001968 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001969 else if (PyExceptionClass_Check(status)) {
1970 PyObject *exc = POP();
1971 PyObject *tb = POP();
1972 PyErr_Restore(status, exc, tb);
1973 why = WHY_EXCEPTION;
1974 goto fast_block_end;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001975 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001976 else if (status != Py_None) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001977 PyErr_SetString(PyExc_SystemError,
1978 "'finally' pops bad exception");
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001979 Py_DECREF(status);
1980 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001981 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001982 Py_DECREF(status);
1983 DISPATCH();
1984 }
Guido van Rossumac7be682001-01-17 15:42:30 +00001985
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001986 TARGET(LOAD_BUILD_CLASS) {
Victor Stinner3c1e4812012-03-26 22:10:51 +02001987 _Py_IDENTIFIER(__build_class__);
Victor Stinnerb0b22422012-04-19 00:57:45 +02001988
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001989 PyObject *bc;
Victor Stinnerb0b22422012-04-19 00:57:45 +02001990 if (PyDict_CheckExact(f->f_builtins)) {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001991 bc = _PyDict_GetItemId(f->f_builtins, &PyId___build_class__);
1992 if (bc == NULL) {
Victor Stinnerb0b22422012-04-19 00:57:45 +02001993 PyErr_SetString(PyExc_NameError,
1994 "__build_class__ not found");
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001995 goto error;
Victor Stinnerb0b22422012-04-19 00:57:45 +02001996 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04001997 Py_INCREF(bc);
Victor Stinnerb0b22422012-04-19 00:57:45 +02001998 }
1999 else {
2000 PyObject *build_class_str = _PyUnicode_FromId(&PyId___build_class__);
2001 if (build_class_str == NULL)
2002 break;
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002003 bc = PyObject_GetItem(f->f_builtins, build_class_str);
2004 if (bc == NULL) {
Victor Stinnerb0b22422012-04-19 00:57:45 +02002005 if (PyErr_ExceptionMatches(PyExc_KeyError))
2006 PyErr_SetString(PyExc_NameError,
2007 "__build_class__ not found");
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002008 goto error;
Victor Stinnerb0b22422012-04-19 00:57:45 +02002009 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002010 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002011 PUSH(bc);
Benjamin Peterson00f86f22012-10-10 14:10:33 -04002012 DISPATCH();
Victor Stinner3c1e4812012-03-26 22:10:51 +02002013 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002014
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002015 TARGET(STORE_NAME) {
2016 PyObject *name = GETITEM(names, oparg);
2017 PyObject *v = POP();
2018 PyObject *ns = f->f_locals;
2019 int err;
2020 if (ns == NULL) {
2021 PyErr_Format(PyExc_SystemError,
2022 "no locals found when storing %R", name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002023 Py_DECREF(v);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002024 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002025 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002026 if (PyDict_CheckExact(ns))
2027 err = PyDict_SetItem(ns, name, v);
2028 else
2029 err = PyObject_SetItem(ns, name, v);
2030 Py_DECREF(v);
2031 if (err != 0)
2032 goto error;
2033 DISPATCH();
2034 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002035
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002036 TARGET(DELETE_NAME) {
2037 PyObject *name = GETITEM(names, oparg);
2038 PyObject *ns = f->f_locals;
2039 int err;
2040 if (ns == NULL) {
2041 PyErr_Format(PyExc_SystemError,
2042 "no locals when deleting %R", name);
2043 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002044 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002045 err = PyObject_DelItem(ns, name);
2046 if (err != 0) {
2047 format_exc_check_arg(PyExc_NameError,
2048 NAME_ERROR_MSG,
2049 name);
2050 goto error;
2051 }
2052 DISPATCH();
2053 }
Guido van Rossum04691fc1992-08-12 15:35:34 +00002054
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002055 PREDICTED_WITH_ARG(UNPACK_SEQUENCE);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002056 TARGET(UNPACK_SEQUENCE) {
2057 PyObject *seq = POP(), *item, **items;
2058 if (PyTuple_CheckExact(seq) &&
2059 PyTuple_GET_SIZE(seq) == oparg) {
2060 items = ((PyTupleObject *)seq)->ob_item;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002061 while (oparg--) {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002062 item = items[oparg];
2063 Py_INCREF(item);
2064 PUSH(item);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002065 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002066 } else if (PyList_CheckExact(seq) &&
2067 PyList_GET_SIZE(seq) == oparg) {
2068 items = ((PyListObject *)seq)->ob_item;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002069 while (oparg--) {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002070 item = items[oparg];
2071 Py_INCREF(item);
2072 PUSH(item);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002073 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002074 } else if (unpack_iterable(seq, oparg, -1,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002075 stack_pointer + oparg)) {
2076 STACKADJ(oparg);
2077 } else {
2078 /* unpack_iterable() raised an exception */
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002079 Py_DECREF(seq);
2080 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002081 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002082 Py_DECREF(seq);
Benjamin Peterson00f86f22012-10-10 14:10:33 -04002083 DISPATCH();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002084 }
Guido van Rossum0368b722007-05-11 16:50:42 +00002085
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002086 TARGET(UNPACK_EX) {
2087 int totalargs = 1 + (oparg & 0xFF) + (oparg >> 8);
2088 PyObject *seq = POP();
2089
2090 if (unpack_iterable(seq, oparg & 0xFF, oparg >> 8,
2091 stack_pointer + totalargs)) {
2092 stack_pointer += totalargs;
2093 } else {
2094 Py_DECREF(seq);
2095 goto error;
2096 }
2097 Py_DECREF(seq);
2098 DISPATCH();
2099 }
2100
2101 TARGET(STORE_ATTR) {
2102 PyObject *name = GETITEM(names, oparg);
2103 PyObject *owner = TOP();
2104 PyObject *v = SECOND();
2105 int err;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002106 STACKADJ(-2);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002107 err = PyObject_SetAttr(owner, name, v);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002108 Py_DECREF(v);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002109 Py_DECREF(owner);
2110 if (err != 0)
2111 goto error;
2112 DISPATCH();
2113 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002114
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002115 TARGET(DELETE_ATTR) {
2116 PyObject *name = GETITEM(names, oparg);
2117 PyObject *owner = POP();
2118 int err;
2119 err = PyObject_SetAttr(owner, name, (PyObject *)NULL);
2120 Py_DECREF(owner);
2121 if (err != 0)
2122 goto error;
2123 DISPATCH();
2124 }
2125
2126 TARGET(STORE_GLOBAL) {
2127 PyObject *name = GETITEM(names, oparg);
2128 PyObject *v = POP();
2129 int err;
2130 err = PyDict_SetItem(f->f_globals, name, v);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002131 Py_DECREF(v);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002132 if (err != 0)
2133 goto error;
2134 DISPATCH();
2135 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002136
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002137 TARGET(DELETE_GLOBAL) {
2138 PyObject *name = GETITEM(names, oparg);
2139 int err;
2140 err = PyDict_DelItem(f->f_globals, name);
2141 if (err != 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002142 format_exc_check_arg(
Ezio Melotti04a29552013-03-03 15:12:44 +02002143 PyExc_NameError, NAME_ERROR_MSG, name);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002144 goto error;
Benjamin Peterson00f86f22012-10-10 14:10:33 -04002145 }
2146 DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002147 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002148
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002149 TARGET(LOAD_NAME) {
2150 PyObject *name = GETITEM(names, oparg);
2151 PyObject *locals = f->f_locals;
2152 PyObject *v;
2153 if (locals == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002154 PyErr_Format(PyExc_SystemError,
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002155 "no locals when loading %R", name);
2156 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002157 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002158 if (PyDict_CheckExact(locals)) {
2159 v = PyDict_GetItem(locals, name);
2160 Py_XINCREF(v);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002161 }
2162 else {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002163 v = PyObject_GetItem(locals, name);
2164 if (v == NULL && PyErr_Occurred()) {
Benjamin Peterson92722792012-12-15 12:51:05 -05002165 if (!PyErr_ExceptionMatches(PyExc_KeyError))
2166 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002167 PyErr_Clear();
2168 }
2169 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002170 if (v == NULL) {
2171 v = PyDict_GetItem(f->f_globals, name);
2172 Py_XINCREF(v);
2173 if (v == NULL) {
Victor Stinnerb0b22422012-04-19 00:57:45 +02002174 if (PyDict_CheckExact(f->f_builtins)) {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002175 v = PyDict_GetItem(f->f_builtins, name);
2176 if (v == NULL) {
Victor Stinnerb0b22422012-04-19 00:57:45 +02002177 format_exc_check_arg(
2178 PyExc_NameError,
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002179 NAME_ERROR_MSG, name);
2180 goto error;
Victor Stinnerb0b22422012-04-19 00:57:45 +02002181 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002182 Py_INCREF(v);
Victor Stinnerb0b22422012-04-19 00:57:45 +02002183 }
2184 else {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002185 v = PyObject_GetItem(f->f_builtins, name);
2186 if (v == NULL) {
Victor Stinnerb0b22422012-04-19 00:57:45 +02002187 if (PyErr_ExceptionMatches(PyExc_KeyError))
2188 format_exc_check_arg(
2189 PyExc_NameError,
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002190 NAME_ERROR_MSG, name);
2191 goto error;
Victor Stinnerb0b22422012-04-19 00:57:45 +02002192 }
Benjamin Peterson20f9c3c2010-07-20 22:39:34 +00002193 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002194 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002195 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002196 PUSH(v);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002197 DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002198 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002199
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002200 TARGET(LOAD_GLOBAL) {
2201 PyObject *name = GETITEM(names, oparg);
2202 PyObject *v;
Victor Stinnerb0b22422012-04-19 00:57:45 +02002203 if (PyDict_CheckExact(f->f_globals)
2204 && PyDict_CheckExact(f->f_builtins)) {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002205 v = _PyDict_LoadGlobal((PyDictObject *)f->f_globals,
Benjamin Peterson7d95e402012-04-23 11:24:50 -04002206 (PyDictObject *)f->f_builtins,
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002207 name);
2208 if (v == NULL) {
Benjamin Peterson7d95e402012-04-23 11:24:50 -04002209 if (!PyErr_Occurred())
2210 format_exc_check_arg(PyExc_NameError,
Ezio Melotti04a29552013-03-03 15:12:44 +02002211 NAME_ERROR_MSG, name);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002212 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002213 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002214 Py_INCREF(v);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002215 }
Benjamin Peterson7d95e402012-04-23 11:24:50 -04002216 else {
2217 /* Slow-path if globals or builtins is not a dict */
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002218 v = PyObject_GetItem(f->f_globals, name);
2219 if (v == NULL) {
2220 v = PyObject_GetItem(f->f_builtins, name);
2221 if (v == NULL) {
Benjamin Peterson7d95e402012-04-23 11:24:50 -04002222 if (PyErr_ExceptionMatches(PyExc_KeyError))
2223 format_exc_check_arg(
2224 PyExc_NameError,
Ezio Melotti04a29552013-03-03 15:12:44 +02002225 NAME_ERROR_MSG, name);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002226 goto error;
Benjamin Peterson7d95e402012-04-23 11:24:50 -04002227 }
2228 }
2229 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002230 PUSH(v);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002231 DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002232 }
Guido van Rossum681d79a1995-07-18 14:51:37 +00002233
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002234 TARGET(DELETE_FAST) {
2235 PyObject *v = GETLOCAL(oparg);
2236 if (v != NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002237 SETLOCAL(oparg, NULL);
2238 DISPATCH();
2239 }
2240 format_exc_check_arg(
2241 PyExc_UnboundLocalError,
2242 UNBOUNDLOCAL_ERROR_MSG,
2243 PyTuple_GetItem(co->co_varnames, oparg)
2244 );
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002245 goto error;
2246 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002247
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002248 TARGET(DELETE_DEREF) {
2249 PyObject *cell = freevars[oparg];
2250 if (PyCell_GET(cell) != NULL) {
2251 PyCell_Set(cell, NULL);
Benjamin Peterson00ebe2c2010-09-10 22:02:31 +00002252 DISPATCH();
Amaury Forgeot d'Arcba117ef2010-09-10 21:39:53 +00002253 }
Amaury Forgeot d'Arcba117ef2010-09-10 21:39:53 +00002254 format_exc_unbound(co, oparg);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002255 goto error;
2256 }
Amaury Forgeot d'Arcba117ef2010-09-10 21:39:53 +00002257
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002258 TARGET(LOAD_CLOSURE) {
2259 PyObject *cell = freevars[oparg];
2260 Py_INCREF(cell);
2261 PUSH(cell);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002262 DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002263 }
Jeremy Hylton64949cb2001-01-25 20:06:59 +00002264
Benjamin Peterson3b0431d2013-04-30 09:41:40 -04002265 TARGET(LOAD_CLASSDEREF) {
2266 PyObject *name, *value, *locals = f->f_locals;
2267 int idx;
2268 assert(locals);
2269 assert(oparg >= PyTuple_GET_SIZE(co->co_cellvars));
2270 idx = oparg - PyTuple_GET_SIZE(co->co_cellvars);
2271 assert(idx >= 0 && idx < PyTuple_GET_SIZE(co->co_freevars));
2272 name = PyTuple_GET_ITEM(co->co_freevars, idx);
2273 if (PyDict_CheckExact(locals)) {
2274 value = PyDict_GetItem(locals, name);
2275 Py_XINCREF(value);
2276 }
2277 else {
2278 value = PyObject_GetItem(locals, name);
2279 if (value == NULL && PyErr_Occurred()) {
2280 if (!PyErr_ExceptionMatches(PyExc_KeyError))
2281 goto error;
2282 PyErr_Clear();
2283 }
2284 }
2285 if (!value) {
2286 PyObject *cell = freevars[oparg];
2287 value = PyCell_GET(cell);
2288 if (value == NULL) {
2289 format_exc_unbound(co, oparg);
2290 goto error;
2291 }
2292 Py_INCREF(value);
2293 }
2294 PUSH(value);
2295 DISPATCH();
2296 }
2297
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002298 TARGET(LOAD_DEREF) {
2299 PyObject *cell = freevars[oparg];
2300 PyObject *value = PyCell_GET(cell);
2301 if (value == NULL) {
2302 format_exc_unbound(co, oparg);
2303 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002304 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002305 Py_INCREF(value);
2306 PUSH(value);
2307 DISPATCH();
2308 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002309
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002310 TARGET(STORE_DEREF) {
2311 PyObject *v = POP();
2312 PyObject *cell = freevars[oparg];
2313 PyCell_Set(cell, v);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002314 Py_DECREF(v);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002315 DISPATCH();
2316 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002317
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002318 TARGET(BUILD_TUPLE) {
2319 PyObject *tup = PyTuple_New(oparg);
2320 if (tup == NULL)
2321 goto error;
2322 while (--oparg >= 0) {
2323 PyObject *item = POP();
2324 PyTuple_SET_ITEM(tup, oparg, item);
2325 }
2326 PUSH(tup);
2327 DISPATCH();
2328 }
2329
2330 TARGET(BUILD_LIST) {
2331 PyObject *list = PyList_New(oparg);
2332 if (list == NULL)
2333 goto error;
2334 while (--oparg >= 0) {
2335 PyObject *item = POP();
2336 PyList_SET_ITEM(list, oparg, item);
2337 }
2338 PUSH(list);
2339 DISPATCH();
2340 }
2341
2342 TARGET(BUILD_SET) {
2343 PyObject *set = PySet_New(NULL);
2344 int err = 0;
2345 if (set == NULL)
2346 goto error;
2347 while (--oparg >= 0) {
2348 PyObject *item = POP();
2349 if (err == 0)
2350 err = PySet_Add(set, item);
2351 Py_DECREF(item);
2352 }
2353 if (err != 0) {
2354 Py_DECREF(set);
2355 goto error;
2356 }
2357 PUSH(set);
2358 DISPATCH();
2359 }
2360
2361 TARGET(BUILD_MAP) {
2362 PyObject *map = _PyDict_NewPresized((Py_ssize_t)oparg);
2363 if (map == NULL)
2364 goto error;
2365 PUSH(map);
2366 DISPATCH();
2367 }
2368
2369 TARGET(STORE_MAP) {
2370 PyObject *key = TOP();
2371 PyObject *value = SECOND();
2372 PyObject *map = THIRD();
2373 int err;
2374 STACKADJ(-2);
2375 assert(PyDict_CheckExact(map));
2376 err = PyDict_SetItem(map, key, value);
2377 Py_DECREF(value);
2378 Py_DECREF(key);
2379 if (err != 0)
2380 goto error;
2381 DISPATCH();
2382 }
2383
2384 TARGET(MAP_ADD) {
2385 PyObject *key = TOP();
2386 PyObject *value = SECOND();
2387 PyObject *map;
2388 int err;
2389 STACKADJ(-2);
2390 map = stack_pointer[-oparg]; /* dict */
2391 assert(PyDict_CheckExact(map));
2392 err = PyDict_SetItem(map, key, value); /* v[w] = u */
2393 Py_DECREF(value);
2394 Py_DECREF(key);
2395 if (err != 0)
2396 goto error;
2397 PREDICT(JUMP_ABSOLUTE);
2398 DISPATCH();
2399 }
2400
2401 TARGET(LOAD_ATTR) {
2402 PyObject *name = GETITEM(names, oparg);
2403 PyObject *owner = TOP();
2404 PyObject *res = PyObject_GetAttr(owner, name);
2405 Py_DECREF(owner);
2406 SET_TOP(res);
2407 if (res == NULL)
2408 goto error;
2409 DISPATCH();
2410 }
2411
2412 TARGET(COMPARE_OP) {
2413 PyObject *right = POP();
2414 PyObject *left = TOP();
2415 PyObject *res = cmp_outcome(oparg, left, right);
2416 Py_DECREF(left);
2417 Py_DECREF(right);
2418 SET_TOP(res);
2419 if (res == NULL)
2420 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002421 PREDICT(POP_JUMP_IF_FALSE);
2422 PREDICT(POP_JUMP_IF_TRUE);
2423 DISPATCH();
Victor Stinner3c1e4812012-03-26 22:10:51 +02002424 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002425
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002426 TARGET(IMPORT_NAME) {
2427 _Py_IDENTIFIER(__import__);
2428 PyObject *name = GETITEM(names, oparg);
2429 PyObject *func = _PyDict_GetItemId(f->f_builtins, &PyId___import__);
Benjamin Petersonfe1bcb62012-10-12 11:40:01 -04002430 PyObject *from, *level, *args, *res;
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002431 if (func == NULL) {
2432 PyErr_SetString(PyExc_ImportError,
2433 "__import__ not found");
2434 goto error;
2435 }
2436 Py_INCREF(func);
2437 from = POP();
2438 level = TOP();
2439 if (PyLong_AsLong(level) != -1 || PyErr_Occurred())
2440 args = PyTuple_Pack(5,
2441 name,
2442 f->f_globals,
2443 f->f_locals == NULL ?
2444 Py_None : f->f_locals,
2445 from,
2446 level);
2447 else
2448 args = PyTuple_Pack(4,
2449 name,
2450 f->f_globals,
2451 f->f_locals == NULL ?
2452 Py_None : f->f_locals,
2453 from);
2454 Py_DECREF(level);
2455 Py_DECREF(from);
2456 if (args == NULL) {
2457 Py_DECREF(func);
2458 STACKADJ(-1);
2459 goto error;
2460 }
2461 READ_TIMESTAMP(intr0);
Benjamin Petersonfe1bcb62012-10-12 11:40:01 -04002462 res = PyEval_CallObject(func, args);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002463 READ_TIMESTAMP(intr1);
2464 Py_DECREF(args);
2465 Py_DECREF(func);
2466 SET_TOP(res);
2467 if (res == NULL)
2468 goto error;
2469 DISPATCH();
2470 }
2471
2472 TARGET(IMPORT_STAR) {
2473 PyObject *from = POP(), *locals;
2474 int err;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002475 PyFrame_FastToLocals(f);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002476 locals = f->f_locals;
2477 if (locals == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002478 PyErr_SetString(PyExc_SystemError,
2479 "no locals found during 'import *'");
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002480 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002481 }
2482 READ_TIMESTAMP(intr0);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002483 err = import_all_from(locals, from);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002484 READ_TIMESTAMP(intr1);
2485 PyFrame_LocalsToFast(f, 0);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002486 Py_DECREF(from);
2487 if (err != 0)
2488 goto error;
2489 DISPATCH();
2490 }
Guido van Rossum25831651993-05-19 14:50:45 +00002491
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002492 TARGET(IMPORT_FROM) {
2493 PyObject *name = GETITEM(names, oparg);
2494 PyObject *from = TOP();
2495 PyObject *res;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002496 READ_TIMESTAMP(intr0);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002497 res = import_from(from, name);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002498 READ_TIMESTAMP(intr1);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002499 PUSH(res);
2500 if (res == NULL)
2501 goto error;
2502 DISPATCH();
2503 }
Thomas Wouters52152252000-08-17 22:55:00 +00002504
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002505 TARGET(JUMP_FORWARD) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002506 JUMPBY(oparg);
2507 FAST_DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002508 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002509
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002510 PREDICTED_WITH_ARG(POP_JUMP_IF_FALSE);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002511 TARGET(POP_JUMP_IF_FALSE) {
2512 PyObject *cond = POP();
2513 int err;
2514 if (cond == Py_True) {
2515 Py_DECREF(cond);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002516 FAST_DISPATCH();
2517 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002518 if (cond == Py_False) {
2519 Py_DECREF(cond);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002520 JUMPTO(oparg);
2521 FAST_DISPATCH();
2522 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002523 err = PyObject_IsTrue(cond);
2524 Py_DECREF(cond);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002525 if (err > 0)
2526 err = 0;
2527 else if (err == 0)
2528 JUMPTO(oparg);
2529 else
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002530 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002531 DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002532 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002533
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002534 PREDICTED_WITH_ARG(POP_JUMP_IF_TRUE);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002535 TARGET(POP_JUMP_IF_TRUE) {
2536 PyObject *cond = POP();
2537 int err;
2538 if (cond == Py_False) {
2539 Py_DECREF(cond);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002540 FAST_DISPATCH();
2541 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002542 if (cond == Py_True) {
2543 Py_DECREF(cond);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002544 JUMPTO(oparg);
2545 FAST_DISPATCH();
2546 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002547 err = PyObject_IsTrue(cond);
2548 Py_DECREF(cond);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002549 if (err > 0) {
2550 err = 0;
2551 JUMPTO(oparg);
2552 }
2553 else if (err == 0)
2554 ;
2555 else
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002556 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002557 DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002558 }
Jeffrey Yasskin9de7ec72009-02-25 02:25:04 +00002559
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002560 TARGET(JUMP_IF_FALSE_OR_POP) {
2561 PyObject *cond = TOP();
2562 int err;
2563 if (cond == Py_True) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002564 STACKADJ(-1);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002565 Py_DECREF(cond);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002566 FAST_DISPATCH();
2567 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002568 if (cond == Py_False) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002569 JUMPTO(oparg);
2570 FAST_DISPATCH();
2571 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002572 err = PyObject_IsTrue(cond);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002573 if (err > 0) {
2574 STACKADJ(-1);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002575 Py_DECREF(cond);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002576 err = 0;
2577 }
2578 else if (err == 0)
2579 JUMPTO(oparg);
2580 else
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002581 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002582 DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002583 }
Jeffrey Yasskin9de7ec72009-02-25 02:25:04 +00002584
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002585 TARGET(JUMP_IF_TRUE_OR_POP) {
2586 PyObject *cond = TOP();
2587 int err;
2588 if (cond == Py_False) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002589 STACKADJ(-1);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002590 Py_DECREF(cond);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002591 FAST_DISPATCH();
2592 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002593 if (cond == Py_True) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002594 JUMPTO(oparg);
2595 FAST_DISPATCH();
2596 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002597 err = PyObject_IsTrue(cond);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002598 if (err > 0) {
2599 err = 0;
2600 JUMPTO(oparg);
2601 }
2602 else if (err == 0) {
2603 STACKADJ(-1);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002604 Py_DECREF(cond);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002605 }
2606 else
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002607 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002608 DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002609 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002610
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002611 PREDICTED_WITH_ARG(JUMP_ABSOLUTE);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002612 TARGET(JUMP_ABSOLUTE) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002613 JUMPTO(oparg);
Guido van Rossum58da9312007-11-10 23:39:45 +00002614#if FAST_LOOPS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002615 /* Enabling this path speeds-up all while and for-loops by bypassing
2616 the per-loop checks for signals. By default, this should be turned-off
2617 because it prevents detection of a control-break in tight loops like
2618 "while 1: pass". Compile with this option turned-on when you need
2619 the speed-up and do not need break checking inside tight loops (ones
2620 that contain only instructions ending with FAST_DISPATCH).
2621 */
2622 FAST_DISPATCH();
Guido van Rossum58da9312007-11-10 23:39:45 +00002623#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002624 DISPATCH();
Guido van Rossum58da9312007-11-10 23:39:45 +00002625#endif
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002626 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002627
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002628 TARGET(GET_ITER) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002629 /* before: [obj]; after [getiter(obj)] */
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002630 PyObject *iterable = TOP();
2631 PyObject *iter = PyObject_GetIter(iterable);
2632 Py_DECREF(iterable);
2633 SET_TOP(iter);
2634 if (iter == NULL)
2635 goto error;
2636 PREDICT(FOR_ITER);
2637 DISPATCH();
2638 }
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002639
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002640 PREDICTED_WITH_ARG(FOR_ITER);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002641 TARGET(FOR_ITER) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002642 /* before: [iter]; after: [iter, iter()] *or* [] */
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002643 PyObject *iter = TOP();
2644 PyObject *next = (*iter->ob_type->tp_iternext)(iter);
2645 if (next != NULL) {
2646 PUSH(next);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002647 PREDICT(STORE_FAST);
2648 PREDICT(UNPACK_SEQUENCE);
2649 DISPATCH();
2650 }
2651 if (PyErr_Occurred()) {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002652 if (!PyErr_ExceptionMatches(PyExc_StopIteration))
2653 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002654 PyErr_Clear();
2655 }
2656 /* iterator ended normally */
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002657 STACKADJ(-1);
2658 Py_DECREF(iter);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002659 JUMPBY(oparg);
2660 DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002661 }
Guido van Rossum59d1d2b2001-04-20 19:13:02 +00002662
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002663 TARGET(BREAK_LOOP) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002664 why = WHY_BREAK;
2665 goto fast_block_end;
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002666 }
Raymond Hettinger2d783e92004-03-12 09:12:22 +00002667
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002668 TARGET(CONTINUE_LOOP) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002669 retval = PyLong_FromLong(oparg);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002670 if (retval == NULL)
2671 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002672 why = WHY_CONTINUE;
2673 goto fast_block_end;
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002674 }
Raymond Hettinger2d783e92004-03-12 09:12:22 +00002675
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002676 TARGET_WITH_IMPL(SETUP_LOOP, _setup_finally)
2677 TARGET_WITH_IMPL(SETUP_EXCEPT, _setup_finally)
2678 TARGET(SETUP_FINALLY)
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002679 _setup_finally: {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002680 /* NOTE: If you add any new block-setup opcodes that
2681 are not try/except/finally handlers, you may need
2682 to update the PyGen_NeedsFinalizing() function.
2683 */
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00002684
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002685 PyFrame_BlockSetup(f, opcode, INSTR_OFFSET() + oparg,
2686 STACK_LEVEL());
2687 DISPATCH();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002688 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002689
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002690 TARGET(SETUP_WITH) {
Benjamin Petersonce798522012-01-22 11:24:29 -05002691 _Py_IDENTIFIER(__exit__);
2692 _Py_IDENTIFIER(__enter__);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002693 PyObject *mgr = TOP();
2694 PyObject *exit = special_lookup(mgr, &PyId___exit__), *enter;
2695 PyObject *res;
2696 if (exit == NULL)
2697 goto error;
2698 SET_TOP(exit);
2699 enter = special_lookup(mgr, &PyId___enter__);
2700 Py_DECREF(mgr);
2701 if (enter == NULL)
2702 goto error;
2703 res = PyObject_CallFunctionObjArgs(enter, NULL);
2704 Py_DECREF(enter);
2705 if (res == NULL)
2706 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002707 /* Setup the finally block before pushing the result
2708 of __enter__ on the stack. */
2709 PyFrame_BlockSetup(f, SETUP_FINALLY, INSTR_OFFSET() + oparg,
2710 STACK_LEVEL());
Benjamin Peterson876b2f22009-06-28 03:18:59 +00002711
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002712 PUSH(res);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002713 DISPATCH();
2714 }
Benjamin Peterson876b2f22009-06-28 03:18:59 +00002715
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002716 TARGET(WITH_CLEANUP) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002717 /* At the top of the stack are 1-3 values indicating
2718 how/why we entered the finally clause:
2719 - TOP = None
2720 - (TOP, SECOND) = (WHY_{RETURN,CONTINUE}), retval
2721 - TOP = WHY_*; no retval below it
2722 - (TOP, SECOND, THIRD) = exc_info()
2723 (FOURTH, FITH, SIXTH) = previous exception for EXCEPT_HANDLER
2724 Below them is EXIT, the context.__exit__ bound method.
2725 In the last case, we must call
2726 EXIT(TOP, SECOND, THIRD)
2727 otherwise we must call
2728 EXIT(None, None, None)
Christian Heimesdd15f6c2008-03-16 00:07:10 +00002729
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002730 In the first two cases, we remove EXIT from the
2731 stack, leaving the rest in the same order. In the
2732 third case, we shift the bottom 3 values of the
2733 stack down, and replace the empty spot with NULL.
Guido van Rossum1a5e21e2006-02-28 21:57:43 +00002734
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002735 In addition, if the stack represents an exception,
2736 *and* the function call returns a 'true' value, we
2737 push WHY_SILENCED onto the stack. END_FINALLY will
2738 then not re-raise the exception. (But non-local
2739 gotos should still be resumed.)
2740 */
Thomas Wouters477c8d52006-05-27 19:21:47 +00002741
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002742 PyObject *exit_func;
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002743 PyObject *exc = TOP(), *val = Py_None, *tb = Py_None, *res;
2744 int err;
2745 if (exc == Py_None) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002746 (void)POP();
2747 exit_func = TOP();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002748 SET_TOP(exc);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002749 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002750 else if (PyLong_Check(exc)) {
2751 STACKADJ(-1);
2752 switch (PyLong_AsLong(exc)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002753 case WHY_RETURN:
2754 case WHY_CONTINUE:
2755 /* Retval in TOP. */
2756 exit_func = SECOND();
2757 SET_SECOND(TOP());
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002758 SET_TOP(exc);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002759 break;
2760 default:
2761 exit_func = TOP();
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002762 SET_TOP(exc);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002763 break;
2764 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002765 exc = Py_None;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002766 }
2767 else {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002768 PyObject *tp2, *exc2, *tb2;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002769 PyTryBlock *block;
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002770 val = SECOND();
2771 tb = THIRD();
2772 tp2 = FOURTH();
2773 exc2 = PEEK(5);
2774 tb2 = PEEK(6);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002775 exit_func = PEEK(7);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002776 SET_VALUE(7, tb2);
2777 SET_VALUE(6, exc2);
2778 SET_VALUE(5, tp2);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002779 /* UNWIND_EXCEPT_HANDLER will pop this off. */
2780 SET_FOURTH(NULL);
2781 /* We just shifted the stack down, so we have
2782 to tell the except handler block that the
2783 values are lower than it expects. */
2784 block = &f->f_blockstack[f->f_iblock - 1];
2785 assert(block->b_type == EXCEPT_HANDLER);
2786 block->b_level--;
2787 }
2788 /* XXX Not the fastest way to call it... */
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002789 res = PyObject_CallFunctionObjArgs(exit_func, exc, val, tb, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002790 Py_DECREF(exit_func);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002791 if (res == NULL)
2792 goto error;
Amaury Forgeot d'Arc10b24e82008-12-10 23:49:33 +00002793
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002794 if (exc != Py_None)
2795 err = PyObject_IsTrue(res);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002796 else
2797 err = 0;
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002798 Py_DECREF(res);
Amaury Forgeot d'Arc10b24e82008-12-10 23:49:33 +00002799
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002800 if (err < 0)
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002801 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002802 else if (err > 0) {
2803 err = 0;
2804 /* There was an exception and a True return */
2805 PUSH(PyLong_FromLong((long) WHY_SILENCED));
2806 }
2807 PREDICT(END_FINALLY);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002808 DISPATCH();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002809 }
Guido van Rossumc2e20742006-02-27 22:32:47 +00002810
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002811 TARGET(CALL_FUNCTION) {
2812 PyObject **sp, *res;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002813 PCALL(PCALL_ALL);
2814 sp = stack_pointer;
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00002815#ifdef WITH_TSC
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002816 res = call_function(&sp, oparg, &intr0, &intr1);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00002817#else
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002818 res = call_function(&sp, oparg);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00002819#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002820 stack_pointer = sp;
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002821 PUSH(res);
2822 if (res == NULL)
2823 goto error;
2824 DISPATCH();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002825 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002826
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002827 TARGET_WITH_IMPL(CALL_FUNCTION_VAR, _call_function_var_kw)
2828 TARGET_WITH_IMPL(CALL_FUNCTION_KW, _call_function_var_kw)
2829 TARGET(CALL_FUNCTION_VAR_KW)
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002830 _call_function_var_kw: {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002831 int na = oparg & 0xff;
2832 int nk = (oparg>>8) & 0xff;
2833 int flags = (opcode - CALL_FUNCTION) & 3;
2834 int n = na + 2 * nk;
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002835 PyObject **pfunc, *func, **sp, *res;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002836 PCALL(PCALL_ALL);
2837 if (flags & CALL_FLAG_VAR)
2838 n++;
2839 if (flags & CALL_FLAG_KW)
2840 n++;
2841 pfunc = stack_pointer - n - 1;
2842 func = *pfunc;
Jeremy Hylton52820442001-01-03 23:52:36 +00002843
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002844 if (PyMethod_Check(func)
Stefan Krahb7e10102010-06-23 18:42:39 +00002845 && PyMethod_GET_SELF(func) != NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002846 PyObject *self = PyMethod_GET_SELF(func);
2847 Py_INCREF(self);
2848 func = PyMethod_GET_FUNCTION(func);
2849 Py_INCREF(func);
2850 Py_DECREF(*pfunc);
2851 *pfunc = self;
2852 na++;
Brett Cannonb94767f2011-02-22 20:15:44 +00002853 /* n++; */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002854 } else
2855 Py_INCREF(func);
2856 sp = stack_pointer;
2857 READ_TIMESTAMP(intr0);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002858 res = ext_do_call(func, &sp, flags, na, nk);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002859 READ_TIMESTAMP(intr1);
2860 stack_pointer = sp;
2861 Py_DECREF(func);
Jeremy Hylton52820442001-01-03 23:52:36 +00002862
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002863 while (stack_pointer > pfunc) {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002864 PyObject *o = POP();
2865 Py_DECREF(o);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002866 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002867 PUSH(res);
2868 if (res == NULL)
2869 goto error;
2870 DISPATCH();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002871 }
Guido van Rossumac7be682001-01-17 15:42:30 +00002872
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002873 TARGET_WITH_IMPL(MAKE_CLOSURE, _make_function)
2874 TARGET(MAKE_FUNCTION)
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002875 _make_function: {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002876 int posdefaults = oparg & 0xff;
2877 int kwdefaults = (oparg>>8) & 0xff;
2878 int num_annotations = (oparg >> 16) & 0x7fff;
Guido van Rossum4f72a782006-10-27 23:31:49 +00002879
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002880 PyObject *qualname = POP(); /* qualname */
2881 PyObject *code = POP(); /* code object */
2882 PyObject *func = PyFunction_NewWithQualName(code, f->f_globals, qualname);
2883 Py_DECREF(code);
2884 Py_DECREF(qualname);
Antoine Pitrou9a2310d2008-07-25 22:39:39 +00002885
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002886 if (func == NULL)
2887 goto error;
2888
2889 if (opcode == MAKE_CLOSURE) {
2890 PyObject *closure = POP();
2891 if (PyFunction_SetClosure(func, closure) != 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002892 /* Can't happen unless bytecode is corrupt. */
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002893 Py_DECREF(func);
2894 Py_DECREF(closure);
2895 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002896 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002897 Py_DECREF(closure);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002898 }
Neal Norwitzc1505362006-12-28 06:47:50 +00002899
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002900 if (num_annotations > 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002901 Py_ssize_t name_ix;
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002902 PyObject *names = POP(); /* names of args with annotations */
2903 PyObject *anns = PyDict_New();
2904 if (anns == NULL) {
2905 Py_DECREF(func);
2906 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002907 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002908 name_ix = PyTuple_Size(names);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002909 assert(num_annotations == name_ix+1);
2910 while (name_ix > 0) {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002911 PyObject *name, *value;
2912 int err;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002913 --name_ix;
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002914 name = PyTuple_GET_ITEM(names, name_ix);
2915 value = POP();
2916 err = PyDict_SetItem(anns, name, value);
2917 Py_DECREF(value);
2918 if (err != 0) {
2919 Py_DECREF(anns);
2920 Py_DECREF(func);
2921 goto error;
2922 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002923 }
Neal Norwitzc1505362006-12-28 06:47:50 +00002924
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002925 if (PyFunction_SetAnnotations(func, anns) != 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002926 /* Can't happen unless
2927 PyFunction_SetAnnotations changes. */
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002928 Py_DECREF(anns);
2929 Py_DECREF(func);
2930 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002931 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002932 Py_DECREF(anns);
2933 Py_DECREF(names);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002934 }
Neal Norwitzc1505362006-12-28 06:47:50 +00002935
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002936 /* XXX Maybe this should be a separate opcode? */
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002937 if (kwdefaults > 0) {
2938 PyObject *defs = PyDict_New();
2939 if (defs == NULL) {
2940 Py_DECREF(func);
2941 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002942 }
2943 while (--kwdefaults >= 0) {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002944 PyObject *v = POP(); /* default value */
2945 PyObject *key = POP(); /* kw only arg name */
2946 int err = PyDict_SetItem(defs, key, v);
2947 Py_DECREF(v);
2948 Py_DECREF(key);
2949 if (err != 0) {
2950 Py_DECREF(defs);
2951 Py_DECREF(func);
2952 goto error;
2953 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002954 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002955 if (PyFunction_SetKwDefaults(func, defs) != 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002956 /* Can't happen unless
2957 PyFunction_SetKwDefaults changes. */
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002958 Py_DECREF(func);
2959 Py_DECREF(defs);
2960 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002961 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002962 Py_DECREF(defs);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002963 }
Benjamin Peterson1ef876c2013-02-10 09:29:59 -05002964 if (posdefaults > 0) {
2965 PyObject *defs = PyTuple_New(posdefaults);
2966 if (defs == NULL) {
2967 Py_DECREF(func);
2968 goto error;
2969 }
2970 while (--posdefaults >= 0)
2971 PyTuple_SET_ITEM(defs, posdefaults, POP());
2972 if (PyFunction_SetDefaults(func, defs) != 0) {
2973 /* Can't happen unless
2974 PyFunction_SetDefaults changes. */
2975 Py_DECREF(defs);
2976 Py_DECREF(func);
2977 goto error;
2978 }
2979 Py_DECREF(defs);
2980 }
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002981 PUSH(func);
2982 DISPATCH();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002983 }
Guido van Rossum8861b741996-07-30 16:49:37 +00002984
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002985 TARGET(BUILD_SLICE) {
2986 PyObject *start, *stop, *step, *slice;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002987 if (oparg == 3)
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002988 step = POP();
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002989 else
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04002990 step = NULL;
2991 stop = POP();
2992 start = TOP();
2993 slice = PySlice_New(start, stop, step);
2994 Py_DECREF(start);
2995 Py_DECREF(stop);
2996 Py_XDECREF(step);
2997 SET_TOP(slice);
2998 if (slice == NULL)
2999 goto error;
3000 DISPATCH();
3001 }
Guido van Rossum8861b741996-07-30 16:49:37 +00003002
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04003003 TARGET(EXTENDED_ARG) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003004 opcode = NEXTOP();
3005 oparg = oparg<<16 | NEXTARG();
3006 goto dispatch_opcode;
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04003007 }
Guido van Rossum8861b741996-07-30 16:49:37 +00003008
Antoine Pitrou042b1282010-08-13 21:15:58 +00003009#if USE_COMPUTED_GOTOS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003010 _unknown_opcode:
Antoine Pitroub52ec782009-01-25 16:34:23 +00003011#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003012 default:
3013 fprintf(stderr,
3014 "XXX lineno: %d, opcode: %d\n",
3015 PyFrame_GetLineNumber(f),
3016 opcode);
3017 PyErr_SetString(PyExc_SystemError, "unknown opcode");
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04003018 goto error;
Guido van Rossum04691fc1992-08-12 15:35:34 +00003019
3020#ifdef CASE_TOO_BIG
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003021 }
Guido van Rossum04691fc1992-08-12 15:35:34 +00003022#endif
3023
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003024 } /* switch */
Guido van Rossum374a9221991-04-04 10:40:29 +00003025
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04003026 /* This should never be reached. Every opcode should end with DISPATCH()
3027 or goto error. */
3028 assert(0);
Guido van Rossumac7be682001-01-17 15:42:30 +00003029
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04003030error:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003031 READ_TIMESTAMP(inst1);
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00003032
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04003033 assert(why == WHY_NOT);
3034 why = WHY_EXCEPTION;
Guido van Rossumac7be682001-01-17 15:42:30 +00003035
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04003036 /* Double-check exception status. */
3037 if (!PyErr_Occurred())
3038 PyErr_SetString(PyExc_SystemError,
3039 "error return without exception set");
Guido van Rossum374a9221991-04-04 10:40:29 +00003040
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04003041 /* Log traceback info. */
3042 PyTraceBack_Here(f);
Guido van Rossumac7be682001-01-17 15:42:30 +00003043
Benjamin Peterson51f46162013-01-23 08:38:47 -05003044 if (tstate->c_tracefunc != NULL)
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04003045 call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj, f);
Guido van Rossumac7be682001-01-17 15:42:30 +00003046
Raymond Hettinger1dd83092004-02-06 18:32:33 +00003047fast_block_end:
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04003048 assert(why != WHY_NOT);
3049
3050 /* Unwind stacks if a (pseudo) exception occurred */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003051 while (why != WHY_NOT && f->f_iblock > 0) {
3052 /* Peek at the current block. */
3053 PyTryBlock *b = &f->f_blockstack[f->f_iblock - 1];
Jeremy Hylton3faa52e2001-02-01 22:48:12 +00003054
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003055 assert(why != WHY_YIELD);
3056 if (b->b_type == SETUP_LOOP && why == WHY_CONTINUE) {
3057 why = WHY_NOT;
3058 JUMPTO(PyLong_AS_LONG(retval));
3059 Py_DECREF(retval);
3060 break;
3061 }
3062 /* Now we have to pop the block. */
3063 f->f_iblock--;
Jeremy Hylton3faa52e2001-02-01 22:48:12 +00003064
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003065 if (b->b_type == EXCEPT_HANDLER) {
3066 UNWIND_EXCEPT_HANDLER(b);
3067 continue;
3068 }
3069 UNWIND_BLOCK(b);
3070 if (b->b_type == SETUP_LOOP && why == WHY_BREAK) {
3071 why = WHY_NOT;
3072 JUMPTO(b->b_handler);
3073 break;
3074 }
3075 if (why == WHY_EXCEPTION && (b->b_type == SETUP_EXCEPT
3076 || b->b_type == SETUP_FINALLY)) {
3077 PyObject *exc, *val, *tb;
3078 int handler = b->b_handler;
3079 /* Beware, this invalidates all b->b_* fields */
3080 PyFrame_BlockSetup(f, EXCEPT_HANDLER, -1, STACK_LEVEL());
3081 PUSH(tstate->exc_traceback);
3082 PUSH(tstate->exc_value);
3083 if (tstate->exc_type != NULL) {
3084 PUSH(tstate->exc_type);
3085 }
3086 else {
3087 Py_INCREF(Py_None);
3088 PUSH(Py_None);
3089 }
3090 PyErr_Fetch(&exc, &val, &tb);
3091 /* Make the raw exception data
3092 available to the handler,
3093 so a program can emulate the
3094 Python main loop. */
3095 PyErr_NormalizeException(
3096 &exc, &val, &tb);
3097 PyException_SetTraceback(val, tb);
3098 Py_INCREF(exc);
3099 tstate->exc_type = exc;
3100 Py_INCREF(val);
3101 tstate->exc_value = val;
3102 tstate->exc_traceback = tb;
3103 if (tb == NULL)
3104 tb = Py_None;
3105 Py_INCREF(tb);
3106 PUSH(tb);
3107 PUSH(val);
3108 PUSH(exc);
3109 why = WHY_NOT;
3110 JUMPTO(handler);
3111 break;
3112 }
3113 if (b->b_type == SETUP_FINALLY) {
3114 if (why & (WHY_RETURN | WHY_CONTINUE))
3115 PUSH(retval);
3116 PUSH(PyLong_FromLong((long)why));
3117 why = WHY_NOT;
3118 JUMPTO(b->b_handler);
3119 break;
3120 }
3121 } /* unwind stack */
Guido van Rossum374a9221991-04-04 10:40:29 +00003122
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003123 /* End the loop if we still have an error (or return) */
Guido van Rossumac7be682001-01-17 15:42:30 +00003124
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003125 if (why != WHY_NOT)
3126 break;
3127 READ_TIMESTAMP(loop1);
Guido van Rossumac7be682001-01-17 15:42:30 +00003128
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003129 } /* main loop */
Guido van Rossumac7be682001-01-17 15:42:30 +00003130
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003131 assert(why != WHY_YIELD);
3132 /* Pop remaining stack entries. */
3133 while (!EMPTY()) {
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04003134 PyObject *o = POP();
3135 Py_XDECREF(o);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003136 }
Guido van Rossum35974fb2001-12-06 21:28:18 +00003137
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003138 if (why != WHY_RETURN)
3139 retval = NULL;
Guido van Rossumac7be682001-01-17 15:42:30 +00003140
Raymond Hettinger1dd83092004-02-06 18:32:33 +00003141fast_yield:
Benjamin Petersonac913412011-07-03 16:25:11 -05003142 if (co->co_flags & CO_GENERATOR && (why == WHY_YIELD || why == WHY_RETURN)) {
3143 /* The purpose of this block is to put aside the generator's exception
3144 state and restore that of the calling frame. If the current
3145 exception state is from the caller, we clear the exception values
3146 on the generator frame, so they are not swapped back in latter. The
3147 origin of the current exception state is determined by checking for
3148 except handler blocks, which we must be in iff a new exception
3149 state came into existence in this frame. (An uncaught exception
3150 would have why == WHY_EXCEPTION, and we wouldn't be here). */
3151 int i;
3152 for (i = 0; i < f->f_iblock; i++)
3153 if (f->f_blockstack[i].b_type == EXCEPT_HANDLER)
3154 break;
3155 if (i == f->f_iblock)
3156 /* We did not create this exception. */
Benjamin Peterson87880242011-07-03 16:48:31 -05003157 restore_and_clear_exc_state(tstate, f);
Benjamin Petersonac913412011-07-03 16:25:11 -05003158 else
Benjamin Peterson87880242011-07-03 16:48:31 -05003159 swap_exc_state(tstate, f);
Benjamin Petersonac913412011-07-03 16:25:11 -05003160 }
Benjamin Peterson83195c32011-07-03 13:44:00 -05003161
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003162 if (tstate->use_tracing) {
Benjamin Peterson51f46162013-01-23 08:38:47 -05003163 if (tstate->c_tracefunc) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003164 if (why == WHY_RETURN || why == WHY_YIELD) {
3165 if (call_trace(tstate->c_tracefunc,
3166 tstate->c_traceobj, f,
3167 PyTrace_RETURN, retval)) {
3168 Py_XDECREF(retval);
3169 retval = NULL;
3170 why = WHY_EXCEPTION;
3171 }
3172 }
3173 else if (why == WHY_EXCEPTION) {
3174 call_trace_protected(tstate->c_tracefunc,
3175 tstate->c_traceobj, f,
3176 PyTrace_RETURN, NULL);
3177 }
3178 }
3179 if (tstate->c_profilefunc) {
3180 if (why == WHY_EXCEPTION)
3181 call_trace_protected(tstate->c_profilefunc,
3182 tstate->c_profileobj, f,
3183 PyTrace_RETURN, NULL);
3184 else if (call_trace(tstate->c_profilefunc,
3185 tstate->c_profileobj, f,
3186 PyTrace_RETURN, retval)) {
3187 Py_XDECREF(retval);
3188 retval = NULL;
Brett Cannonb94767f2011-02-22 20:15:44 +00003189 /* why = WHY_EXCEPTION; */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003190 }
3191 }
3192 }
Guido van Rossuma4240131997-01-21 21:18:36 +00003193
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003194 /* pop frame */
Thomas Woutersce272b62007-09-19 21:19:28 +00003195exit_eval_frame:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003196 Py_LeaveRecursiveCall();
3197 tstate->frame = f->f_back;
Guido van Rossumac7be682001-01-17 15:42:30 +00003198
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003199 return retval;
Guido van Rossum374a9221991-04-04 10:40:29 +00003200}
3201
Benjamin Petersonb204a422011-06-05 22:04:07 -05003202static void
Benjamin Petersone109c702011-06-24 09:37:26 -05003203format_missing(const char *kind, PyCodeObject *co, PyObject *names)
3204{
3205 int err;
3206 Py_ssize_t len = PyList_GET_SIZE(names);
3207 PyObject *name_str, *comma, *tail, *tmp;
3208
3209 assert(PyList_CheckExact(names));
3210 assert(len >= 1);
3211 /* Deal with the joys of natural language. */
3212 switch (len) {
3213 case 1:
3214 name_str = PyList_GET_ITEM(names, 0);
3215 Py_INCREF(name_str);
3216 break;
3217 case 2:
3218 name_str = PyUnicode_FromFormat("%U and %U",
3219 PyList_GET_ITEM(names, len - 2),
3220 PyList_GET_ITEM(names, len - 1));
3221 break;
3222 default:
3223 tail = PyUnicode_FromFormat(", %U, and %U",
3224 PyList_GET_ITEM(names, len - 2),
3225 PyList_GET_ITEM(names, len - 1));
Benjamin Petersond1ab6082012-06-01 11:18:22 -07003226 if (tail == NULL)
3227 return;
Benjamin Petersone109c702011-06-24 09:37:26 -05003228 /* Chop off the last two objects in the list. This shouldn't actually
3229 fail, but we can't be too careful. */
3230 err = PyList_SetSlice(names, len - 2, len, NULL);
3231 if (err == -1) {
3232 Py_DECREF(tail);
3233 return;
3234 }
3235 /* Stitch everything up into a nice comma-separated list. */
3236 comma = PyUnicode_FromString(", ");
3237 if (comma == NULL) {
3238 Py_DECREF(tail);
3239 return;
3240 }
3241 tmp = PyUnicode_Join(comma, names);
3242 Py_DECREF(comma);
3243 if (tmp == NULL) {
3244 Py_DECREF(tail);
3245 return;
3246 }
3247 name_str = PyUnicode_Concat(tmp, tail);
3248 Py_DECREF(tmp);
3249 Py_DECREF(tail);
3250 break;
3251 }
3252 if (name_str == NULL)
3253 return;
3254 PyErr_Format(PyExc_TypeError,
3255 "%U() missing %i required %s argument%s: %U",
3256 co->co_name,
3257 len,
3258 kind,
3259 len == 1 ? "" : "s",
3260 name_str);
3261 Py_DECREF(name_str);
3262}
3263
3264static void
3265missing_arguments(PyCodeObject *co, int missing, int defcount,
3266 PyObject **fastlocals)
3267{
3268 int i, j = 0;
3269 int start, end;
3270 int positional = defcount != -1;
3271 const char *kind = positional ? "positional" : "keyword-only";
3272 PyObject *missing_names;
3273
3274 /* Compute the names of the arguments that are missing. */
3275 missing_names = PyList_New(missing);
3276 if (missing_names == NULL)
3277 return;
3278 if (positional) {
3279 start = 0;
3280 end = co->co_argcount - defcount;
3281 }
3282 else {
3283 start = co->co_argcount;
3284 end = start + co->co_kwonlyargcount;
3285 }
3286 for (i = start; i < end; i++) {
3287 if (GETLOCAL(i) == NULL) {
3288 PyObject *raw = PyTuple_GET_ITEM(co->co_varnames, i);
3289 PyObject *name = PyObject_Repr(raw);
3290 if (name == NULL) {
3291 Py_DECREF(missing_names);
3292 return;
3293 }
3294 PyList_SET_ITEM(missing_names, j++, name);
3295 }
3296 }
3297 assert(j == missing);
3298 format_missing(kind, co, missing_names);
3299 Py_DECREF(missing_names);
3300}
3301
3302static void
3303too_many_positional(PyCodeObject *co, int given, int defcount, PyObject **fastlocals)
Benjamin Petersonb204a422011-06-05 22:04:07 -05003304{
3305 int plural;
3306 int kwonly_given = 0;
Benjamin Petersonb204a422011-06-05 22:04:07 -05003307 int i;
3308 PyObject *sig, *kwonly_sig;
3309
Benjamin Petersone109c702011-06-24 09:37:26 -05003310 assert((co->co_flags & CO_VARARGS) == 0);
3311 /* Count missing keyword-only args. */
Benjamin Petersonb204a422011-06-05 22:04:07 -05003312 for (i = co->co_argcount; i < co->co_argcount + co->co_kwonlyargcount; i++)
Benjamin Petersone109c702011-06-24 09:37:26 -05003313 if (GETLOCAL(i) != NULL)
Benjamin Petersonb204a422011-06-05 22:04:07 -05003314 kwonly_given++;
Benjamin Petersone109c702011-06-24 09:37:26 -05003315 if (defcount) {
3316 int atleast = co->co_argcount - defcount;
Benjamin Petersonb204a422011-06-05 22:04:07 -05003317 plural = 1;
3318 sig = PyUnicode_FromFormat("from %d to %d", atleast, co->co_argcount);
3319 }
3320 else {
3321 plural = co->co_argcount != 1;
3322 sig = PyUnicode_FromFormat("%d", co->co_argcount);
3323 }
3324 if (sig == NULL)
3325 return;
3326 if (kwonly_given) {
3327 const char *format = " positional argument%s (and %d keyword-only argument%s)";
3328 kwonly_sig = PyUnicode_FromFormat(format, given != 1 ? "s" : "", kwonly_given,
3329 kwonly_given != 1 ? "s" : "");
3330 if (kwonly_sig == NULL) {
3331 Py_DECREF(sig);
3332 return;
3333 }
3334 }
3335 else {
3336 /* This will not fail. */
3337 kwonly_sig = PyUnicode_FromString("");
Benjamin Petersone109c702011-06-24 09:37:26 -05003338 assert(kwonly_sig != NULL);
Benjamin Petersonb204a422011-06-05 22:04:07 -05003339 }
3340 PyErr_Format(PyExc_TypeError,
3341 "%U() takes %U positional argument%s but %d%U %s given",
3342 co->co_name,
3343 sig,
3344 plural ? "s" : "",
3345 given,
3346 kwonly_sig,
3347 given == 1 && !kwonly_given ? "was" : "were");
3348 Py_DECREF(sig);
3349 Py_DECREF(kwonly_sig);
3350}
3351
Guido van Rossumc2e20742006-02-27 22:32:47 +00003352/* This is gonna seem *real weird*, but if you put some other code between
Martin v. Löwis8d97e332004-06-27 15:43:12 +00003353 PyEval_EvalFrame() and PyEval_EvalCodeEx() you will need to adjust
Guido van Rossumc2e20742006-02-27 22:32:47 +00003354 the test in the if statements in Misc/gdbinit (pystack and pystackv). */
Skip Montanaro786ea6b2004-03-01 15:44:05 +00003355
Tim Peters6d6c1a32001-08-02 04:15:00 +00003356PyObject *
Martin v. Löwis4d0d4712010-12-03 20:14:31 +00003357PyEval_EvalCodeEx(PyObject *_co, PyObject *globals, PyObject *locals,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003358 PyObject **args, int argcount, PyObject **kws, int kwcount,
3359 PyObject **defs, int defcount, PyObject *kwdefs, PyObject *closure)
Tim Peters5ca576e2001-06-18 22:08:13 +00003360{
Martin v. Löwis4d0d4712010-12-03 20:14:31 +00003361 PyCodeObject* co = (PyCodeObject*)_co;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003362 register PyFrameObject *f;
3363 register PyObject *retval = NULL;
3364 register PyObject **fastlocals, **freevars;
3365 PyThreadState *tstate = PyThreadState_GET();
3366 PyObject *x, *u;
3367 int total_args = co->co_argcount + co->co_kwonlyargcount;
Benjamin Petersonb204a422011-06-05 22:04:07 -05003368 int i;
3369 int n = argcount;
3370 PyObject *kwdict = NULL;
Tim Peters5ca576e2001-06-18 22:08:13 +00003371
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003372 if (globals == NULL) {
3373 PyErr_SetString(PyExc_SystemError,
3374 "PyEval_EvalCodeEx: NULL globals");
3375 return NULL;
3376 }
Tim Peters5ca576e2001-06-18 22:08:13 +00003377
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003378 assert(tstate != NULL);
3379 assert(globals != NULL);
3380 f = PyFrame_New(tstate, co, globals, locals);
3381 if (f == NULL)
3382 return NULL;
Tim Peters5ca576e2001-06-18 22:08:13 +00003383
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003384 fastlocals = f->f_localsplus;
3385 freevars = f->f_localsplus + co->co_nlocals;
Tim Peters5ca576e2001-06-18 22:08:13 +00003386
Benjamin Petersonb204a422011-06-05 22:04:07 -05003387 /* Parse arguments. */
3388 if (co->co_flags & CO_VARKEYWORDS) {
3389 kwdict = PyDict_New();
3390 if (kwdict == NULL)
3391 goto fail;
3392 i = total_args;
3393 if (co->co_flags & CO_VARARGS)
3394 i++;
3395 SETLOCAL(i, kwdict);
3396 }
3397 if (argcount > co->co_argcount)
3398 n = co->co_argcount;
3399 for (i = 0; i < n; i++) {
3400 x = args[i];
3401 Py_INCREF(x);
3402 SETLOCAL(i, x);
3403 }
3404 if (co->co_flags & CO_VARARGS) {
3405 u = PyTuple_New(argcount - n);
3406 if (u == NULL)
3407 goto fail;
3408 SETLOCAL(total_args, u);
3409 for (i = n; i < argcount; i++) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003410 x = args[i];
3411 Py_INCREF(x);
Benjamin Petersonb204a422011-06-05 22:04:07 -05003412 PyTuple_SET_ITEM(u, i-n, x);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003413 }
Benjamin Petersonb204a422011-06-05 22:04:07 -05003414 }
3415 for (i = 0; i < kwcount; i++) {
3416 PyObject **co_varnames;
3417 PyObject *keyword = kws[2*i];
3418 PyObject *value = kws[2*i + 1];
3419 int j;
3420 if (keyword == NULL || !PyUnicode_Check(keyword)) {
3421 PyErr_Format(PyExc_TypeError,
3422 "%U() keywords must be strings",
3423 co->co_name);
3424 goto fail;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003425 }
Benjamin Petersonb204a422011-06-05 22:04:07 -05003426 /* Speed hack: do raw pointer compares. As names are
3427 normally interned this should almost always hit. */
3428 co_varnames = ((PyTupleObject *)(co->co_varnames))->ob_item;
3429 for (j = 0; j < total_args; j++) {
3430 PyObject *nm = co_varnames[j];
3431 if (nm == keyword)
3432 goto kw_found;
3433 }
3434 /* Slow fallback, just in case */
3435 for (j = 0; j < total_args; j++) {
3436 PyObject *nm = co_varnames[j];
3437 int cmp = PyObject_RichCompareBool(
3438 keyword, nm, Py_EQ);
3439 if (cmp > 0)
3440 goto kw_found;
3441 else if (cmp < 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003442 goto fail;
Benjamin Petersonb204a422011-06-05 22:04:07 -05003443 }
3444 if (j >= total_args && kwdict == NULL) {
3445 PyErr_Format(PyExc_TypeError,
3446 "%U() got an unexpected "
3447 "keyword argument '%S'",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003448 co->co_name,
3449 keyword);
Benjamin Petersonb204a422011-06-05 22:04:07 -05003450 goto fail;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003451 }
Benjamin Petersonb204a422011-06-05 22:04:07 -05003452 PyDict_SetItem(kwdict, keyword, value);
3453 continue;
3454 kw_found:
3455 if (GETLOCAL(j) != NULL) {
3456 PyErr_Format(PyExc_TypeError,
3457 "%U() got multiple "
3458 "values for argument '%S'",
3459 co->co_name,
3460 keyword);
3461 goto fail;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003462 }
Benjamin Petersonb204a422011-06-05 22:04:07 -05003463 Py_INCREF(value);
3464 SETLOCAL(j, value);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003465 }
Benjamin Petersonb204a422011-06-05 22:04:07 -05003466 if (argcount > co->co_argcount && !(co->co_flags & CO_VARARGS)) {
Benjamin Petersone109c702011-06-24 09:37:26 -05003467 too_many_positional(co, argcount, defcount, fastlocals);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003468 goto fail;
3469 }
Benjamin Petersonb204a422011-06-05 22:04:07 -05003470 if (argcount < co->co_argcount) {
3471 int m = co->co_argcount - defcount;
Benjamin Petersone109c702011-06-24 09:37:26 -05003472 int missing = 0;
3473 for (i = argcount; i < m; i++)
3474 if (GETLOCAL(i) == NULL)
3475 missing++;
3476 if (missing) {
3477 missing_arguments(co, missing, defcount, fastlocals);
3478 goto fail;
Benjamin Petersonb204a422011-06-05 22:04:07 -05003479 }
3480 if (n > m)
3481 i = n - m;
3482 else
3483 i = 0;
3484 for (; i < defcount; i++) {
3485 if (GETLOCAL(m+i) == NULL) {
3486 PyObject *def = defs[i];
3487 Py_INCREF(def);
3488 SETLOCAL(m+i, def);
3489 }
3490 }
3491 }
3492 if (co->co_kwonlyargcount > 0) {
Benjamin Petersone109c702011-06-24 09:37:26 -05003493 int missing = 0;
Benjamin Petersonb204a422011-06-05 22:04:07 -05003494 for (i = co->co_argcount; i < total_args; i++) {
3495 PyObject *name;
3496 if (GETLOCAL(i) != NULL)
3497 continue;
3498 name = PyTuple_GET_ITEM(co->co_varnames, i);
3499 if (kwdefs != NULL) {
3500 PyObject *def = PyDict_GetItem(kwdefs, name);
3501 if (def) {
3502 Py_INCREF(def);
3503 SETLOCAL(i, def);
3504 continue;
3505 }
3506 }
Benjamin Petersone109c702011-06-24 09:37:26 -05003507 missing++;
3508 }
3509 if (missing) {
3510 missing_arguments(co, missing, -1, fastlocals);
Benjamin Petersonb204a422011-06-05 22:04:07 -05003511 goto fail;
3512 }
3513 }
3514
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003515 /* Allocate and initialize storage for cell vars, and copy free
Benjamin Peterson90037602011-06-25 22:54:45 -05003516 vars into frame. */
3517 for (i = 0; i < PyTuple_GET_SIZE(co->co_cellvars); ++i) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003518 PyObject *c;
Benjamin Peterson90037602011-06-25 22:54:45 -05003519 int arg;
3520 /* Possibly account for the cell variable being an argument. */
3521 if (co->co_cell2arg != NULL &&
Guido van Rossum6832c812013-05-10 08:47:42 -07003522 (arg = co->co_cell2arg[i]) != CO_CELL_NOT_AN_ARG) {
Benjamin Peterson90037602011-06-25 22:54:45 -05003523 c = PyCell_New(GETLOCAL(arg));
Guido van Rossum6832c812013-05-10 08:47:42 -07003524 if (c == NULL)
3525 goto fail;
3526 /* Reference the cell from the argument slot, for super().
3527 See typeobject.c. */
3528 Py_INCREF(c);
3529 SETLOCAL(arg, c);
3530 }
3531 else {
Benjamin Peterson90037602011-06-25 22:54:45 -05003532 c = PyCell_New(NULL);
Guido van Rossum6832c812013-05-10 08:47:42 -07003533 if (c == NULL)
3534 goto fail;
3535 }
Benjamin Peterson90037602011-06-25 22:54:45 -05003536 SETLOCAL(co->co_nlocals + i, c);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003537 }
Benjamin Peterson90037602011-06-25 22:54:45 -05003538 for (i = 0; i < PyTuple_GET_SIZE(co->co_freevars); ++i) {
3539 PyObject *o = PyTuple_GET_ITEM(closure, i);
3540 Py_INCREF(o);
3541 freevars[PyTuple_GET_SIZE(co->co_cellvars) + i] = o;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003542 }
Tim Peters5ca576e2001-06-18 22:08:13 +00003543
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003544 if (co->co_flags & CO_GENERATOR) {
3545 /* Don't need to keep the reference to f_back, it will be set
3546 * when the generator is resumed. */
3547 Py_XDECREF(f->f_back);
3548 f->f_back = NULL;
Neil Schemenauer2b13ce82001-06-21 02:41:10 +00003549
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003550 PCALL(PCALL_GENERATOR);
Jeremy Hylton985eba52003-02-05 23:13:00 +00003551
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003552 /* Create a new generator that owns the ready to run frame
3553 * and return that as the value. */
3554 return PyGen_New(f);
3555 }
Tim Peters5ca576e2001-06-18 22:08:13 +00003556
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003557 retval = PyEval_EvalFrameEx(f,0);
Tim Peters5ca576e2001-06-18 22:08:13 +00003558
Thomas Woutersce272b62007-09-19 21:19:28 +00003559fail: /* Jump here from prelude on failure */
Tim Peters5ca576e2001-06-18 22:08:13 +00003560
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003561 /* decref'ing the frame can cause __del__ methods to get invoked,
3562 which can call back into Python. While we're done with the
3563 current Python frame (f), the associated C stack is still in use,
3564 so recursion_depth must be boosted for the duration.
3565 */
3566 assert(tstate != NULL);
3567 ++tstate->recursion_depth;
3568 Py_DECREF(f);
3569 --tstate->recursion_depth;
3570 return retval;
Tim Peters5ca576e2001-06-18 22:08:13 +00003571}
3572
3573
Benjamin Peterson876b2f22009-06-28 03:18:59 +00003574static PyObject *
Benjamin Petersonce798522012-01-22 11:24:29 -05003575special_lookup(PyObject *o, _Py_Identifier *id)
Benjamin Peterson876b2f22009-06-28 03:18:59 +00003576{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003577 PyObject *res;
Benjamin Petersonce798522012-01-22 11:24:29 -05003578 res = _PyObject_LookupSpecial(o, id);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003579 if (res == NULL && !PyErr_Occurred()) {
Benjamin Petersonce798522012-01-22 11:24:29 -05003580 PyErr_SetObject(PyExc_AttributeError, id->object);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003581 return NULL;
3582 }
3583 return res;
Benjamin Peterson876b2f22009-06-28 03:18:59 +00003584}
3585
3586
Benjamin Peterson87880242011-07-03 16:48:31 -05003587/* These 3 functions deal with the exception state of generators. */
3588
3589static void
3590save_exc_state(PyThreadState *tstate, PyFrameObject *f)
3591{
3592 PyObject *type, *value, *traceback;
3593 Py_XINCREF(tstate->exc_type);
3594 Py_XINCREF(tstate->exc_value);
3595 Py_XINCREF(tstate->exc_traceback);
3596 type = f->f_exc_type;
3597 value = f->f_exc_value;
3598 traceback = f->f_exc_traceback;
3599 f->f_exc_type = tstate->exc_type;
3600 f->f_exc_value = tstate->exc_value;
3601 f->f_exc_traceback = tstate->exc_traceback;
3602 Py_XDECREF(type);
3603 Py_XDECREF(value);
Victor Stinnerd2a915d2011-10-02 20:34:20 +02003604 Py_XDECREF(traceback);
Benjamin Peterson87880242011-07-03 16:48:31 -05003605}
3606
3607static void
3608swap_exc_state(PyThreadState *tstate, PyFrameObject *f)
3609{
3610 PyObject *tmp;
3611 tmp = tstate->exc_type;
3612 tstate->exc_type = f->f_exc_type;
3613 f->f_exc_type = tmp;
3614 tmp = tstate->exc_value;
3615 tstate->exc_value = f->f_exc_value;
3616 f->f_exc_value = tmp;
3617 tmp = tstate->exc_traceback;
3618 tstate->exc_traceback = f->f_exc_traceback;
3619 f->f_exc_traceback = tmp;
3620}
3621
3622static void
3623restore_and_clear_exc_state(PyThreadState *tstate, PyFrameObject *f)
3624{
3625 PyObject *type, *value, *tb;
3626 type = tstate->exc_type;
3627 value = tstate->exc_value;
3628 tb = tstate->exc_traceback;
3629 tstate->exc_type = f->f_exc_type;
3630 tstate->exc_value = f->f_exc_value;
3631 tstate->exc_traceback = f->f_exc_traceback;
3632 f->f_exc_type = NULL;
3633 f->f_exc_value = NULL;
3634 f->f_exc_traceback = NULL;
3635 Py_XDECREF(type);
3636 Py_XDECREF(value);
3637 Py_XDECREF(tb);
3638}
3639
3640
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003641/* Logic for the raise statement (too complicated for inlining).
3642 This *consumes* a reference count to each of its arguments. */
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04003643static int
Collin Winter828f04a2007-08-31 00:04:24 +00003644do_raise(PyObject *exc, PyObject *cause)
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003645{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003646 PyObject *type = NULL, *value = NULL;
Collin Winter828f04a2007-08-31 00:04:24 +00003647
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003648 if (exc == NULL) {
3649 /* Reraise */
3650 PyThreadState *tstate = PyThreadState_GET();
3651 PyObject *tb;
3652 type = tstate->exc_type;
3653 value = tstate->exc_value;
3654 tb = tstate->exc_traceback;
3655 if (type == Py_None) {
3656 PyErr_SetString(PyExc_RuntimeError,
3657 "No active exception to reraise");
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04003658 return 0;
3659 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003660 Py_XINCREF(type);
3661 Py_XINCREF(value);
3662 Py_XINCREF(tb);
3663 PyErr_Restore(type, value, tb);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04003664 return 1;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003665 }
Guido van Rossumac7be682001-01-17 15:42:30 +00003666
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003667 /* We support the following forms of raise:
3668 raise
Collin Winter828f04a2007-08-31 00:04:24 +00003669 raise <instance>
3670 raise <type> */
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003671
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003672 if (PyExceptionClass_Check(exc)) {
3673 type = exc;
3674 value = PyObject_CallObject(exc, NULL);
3675 if (value == NULL)
3676 goto raise_error;
Benjamin Peterson5afa03a2011-07-15 14:09:26 -05003677 if (!PyExceptionInstance_Check(value)) {
3678 PyErr_Format(PyExc_TypeError,
3679 "calling %R should have returned an instance of "
3680 "BaseException, not %R",
3681 type, Py_TYPE(value));
3682 goto raise_error;
3683 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003684 }
3685 else if (PyExceptionInstance_Check(exc)) {
3686 value = exc;
3687 type = PyExceptionInstance_Class(exc);
3688 Py_INCREF(type);
3689 }
3690 else {
3691 /* Not something you can raise. You get an exception
3692 anyway, just not what you specified :-) */
3693 Py_DECREF(exc);
3694 PyErr_SetString(PyExc_TypeError,
3695 "exceptions must derive from BaseException");
3696 goto raise_error;
3697 }
Collin Winter828f04a2007-08-31 00:04:24 +00003698
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003699 if (cause) {
3700 PyObject *fixed_cause;
3701 if (PyExceptionClass_Check(cause)) {
3702 fixed_cause = PyObject_CallObject(cause, NULL);
3703 if (fixed_cause == NULL)
3704 goto raise_error;
Benjamin Petersond5a1c442012-05-14 22:09:31 -07003705 Py_DECREF(cause);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003706 }
Benjamin Petersond5a1c442012-05-14 22:09:31 -07003707 else if (PyExceptionInstance_Check(cause)) {
3708 fixed_cause = cause;
3709 }
3710 else if (cause == Py_None) {
3711 Py_DECREF(cause);
3712 fixed_cause = NULL;
3713 }
3714 else {
3715 PyErr_SetString(PyExc_TypeError,
3716 "exception causes must derive from "
3717 "BaseException");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003718 goto raise_error;
3719 }
Benjamin Petersond5a1c442012-05-14 22:09:31 -07003720 PyException_SetCause(value, fixed_cause);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003721 }
Collin Winter828f04a2007-08-31 00:04:24 +00003722
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003723 PyErr_SetObject(type, value);
3724 /* PyErr_SetObject incref's its arguments */
3725 Py_XDECREF(value);
3726 Py_XDECREF(type);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04003727 return 0;
Collin Winter828f04a2007-08-31 00:04:24 +00003728
3729raise_error:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003730 Py_XDECREF(value);
3731 Py_XDECREF(type);
3732 Py_XDECREF(cause);
Benjamin Peterson31a58ff2012-10-12 11:34:51 -04003733 return 0;
Guido van Rossum0aa9ee61996-12-10 18:07:35 +00003734}
3735
Tim Petersd6d010b2001-06-21 02:49:55 +00003736/* Iterate v argcnt times and store the results on the stack (via decreasing
Guido van Rossum0368b722007-05-11 16:50:42 +00003737 sp). Return 1 for success, 0 if error.
Antoine Pitrou9a2310d2008-07-25 22:39:39 +00003738
Guido van Rossum0368b722007-05-11 16:50:42 +00003739 If argcntafter == -1, do a simple unpack. If it is >= 0, do an unpack
3740 with a variable target.
3741*/
Tim Petersd6d010b2001-06-21 02:49:55 +00003742
Barry Warsawe42b18f1997-08-25 22:13:04 +00003743static int
Guido van Rossum0368b722007-05-11 16:50:42 +00003744unpack_iterable(PyObject *v, int argcnt, int argcntafter, PyObject **sp)
Barry Warsawe42b18f1997-08-25 22:13:04 +00003745{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003746 int i = 0, j = 0;
3747 Py_ssize_t ll = 0;
3748 PyObject *it; /* iter(v) */
3749 PyObject *w;
3750 PyObject *l = NULL; /* variable list */
Guido van Rossumac7be682001-01-17 15:42:30 +00003751
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003752 assert(v != NULL);
Tim Petersd6d010b2001-06-21 02:49:55 +00003753
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003754 it = PyObject_GetIter(v);
3755 if (it == NULL)
3756 goto Error;
Tim Petersd6d010b2001-06-21 02:49:55 +00003757
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003758 for (; i < argcnt; i++) {
3759 w = PyIter_Next(it);
3760 if (w == NULL) {
3761 /* Iterator done, via error or exhaustion. */
3762 if (!PyErr_Occurred()) {
3763 PyErr_Format(PyExc_ValueError,
3764 "need more than %d value%s to unpack",
3765 i, i == 1 ? "" : "s");
3766 }
3767 goto Error;
3768 }
3769 *--sp = w;
3770 }
Tim Petersd6d010b2001-06-21 02:49:55 +00003771
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003772 if (argcntafter == -1) {
3773 /* We better have exhausted the iterator now. */
3774 w = PyIter_Next(it);
3775 if (w == NULL) {
3776 if (PyErr_Occurred())
3777 goto Error;
3778 Py_DECREF(it);
3779 return 1;
3780 }
3781 Py_DECREF(w);
Georg Brandl0310a832010-07-10 10:32:36 +00003782 PyErr_Format(PyExc_ValueError, "too many values to unpack "
3783 "(expected %d)", argcnt);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003784 goto Error;
3785 }
Guido van Rossum0368b722007-05-11 16:50:42 +00003786
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003787 l = PySequence_List(it);
3788 if (l == NULL)
3789 goto Error;
3790 *--sp = l;
3791 i++;
Guido van Rossum0368b722007-05-11 16:50:42 +00003792
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003793 ll = PyList_GET_SIZE(l);
3794 if (ll < argcntafter) {
3795 PyErr_Format(PyExc_ValueError, "need more than %zd values to unpack",
3796 argcnt + ll);
3797 goto Error;
3798 }
Guido van Rossum0368b722007-05-11 16:50:42 +00003799
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003800 /* Pop the "after-variable" args off the list. */
3801 for (j = argcntafter; j > 0; j--, i++) {
3802 *--sp = PyList_GET_ITEM(l, ll - j);
3803 }
3804 /* Resize the list. */
3805 Py_SIZE(l) = ll - argcntafter;
3806 Py_DECREF(it);
3807 return 1;
Guido van Rossum0368b722007-05-11 16:50:42 +00003808
Tim Petersd6d010b2001-06-21 02:49:55 +00003809Error:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003810 for (; i > 0; i--, sp++)
3811 Py_DECREF(*sp);
3812 Py_XDECREF(it);
3813 return 0;
Barry Warsawe42b18f1997-08-25 22:13:04 +00003814}
3815
3816
Guido van Rossum96a42c81992-01-12 02:29:51 +00003817#ifdef LLTRACE
Guido van Rossum3f5da241990-12-20 15:06:42 +00003818static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003819prtrace(PyObject *v, char *str)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003820{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003821 printf("%s ", str);
3822 if (PyObject_Print(v, stdout, 0) != 0)
3823 PyErr_Clear(); /* Don't know what else to do */
3824 printf("\n");
3825 return 1;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003826}
Guido van Rossum3f5da241990-12-20 15:06:42 +00003827#endif
Guido van Rossum10dc2e81990-11-18 17:27:39 +00003828
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003829static void
Fred Drake5755ce62001-06-27 19:19:46 +00003830call_exc_trace(Py_tracefunc func, PyObject *self, PyFrameObject *f)
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003831{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003832 PyObject *type, *value, *traceback, *arg;
3833 int err;
3834 PyErr_Fetch(&type, &value, &traceback);
3835 if (value == NULL) {
3836 value = Py_None;
3837 Py_INCREF(value);
3838 }
R David Murray35837612013-04-19 12:56:57 -04003839 PyErr_NormalizeException(&type, &value, &traceback);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003840 arg = PyTuple_Pack(3, type, value, traceback);
3841 if (arg == NULL) {
3842 PyErr_Restore(type, value, traceback);
3843 return;
3844 }
3845 err = call_trace(func, self, f, PyTrace_EXCEPTION, arg);
3846 Py_DECREF(arg);
3847 if (err == 0)
3848 PyErr_Restore(type, value, traceback);
3849 else {
3850 Py_XDECREF(type);
3851 Py_XDECREF(value);
3852 Py_XDECREF(traceback);
3853 }
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003854}
3855
Amaury Forgeot d'Arcf05149a2007-11-13 01:05:30 +00003856static int
Fred Drake4ec5d562001-10-04 19:26:43 +00003857call_trace_protected(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003858 int what, PyObject *arg)
Fred Drake4ec5d562001-10-04 19:26:43 +00003859{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003860 PyObject *type, *value, *traceback;
3861 int err;
3862 PyErr_Fetch(&type, &value, &traceback);
3863 err = call_trace(func, obj, frame, what, arg);
3864 if (err == 0)
3865 {
3866 PyErr_Restore(type, value, traceback);
3867 return 0;
3868 }
3869 else {
3870 Py_XDECREF(type);
3871 Py_XDECREF(value);
3872 Py_XDECREF(traceback);
3873 return -1;
3874 }
Fred Drake4ec5d562001-10-04 19:26:43 +00003875}
3876
Guido van Rossum9c8d70d1992-03-23 18:19:28 +00003877static int
Fred Drake5755ce62001-06-27 19:19:46 +00003878call_trace(Py_tracefunc func, PyObject *obj, PyFrameObject *frame,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003879 int what, PyObject *arg)
Guido van Rossum96a42c81992-01-12 02:29:51 +00003880{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003881 register PyThreadState *tstate = frame->f_tstate;
3882 int result;
3883 if (tstate->tracing)
3884 return 0;
3885 tstate->tracing++;
3886 tstate->use_tracing = 0;
3887 result = func(obj, frame, what, arg);
3888 tstate->use_tracing = ((tstate->c_tracefunc != NULL)
3889 || (tstate->c_profilefunc != NULL));
3890 tstate->tracing--;
3891 return result;
Guido van Rossum96a42c81992-01-12 02:29:51 +00003892}
3893
Guido van Rossuma12fe4e2003-04-09 19:06:21 +00003894PyObject *
3895_PyEval_CallTracing(PyObject *func, PyObject *args)
3896{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003897 PyFrameObject *frame = PyEval_GetFrame();
3898 PyThreadState *tstate = frame->f_tstate;
3899 int save_tracing = tstate->tracing;
3900 int save_use_tracing = tstate->use_tracing;
3901 PyObject *result;
Guido van Rossuma12fe4e2003-04-09 19:06:21 +00003902
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003903 tstate->tracing = 0;
3904 tstate->use_tracing = ((tstate->c_tracefunc != NULL)
3905 || (tstate->c_profilefunc != NULL));
3906 result = PyObject_Call(func, args, NULL);
3907 tstate->tracing = save_tracing;
3908 tstate->use_tracing = save_use_tracing;
3909 return result;
Guido van Rossuma12fe4e2003-04-09 19:06:21 +00003910}
3911
Alexandre Vassalotti7b82b402009-07-21 04:30:03 +00003912/* See Objects/lnotab_notes.txt for a description of how tracing works. */
Michael W. Hudson006c7522002-11-08 13:08:46 +00003913static int
Tim Peters8a5c3c72004-04-05 19:36:21 +00003914maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003915 PyFrameObject *frame, int *instr_lb, int *instr_ub,
3916 int *instr_prev)
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003917{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003918 int result = 0;
3919 int line = frame->f_lineno;
Michael W. Hudson006c7522002-11-08 13:08:46 +00003920
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003921 /* If the last instruction executed isn't in the current
3922 instruction window, reset the window.
3923 */
3924 if (frame->f_lasti < *instr_lb || frame->f_lasti >= *instr_ub) {
3925 PyAddrPair bounds;
3926 line = _PyCode_CheckLineNumber(frame->f_code, frame->f_lasti,
3927 &bounds);
3928 *instr_lb = bounds.ap_lower;
3929 *instr_ub = bounds.ap_upper;
3930 }
3931 /* If the last instruction falls at the start of a line or if
3932 it represents a jump backwards, update the frame's line
3933 number and call the trace function. */
3934 if (frame->f_lasti == *instr_lb || frame->f_lasti < *instr_prev) {
3935 frame->f_lineno = line;
3936 result = call_trace(func, obj, frame, PyTrace_LINE, Py_None);
3937 }
3938 *instr_prev = frame->f_lasti;
3939 return result;
Michael W. Hudsondd32a912002-08-15 14:59:02 +00003940}
3941
Fred Drake5755ce62001-06-27 19:19:46 +00003942void
3943PyEval_SetProfile(Py_tracefunc func, PyObject *arg)
Fred Draked0838392001-06-16 21:02:31 +00003944{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003945 PyThreadState *tstate = PyThreadState_GET();
3946 PyObject *temp = tstate->c_profileobj;
3947 Py_XINCREF(arg);
3948 tstate->c_profilefunc = NULL;
3949 tstate->c_profileobj = NULL;
3950 /* Must make sure that tracing is not ignored if 'temp' is freed */
3951 tstate->use_tracing = tstate->c_tracefunc != NULL;
3952 Py_XDECREF(temp);
3953 tstate->c_profilefunc = func;
3954 tstate->c_profileobj = arg;
3955 /* Flag that tracing or profiling is turned on */
3956 tstate->use_tracing = (func != NULL) || (tstate->c_tracefunc != NULL);
Fred Drake5755ce62001-06-27 19:19:46 +00003957}
3958
3959void
3960PyEval_SetTrace(Py_tracefunc func, PyObject *arg)
3961{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003962 PyThreadState *tstate = PyThreadState_GET();
3963 PyObject *temp = tstate->c_traceobj;
3964 _Py_TracingPossible += (func != NULL) - (tstate->c_tracefunc != NULL);
3965 Py_XINCREF(arg);
3966 tstate->c_tracefunc = NULL;
3967 tstate->c_traceobj = NULL;
3968 /* Must make sure that profiling is not ignored if 'temp' is freed */
3969 tstate->use_tracing = tstate->c_profilefunc != NULL;
3970 Py_XDECREF(temp);
3971 tstate->c_tracefunc = func;
3972 tstate->c_traceobj = arg;
3973 /* Flag that tracing or profiling is turned on */
3974 tstate->use_tracing = ((func != NULL)
3975 || (tstate->c_profilefunc != NULL));
Fred Draked0838392001-06-16 21:02:31 +00003976}
3977
Guido van Rossumb209a111997-04-29 18:18:01 +00003978PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003979PyEval_GetBuiltins(void)
Guido van Rossum6135a871995-01-09 17:53:26 +00003980{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003981 PyFrameObject *current_frame = PyEval_GetFrame();
3982 if (current_frame == NULL)
3983 return PyThreadState_GET()->interp->builtins;
3984 else
3985 return current_frame->f_builtins;
Guido van Rossum6135a871995-01-09 17:53:26 +00003986}
3987
Guido van Rossumb209a111997-04-29 18:18:01 +00003988PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003989PyEval_GetLocals(void)
Guido van Rossum5b722181993-03-30 17:46:03 +00003990{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00003991 PyFrameObject *current_frame = PyEval_GetFrame();
3992 if (current_frame == NULL)
3993 return NULL;
3994 PyFrame_FastToLocals(current_frame);
3995 return current_frame->f_locals;
Guido van Rossum5b722181993-03-30 17:46:03 +00003996}
3997
Guido van Rossumb209a111997-04-29 18:18:01 +00003998PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00003999PyEval_GetGlobals(void)
Guido van Rossum3f5da241990-12-20 15:06:42 +00004000{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004001 PyFrameObject *current_frame = PyEval_GetFrame();
4002 if (current_frame == NULL)
4003 return NULL;
4004 else
4005 return current_frame->f_globals;
Guido van Rossum3f5da241990-12-20 15:06:42 +00004006}
4007
Guido van Rossum6297a7a2003-02-19 15:53:17 +00004008PyFrameObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004009PyEval_GetFrame(void)
Guido van Rossume59214e1994-08-30 08:01:59 +00004010{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004011 PyThreadState *tstate = PyThreadState_GET();
4012 return _PyThreadState_GetFrame(tstate);
Guido van Rossume59214e1994-08-30 08:01:59 +00004013}
4014
Guido van Rossum6135a871995-01-09 17:53:26 +00004015int
Tim Peters5ba58662001-07-16 02:29:45 +00004016PyEval_MergeCompilerFlags(PyCompilerFlags *cf)
Jeremy Hylton061d1062001-03-22 02:32:48 +00004017{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004018 PyFrameObject *current_frame = PyEval_GetFrame();
4019 int result = cf->cf_flags != 0;
Tim Peters5ba58662001-07-16 02:29:45 +00004020
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004021 if (current_frame != NULL) {
4022 const int codeflags = current_frame->f_code->co_flags;
4023 const int compilerflags = codeflags & PyCF_MASK;
4024 if (compilerflags) {
4025 result = 1;
4026 cf->cf_flags |= compilerflags;
4027 }
Neil Schemenauerc24ea082002-03-22 23:53:36 +00004028#if 0 /* future keyword */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004029 if (codeflags & CO_GENERATOR_ALLOWED) {
4030 result = 1;
4031 cf->cf_flags |= CO_GENERATOR_ALLOWED;
4032 }
Neil Schemenauerc24ea082002-03-22 23:53:36 +00004033#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004034 }
4035 return result;
Jeremy Hylton061d1062001-03-22 02:32:48 +00004036}
4037
Guido van Rossum3f5da241990-12-20 15:06:42 +00004038
Guido van Rossum681d79a1995-07-18 14:51:37 +00004039/* External interface to call any callable object.
Antoine Pitrou8689a102010-04-01 16:53:15 +00004040 The arg must be a tuple or NULL. The kw must be a dict or NULL. */
Guido van Rossume59214e1994-08-30 08:01:59 +00004041
Guido van Rossumb209a111997-04-29 18:18:01 +00004042PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004043PyEval_CallObjectWithKeywords(PyObject *func, PyObject *arg, PyObject *kw)
Guido van Rossum681d79a1995-07-18 14:51:37 +00004044{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004045 PyObject *result;
Guido van Rossum681d79a1995-07-18 14:51:37 +00004046
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004047 if (arg == NULL) {
4048 arg = PyTuple_New(0);
4049 if (arg == NULL)
4050 return NULL;
4051 }
4052 else if (!PyTuple_Check(arg)) {
4053 PyErr_SetString(PyExc_TypeError,
4054 "argument list must be a tuple");
4055 return NULL;
4056 }
4057 else
4058 Py_INCREF(arg);
Guido van Rossum681d79a1995-07-18 14:51:37 +00004059
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004060 if (kw != NULL && !PyDict_Check(kw)) {
4061 PyErr_SetString(PyExc_TypeError,
4062 "keyword list must be a dictionary");
4063 Py_DECREF(arg);
4064 return NULL;
4065 }
Guido van Rossume3e61c11995-08-04 04:14:47 +00004066
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004067 result = PyObject_Call(func, arg, kw);
4068 Py_DECREF(arg);
4069 return result;
Jeremy Hylton52820442001-01-03 23:52:36 +00004070}
4071
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00004072const char *
Tim Peters6d6c1a32001-08-02 04:15:00 +00004073PyEval_GetFuncName(PyObject *func)
Jeremy Hylton512a2372001-04-11 13:52:29 +00004074{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004075 if (PyMethod_Check(func))
4076 return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func));
4077 else if (PyFunction_Check(func))
4078 return _PyUnicode_AsString(((PyFunctionObject*)func)->func_name);
4079 else if (PyCFunction_Check(func))
4080 return ((PyCFunctionObject*)func)->m_ml->ml_name;
4081 else
4082 return func->ob_type->tp_name;
Jeremy Hylton512a2372001-04-11 13:52:29 +00004083}
4084
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00004085const char *
Tim Peters6d6c1a32001-08-02 04:15:00 +00004086PyEval_GetFuncDesc(PyObject *func)
Jeremy Hylton512a2372001-04-11 13:52:29 +00004087{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004088 if (PyMethod_Check(func))
4089 return "()";
4090 else if (PyFunction_Check(func))
4091 return "()";
4092 else if (PyCFunction_Check(func))
4093 return "()";
4094 else
4095 return " object";
Jeremy Hylton512a2372001-04-11 13:52:29 +00004096}
4097
Neal Norwitzaddfe0c2002-11-10 14:33:26 +00004098static void
Jeremy Hylton192690e2002-08-16 18:36:11 +00004099err_args(PyObject *func, int flags, int nargs)
4100{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004101 if (flags & METH_NOARGS)
4102 PyErr_Format(PyExc_TypeError,
4103 "%.200s() takes no arguments (%d given)",
4104 ((PyCFunctionObject *)func)->m_ml->ml_name,
4105 nargs);
4106 else
4107 PyErr_Format(PyExc_TypeError,
4108 "%.200s() takes exactly one argument (%d given)",
4109 ((PyCFunctionObject *)func)->m_ml->ml_name,
4110 nargs);
Jeremy Hylton192690e2002-08-16 18:36:11 +00004111}
4112
Armin Rigo1c2d7e52005-09-20 18:34:01 +00004113#define C_TRACE(x, call) \
Nicholas Bastind858a772004-06-25 23:31:06 +00004114if (tstate->use_tracing && tstate->c_profilefunc) { \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004115 if (call_trace(tstate->c_profilefunc, \
4116 tstate->c_profileobj, \
4117 tstate->frame, PyTrace_C_CALL, \
4118 func)) { \
4119 x = NULL; \
4120 } \
4121 else { \
4122 x = call; \
4123 if (tstate->c_profilefunc != NULL) { \
4124 if (x == NULL) { \
4125 call_trace_protected(tstate->c_profilefunc, \
4126 tstate->c_profileobj, \
4127 tstate->frame, PyTrace_C_EXCEPTION, \
4128 func); \
4129 /* XXX should pass (type, value, tb) */ \
4130 } else { \
4131 if (call_trace(tstate->c_profilefunc, \
4132 tstate->c_profileobj, \
4133 tstate->frame, PyTrace_C_RETURN, \
4134 func)) { \
4135 Py_DECREF(x); \
4136 x = NULL; \
4137 } \
4138 } \
4139 } \
4140 } \
Nicholas Bastind858a772004-06-25 23:31:06 +00004141} else { \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004142 x = call; \
4143 }
Nicholas Bastinc69ebe82004-03-24 21:57:10 +00004144
Jeremy Hyltone8c04322002-08-16 17:47:26 +00004145static PyObject *
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00004146call_function(PyObject ***pp_stack, int oparg
4147#ifdef WITH_TSC
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004148 , uint64* pintr0, uint64* pintr1
Martin v. Löwisf30d60e2004-06-08 08:17:44 +00004149#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004150 )
Jeremy Hyltone8c04322002-08-16 17:47:26 +00004151{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004152 int na = oparg & 0xff;
4153 int nk = (oparg>>8) & 0xff;
4154 int n = na + 2 * nk;
4155 PyObject **pfunc = (*pp_stack) - n - 1;
4156 PyObject *func = *pfunc;
4157 PyObject *x, *w;
Jeremy Hyltone8c04322002-08-16 17:47:26 +00004158
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004159 /* Always dispatch PyCFunction first, because these are
4160 presumed to be the most frequent callable object.
4161 */
4162 if (PyCFunction_Check(func) && nk == 0) {
4163 int flags = PyCFunction_GET_FLAGS(func);
4164 PyThreadState *tstate = PyThreadState_GET();
Raymond Hettingera7f56bc2004-06-26 04:34:33 +00004165
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004166 PCALL(PCALL_CFUNCTION);
4167 if (flags & (METH_NOARGS | METH_O)) {
4168 PyCFunction meth = PyCFunction_GET_FUNCTION(func);
4169 PyObject *self = PyCFunction_GET_SELF(func);
4170 if (flags & METH_NOARGS && na == 0) {
4171 C_TRACE(x, (*meth)(self,NULL));
4172 }
4173 else if (flags & METH_O && na == 1) {
4174 PyObject *arg = EXT_POP(*pp_stack);
4175 C_TRACE(x, (*meth)(self,arg));
4176 Py_DECREF(arg);
4177 }
4178 else {
4179 err_args(func, flags, na);
4180 x = NULL;
4181 }
4182 }
4183 else {
4184 PyObject *callargs;
4185 callargs = load_args(pp_stack, na);
4186 READ_TIMESTAMP(*pintr0);
4187 C_TRACE(x, PyCFunction_Call(func,callargs,NULL));
4188 READ_TIMESTAMP(*pintr1);
4189 Py_XDECREF(callargs);
4190 }
4191 } else {
4192 if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) {
4193 /* optimize access to bound methods */
4194 PyObject *self = PyMethod_GET_SELF(func);
4195 PCALL(PCALL_METHOD);
4196 PCALL(PCALL_BOUND_METHOD);
4197 Py_INCREF(self);
4198 func = PyMethod_GET_FUNCTION(func);
4199 Py_INCREF(func);
4200 Py_DECREF(*pfunc);
4201 *pfunc = self;
4202 na++;
4203 n++;
4204 } else
4205 Py_INCREF(func);
4206 READ_TIMESTAMP(*pintr0);
4207 if (PyFunction_Check(func))
4208 x = fast_function(func, pp_stack, n, na, nk);
4209 else
4210 x = do_call(func, pp_stack, na, nk);
4211 READ_TIMESTAMP(*pintr1);
4212 Py_DECREF(func);
4213 }
Tim Peters8a5c3c72004-04-05 19:36:21 +00004214
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004215 /* Clear the stack of the function object. Also removes
4216 the arguments in case they weren't consumed already
4217 (fast_function() and err_args() leave them on the stack).
4218 */
4219 while ((*pp_stack) > pfunc) {
4220 w = EXT_POP(*pp_stack);
4221 Py_DECREF(w);
4222 PCALL(PCALL_POP);
4223 }
4224 return x;
Jeremy Hyltone8c04322002-08-16 17:47:26 +00004225}
4226
Jeremy Hylton192690e2002-08-16 18:36:11 +00004227/* The fast_function() function optimize calls for which no argument
Jeremy Hylton52820442001-01-03 23:52:36 +00004228 tuple is necessary; the objects are passed directly from the stack.
Jeremy Hylton985eba52003-02-05 23:13:00 +00004229 For the simplest case -- a function that takes only positional
4230 arguments and is called with only positional arguments -- it
4231 inlines the most primitive frame setup code from
4232 PyEval_EvalCodeEx(), which vastly reduces the checks that must be
4233 done before evaluating the frame.
Jeremy Hylton52820442001-01-03 23:52:36 +00004234*/
4235
4236static PyObject *
Guido van Rossumac7be682001-01-17 15:42:30 +00004237fast_function(PyObject *func, PyObject ***pp_stack, int n, int na, int nk)
Jeremy Hylton52820442001-01-03 23:52:36 +00004238{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004239 PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
4240 PyObject *globals = PyFunction_GET_GLOBALS(func);
4241 PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
4242 PyObject *kwdefs = PyFunction_GET_KW_DEFAULTS(func);
4243 PyObject **d = NULL;
4244 int nd = 0;
Jeremy Hylton52820442001-01-03 23:52:36 +00004245
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004246 PCALL(PCALL_FUNCTION);
4247 PCALL(PCALL_FAST_FUNCTION);
4248 if (argdefs == NULL && co->co_argcount == n &&
4249 co->co_kwonlyargcount == 0 && nk==0 &&
4250 co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
4251 PyFrameObject *f;
4252 PyObject *retval = NULL;
4253 PyThreadState *tstate = PyThreadState_GET();
4254 PyObject **fastlocals, **stack;
4255 int i;
Jeremy Hylton985eba52003-02-05 23:13:00 +00004256
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004257 PCALL(PCALL_FASTER_FUNCTION);
4258 assert(globals != NULL);
4259 /* XXX Perhaps we should create a specialized
4260 PyFrame_New() that doesn't take locals, but does
4261 take builtins without sanity checking them.
4262 */
4263 assert(tstate != NULL);
4264 f = PyFrame_New(tstate, co, globals, NULL);
4265 if (f == NULL)
4266 return NULL;
Jeremy Hylton985eba52003-02-05 23:13:00 +00004267
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004268 fastlocals = f->f_localsplus;
4269 stack = (*pp_stack) - n;
Jeremy Hylton985eba52003-02-05 23:13:00 +00004270
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004271 for (i = 0; i < n; i++) {
4272 Py_INCREF(*stack);
4273 fastlocals[i] = *stack++;
4274 }
4275 retval = PyEval_EvalFrameEx(f,0);
4276 ++tstate->recursion_depth;
4277 Py_DECREF(f);
4278 --tstate->recursion_depth;
4279 return retval;
4280 }
4281 if (argdefs != NULL) {
4282 d = &PyTuple_GET_ITEM(argdefs, 0);
4283 nd = Py_SIZE(argdefs);
4284 }
Martin v. Löwis4d0d4712010-12-03 20:14:31 +00004285 return PyEval_EvalCodeEx((PyObject*)co, globals,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004286 (PyObject *)NULL, (*pp_stack)-n, na,
4287 (*pp_stack)-2*nk, nk, d, nd, kwdefs,
4288 PyFunction_GET_CLOSURE(func));
Jeremy Hylton52820442001-01-03 23:52:36 +00004289}
4290
4291static PyObject *
Ka-Ping Yee20579702001-01-15 22:14:16 +00004292update_keyword_args(PyObject *orig_kwdict, int nk, PyObject ***pp_stack,
4293 PyObject *func)
Jeremy Hylton52820442001-01-03 23:52:36 +00004294{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004295 PyObject *kwdict = NULL;
4296 if (orig_kwdict == NULL)
4297 kwdict = PyDict_New();
4298 else {
4299 kwdict = PyDict_Copy(orig_kwdict);
4300 Py_DECREF(orig_kwdict);
4301 }
4302 if (kwdict == NULL)
4303 return NULL;
4304 while (--nk >= 0) {
4305 int err;
4306 PyObject *value = EXT_POP(*pp_stack);
4307 PyObject *key = EXT_POP(*pp_stack);
4308 if (PyDict_GetItem(kwdict, key) != NULL) {
4309 PyErr_Format(PyExc_TypeError,
4310 "%.200s%s got multiple values "
4311 "for keyword argument '%U'",
4312 PyEval_GetFuncName(func),
4313 PyEval_GetFuncDesc(func),
4314 key);
4315 Py_DECREF(key);
4316 Py_DECREF(value);
4317 Py_DECREF(kwdict);
4318 return NULL;
4319 }
4320 err = PyDict_SetItem(kwdict, key, value);
4321 Py_DECREF(key);
4322 Py_DECREF(value);
4323 if (err) {
4324 Py_DECREF(kwdict);
4325 return NULL;
4326 }
4327 }
4328 return kwdict;
Jeremy Hylton52820442001-01-03 23:52:36 +00004329}
4330
4331static PyObject *
4332update_star_args(int nstack, int nstar, PyObject *stararg,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004333 PyObject ***pp_stack)
Jeremy Hylton52820442001-01-03 23:52:36 +00004334{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004335 PyObject *callargs, *w;
Jeremy Hylton52820442001-01-03 23:52:36 +00004336
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004337 callargs = PyTuple_New(nstack + nstar);
4338 if (callargs == NULL) {
4339 return NULL;
4340 }
4341 if (nstar) {
4342 int i;
4343 for (i = 0; i < nstar; i++) {
4344 PyObject *a = PyTuple_GET_ITEM(stararg, i);
4345 Py_INCREF(a);
4346 PyTuple_SET_ITEM(callargs, nstack + i, a);
4347 }
4348 }
4349 while (--nstack >= 0) {
4350 w = EXT_POP(*pp_stack);
4351 PyTuple_SET_ITEM(callargs, nstack, w);
4352 }
4353 return callargs;
Jeremy Hylton52820442001-01-03 23:52:36 +00004354}
4355
4356static PyObject *
4357load_args(PyObject ***pp_stack, int na)
4358{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004359 PyObject *args = PyTuple_New(na);
4360 PyObject *w;
Jeremy Hylton52820442001-01-03 23:52:36 +00004361
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004362 if (args == NULL)
4363 return NULL;
4364 while (--na >= 0) {
4365 w = EXT_POP(*pp_stack);
4366 PyTuple_SET_ITEM(args, na, w);
4367 }
4368 return args;
Jeremy Hylton52820442001-01-03 23:52:36 +00004369}
4370
4371static PyObject *
4372do_call(PyObject *func, PyObject ***pp_stack, int na, int nk)
4373{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004374 PyObject *callargs = NULL;
4375 PyObject *kwdict = NULL;
4376 PyObject *result = NULL;
Jeremy Hylton52820442001-01-03 23:52:36 +00004377
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004378 if (nk > 0) {
4379 kwdict = update_keyword_args(NULL, nk, pp_stack, func);
4380 if (kwdict == NULL)
4381 goto call_fail;
4382 }
4383 callargs = load_args(pp_stack, na);
4384 if (callargs == NULL)
4385 goto call_fail;
Jeremy Hylton985eba52003-02-05 23:13:00 +00004386#ifdef CALL_PROFILE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004387 /* At this point, we have to look at the type of func to
4388 update the call stats properly. Do it here so as to avoid
4389 exposing the call stats machinery outside ceval.c
4390 */
4391 if (PyFunction_Check(func))
4392 PCALL(PCALL_FUNCTION);
4393 else if (PyMethod_Check(func))
4394 PCALL(PCALL_METHOD);
4395 else if (PyType_Check(func))
4396 PCALL(PCALL_TYPE);
4397 else if (PyCFunction_Check(func))
4398 PCALL(PCALL_CFUNCTION);
4399 else
4400 PCALL(PCALL_OTHER);
Jeremy Hylton985eba52003-02-05 23:13:00 +00004401#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004402 if (PyCFunction_Check(func)) {
4403 PyThreadState *tstate = PyThreadState_GET();
4404 C_TRACE(result, PyCFunction_Call(func, callargs, kwdict));
4405 }
4406 else
4407 result = PyObject_Call(func, callargs, kwdict);
Thomas Wouters7ce29ca2007-09-19 21:56:32 +00004408call_fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004409 Py_XDECREF(callargs);
4410 Py_XDECREF(kwdict);
4411 return result;
Jeremy Hylton52820442001-01-03 23:52:36 +00004412}
4413
4414static PyObject *
4415ext_do_call(PyObject *func, PyObject ***pp_stack, int flags, int na, int nk)
4416{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004417 int nstar = 0;
4418 PyObject *callargs = NULL;
4419 PyObject *stararg = NULL;
4420 PyObject *kwdict = NULL;
4421 PyObject *result = NULL;
Jeremy Hylton52820442001-01-03 23:52:36 +00004422
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004423 if (flags & CALL_FLAG_KW) {
4424 kwdict = EXT_POP(*pp_stack);
4425 if (!PyDict_Check(kwdict)) {
4426 PyObject *d;
4427 d = PyDict_New();
4428 if (d == NULL)
4429 goto ext_call_fail;
4430 if (PyDict_Update(d, kwdict) != 0) {
4431 Py_DECREF(d);
4432 /* PyDict_Update raises attribute
4433 * error (percolated from an attempt
4434 * to get 'keys' attribute) instead of
4435 * a type error if its second argument
4436 * is not a mapping.
4437 */
4438 if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
4439 PyErr_Format(PyExc_TypeError,
4440 "%.200s%.200s argument after ** "
4441 "must be a mapping, not %.200s",
4442 PyEval_GetFuncName(func),
4443 PyEval_GetFuncDesc(func),
4444 kwdict->ob_type->tp_name);
4445 }
4446 goto ext_call_fail;
4447 }
4448 Py_DECREF(kwdict);
4449 kwdict = d;
4450 }
4451 }
4452 if (flags & CALL_FLAG_VAR) {
4453 stararg = EXT_POP(*pp_stack);
4454 if (!PyTuple_Check(stararg)) {
4455 PyObject *t = NULL;
4456 t = PySequence_Tuple(stararg);
4457 if (t == NULL) {
4458 if (PyErr_ExceptionMatches(PyExc_TypeError)) {
4459 PyErr_Format(PyExc_TypeError,
4460 "%.200s%.200s argument after * "
Victor Stinner0a5f65a2011-03-22 01:09:21 +01004461 "must be a sequence, not %.200s",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004462 PyEval_GetFuncName(func),
4463 PyEval_GetFuncDesc(func),
4464 stararg->ob_type->tp_name);
4465 }
4466 goto ext_call_fail;
4467 }
4468 Py_DECREF(stararg);
4469 stararg = t;
4470 }
4471 nstar = PyTuple_GET_SIZE(stararg);
4472 }
4473 if (nk > 0) {
4474 kwdict = update_keyword_args(kwdict, nk, pp_stack, func);
4475 if (kwdict == NULL)
4476 goto ext_call_fail;
4477 }
4478 callargs = update_star_args(na, nstar, stararg, pp_stack);
4479 if (callargs == NULL)
4480 goto ext_call_fail;
Jeremy Hylton985eba52003-02-05 23:13:00 +00004481#ifdef CALL_PROFILE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004482 /* At this point, we have to look at the type of func to
4483 update the call stats properly. Do it here so as to avoid
4484 exposing the call stats machinery outside ceval.c
4485 */
4486 if (PyFunction_Check(func))
4487 PCALL(PCALL_FUNCTION);
4488 else if (PyMethod_Check(func))
4489 PCALL(PCALL_METHOD);
4490 else if (PyType_Check(func))
4491 PCALL(PCALL_TYPE);
4492 else if (PyCFunction_Check(func))
4493 PCALL(PCALL_CFUNCTION);
4494 else
4495 PCALL(PCALL_OTHER);
Jeremy Hylton985eba52003-02-05 23:13:00 +00004496#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004497 if (PyCFunction_Check(func)) {
4498 PyThreadState *tstate = PyThreadState_GET();
4499 C_TRACE(result, PyCFunction_Call(func, callargs, kwdict));
4500 }
4501 else
4502 result = PyObject_Call(func, callargs, kwdict);
Thomas Woutersce272b62007-09-19 21:19:28 +00004503ext_call_fail:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004504 Py_XDECREF(callargs);
4505 Py_XDECREF(kwdict);
4506 Py_XDECREF(stararg);
4507 return result;
Jeremy Hylton52820442001-01-03 23:52:36 +00004508}
4509
Guido van Rossum38fff8c2006-03-07 18:50:55 +00004510/* Extract a slice index from a PyInt or PyLong or an object with the
4511 nb_index slot defined, and store in *pi.
4512 Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX,
4513 and silently boost values less than -PY_SSIZE_T_MAX-1 to -PY_SSIZE_T_MAX-1.
Martin v. Löwisdde99d22006-02-17 15:57:41 +00004514 Return 0 on error, 1 on success.
Tim Peterscb479e72001-12-16 19:11:44 +00004515*/
Tim Petersb5196382001-12-16 19:44:20 +00004516/* Note: If v is NULL, return success without storing into *pi. This
4517 is because_PyEval_SliceIndex() is called by apply_slice(), which can be
4518 called by the SLICE opcode with v and/or w equal to NULL.
Tim Peterscb479e72001-12-16 19:11:44 +00004519*/
Guido van Rossum20c6add2000-05-08 14:06:50 +00004520int
Martin v. Löwis18e16552006-02-15 17:27:45 +00004521_PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004522{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004523 if (v != NULL) {
4524 Py_ssize_t x;
4525 if (PyIndex_Check(v)) {
4526 x = PyNumber_AsSsize_t(v, NULL);
4527 if (x == -1 && PyErr_Occurred())
4528 return 0;
4529 }
4530 else {
4531 PyErr_SetString(PyExc_TypeError,
4532 "slice indices must be integers or "
4533 "None or have an __index__ method");
4534 return 0;
4535 }
4536 *pi = x;
4537 }
4538 return 1;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004539}
4540
Guido van Rossum486364b2007-06-30 05:01:58 +00004541#define CANNOT_CATCH_MSG "catching classes that do not inherit from "\
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004542 "BaseException is not allowed"
Brett Cannonf74225d2007-02-26 21:10:16 +00004543
Guido van Rossumb209a111997-04-29 18:18:01 +00004544static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004545cmp_outcome(int op, register PyObject *v, register PyObject *w)
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004546{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004547 int res = 0;
4548 switch (op) {
4549 case PyCmp_IS:
4550 res = (v == w);
4551 break;
4552 case PyCmp_IS_NOT:
4553 res = (v != w);
4554 break;
4555 case PyCmp_IN:
4556 res = PySequence_Contains(w, v);
4557 if (res < 0)
4558 return NULL;
4559 break;
4560 case PyCmp_NOT_IN:
4561 res = PySequence_Contains(w, v);
4562 if (res < 0)
4563 return NULL;
4564 res = !res;
4565 break;
4566 case PyCmp_EXC_MATCH:
4567 if (PyTuple_Check(w)) {
4568 Py_ssize_t i, length;
4569 length = PyTuple_Size(w);
4570 for (i = 0; i < length; i += 1) {
4571 PyObject *exc = PyTuple_GET_ITEM(w, i);
4572 if (!PyExceptionClass_Check(exc)) {
4573 PyErr_SetString(PyExc_TypeError,
4574 CANNOT_CATCH_MSG);
4575 return NULL;
4576 }
4577 }
4578 }
4579 else {
4580 if (!PyExceptionClass_Check(w)) {
4581 PyErr_SetString(PyExc_TypeError,
4582 CANNOT_CATCH_MSG);
4583 return NULL;
4584 }
4585 }
4586 res = PyErr_GivenExceptionMatches(v, w);
4587 break;
4588 default:
4589 return PyObject_RichCompare(v, w, op);
4590 }
4591 v = res ? Py_True : Py_False;
4592 Py_INCREF(v);
4593 return v;
Guido van Rossum10dc2e81990-11-18 17:27:39 +00004594}
4595
Thomas Wouters52152252000-08-17 22:55:00 +00004596static PyObject *
4597import_from(PyObject *v, PyObject *name)
Guido van Rossume9736fc1990-11-18 17:33:06 +00004598{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004599 PyObject *x;
Guido van Rossum18d4d8f2001-01-12 16:24:03 +00004600
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004601 x = PyObject_GetAttr(v, name);
4602 if (x == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
4603 PyErr_Format(PyExc_ImportError, "cannot import name %S", name);
4604 }
4605 return x;
Thomas Wouters52152252000-08-17 22:55:00 +00004606}
Guido van Rossumac7be682001-01-17 15:42:30 +00004607
Thomas Wouters52152252000-08-17 22:55:00 +00004608static int
4609import_all_from(PyObject *locals, PyObject *v)
4610{
Martin v. Löwis1c67dd92011-10-14 15:16:45 +02004611 _Py_IDENTIFIER(__all__);
4612 _Py_IDENTIFIER(__dict__);
4613 PyObject *all = _PyObject_GetAttrId(v, &PyId___all__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004614 PyObject *dict, *name, *value;
4615 int skip_leading_underscores = 0;
4616 int pos, err;
Thomas Wouters52152252000-08-17 22:55:00 +00004617
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004618 if (all == NULL) {
4619 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
4620 return -1; /* Unexpected error */
4621 PyErr_Clear();
Martin v. Löwis1c67dd92011-10-14 15:16:45 +02004622 dict = _PyObject_GetAttrId(v, &PyId___dict__);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004623 if (dict == NULL) {
4624 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
4625 return -1;
4626 PyErr_SetString(PyExc_ImportError,
4627 "from-import-* object has no __dict__ and no __all__");
4628 return -1;
4629 }
4630 all = PyMapping_Keys(dict);
4631 Py_DECREF(dict);
4632 if (all == NULL)
4633 return -1;
4634 skip_leading_underscores = 1;
4635 }
Guido van Rossum18d4d8f2001-01-12 16:24:03 +00004636
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004637 for (pos = 0, err = 0; ; pos++) {
4638 name = PySequence_GetItem(all, pos);
4639 if (name == NULL) {
4640 if (!PyErr_ExceptionMatches(PyExc_IndexError))
4641 err = -1;
4642 else
4643 PyErr_Clear();
4644 break;
4645 }
4646 if (skip_leading_underscores &&
4647 PyUnicode_Check(name) &&
Martin v. Löwisd63a3b82011-09-28 07:41:54 +02004648 PyUnicode_READY(name) != -1 &&
4649 PyUnicode_READ_CHAR(name, 0) == '_')
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004650 {
4651 Py_DECREF(name);
4652 continue;
4653 }
4654 value = PyObject_GetAttr(v, name);
4655 if (value == NULL)
4656 err = -1;
4657 else if (PyDict_CheckExact(locals))
4658 err = PyDict_SetItem(locals, name, value);
4659 else
4660 err = PyObject_SetItem(locals, name, value);
4661 Py_DECREF(name);
4662 Py_XDECREF(value);
4663 if (err != 0)
4664 break;
4665 }
4666 Py_DECREF(all);
4667 return err;
Guido van Rossume9736fc1990-11-18 17:33:06 +00004668}
4669
Guido van Rossumac7be682001-01-17 15:42:30 +00004670static void
Neal Norwitzda059e32007-08-26 05:33:45 +00004671format_exc_check_arg(PyObject *exc, const char *format_str, PyObject *obj)
Paul Prescode68140d2000-08-30 20:25:01 +00004672{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004673 const char *obj_str;
Paul Prescode68140d2000-08-30 20:25:01 +00004674
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004675 if (!obj)
4676 return;
Paul Prescode68140d2000-08-30 20:25:01 +00004677
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004678 obj_str = _PyUnicode_AsString(obj);
4679 if (!obj_str)
4680 return;
Paul Prescode68140d2000-08-30 20:25:01 +00004681
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004682 PyErr_Format(exc, format_str, obj_str);
Paul Prescode68140d2000-08-30 20:25:01 +00004683}
Guido van Rossum950361c1997-01-24 13:49:28 +00004684
Amaury Forgeot d'Arcba117ef2010-09-10 21:39:53 +00004685static void
4686format_exc_unbound(PyCodeObject *co, int oparg)
4687{
4688 PyObject *name;
4689 /* Don't stomp existing exception */
4690 if (PyErr_Occurred())
4691 return;
4692 if (oparg < PyTuple_GET_SIZE(co->co_cellvars)) {
4693 name = PyTuple_GET_ITEM(co->co_cellvars,
4694 oparg);
4695 format_exc_check_arg(
4696 PyExc_UnboundLocalError,
4697 UNBOUNDLOCAL_ERROR_MSG,
4698 name);
4699 } else {
4700 name = PyTuple_GET_ITEM(co->co_freevars, oparg -
4701 PyTuple_GET_SIZE(co->co_cellvars));
4702 format_exc_check_arg(PyExc_NameError,
4703 UNBOUNDFREE_ERROR_MSG, name);
4704 }
4705}
4706
Victor Stinnerd2a915d2011-10-02 20:34:20 +02004707static PyObject *
4708unicode_concatenate(PyObject *v, PyObject *w,
4709 PyFrameObject *f, unsigned char *next_instr)
4710{
4711 PyObject *res;
4712 if (Py_REFCNT(v) == 2) {
4713 /* In the common case, there are 2 references to the value
4714 * stored in 'variable' when the += is performed: one on the
4715 * value stack (in 'v') and one still stored in the
4716 * 'variable'. We try to delete the variable now to reduce
4717 * the refcnt to 1.
4718 */
4719 switch (*next_instr) {
4720 case STORE_FAST:
4721 {
4722 int oparg = PEEKARG();
4723 PyObject **fastlocals = f->f_localsplus;
4724 if (GETLOCAL(oparg) == v)
4725 SETLOCAL(oparg, NULL);
4726 break;
4727 }
4728 case STORE_DEREF:
4729 {
4730 PyObject **freevars = (f->f_localsplus +
4731 f->f_code->co_nlocals);
4732 PyObject *c = freevars[PEEKARG()];
4733 if (PyCell_GET(c) == v)
4734 PyCell_Set(c, NULL);
4735 break;
4736 }
4737 case STORE_NAME:
4738 {
4739 PyObject *names = f->f_code->co_names;
4740 PyObject *name = GETITEM(names, PEEKARG());
4741 PyObject *locals = f->f_locals;
4742 if (PyDict_CheckExact(locals) &&
4743 PyDict_GetItem(locals, name) == v) {
4744 if (PyDict_DelItem(locals, name) != 0) {
4745 PyErr_Clear();
4746 }
4747 }
4748 break;
4749 }
4750 }
4751 }
4752 res = v;
4753 PyUnicode_Append(&res, w);
4754 return res;
4755}
4756
Guido van Rossum950361c1997-01-24 13:49:28 +00004757#ifdef DYNAMIC_EXECUTION_PROFILE
4758
Skip Montanarof118cb12001-10-15 20:51:38 +00004759static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004760getarray(long a[256])
Guido van Rossum950361c1997-01-24 13:49:28 +00004761{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004762 int i;
4763 PyObject *l = PyList_New(256);
4764 if (l == NULL) return NULL;
4765 for (i = 0; i < 256; i++) {
4766 PyObject *x = PyLong_FromLong(a[i]);
4767 if (x == NULL) {
4768 Py_DECREF(l);
4769 return NULL;
4770 }
4771 PyList_SetItem(l, i, x);
4772 }
4773 for (i = 0; i < 256; i++)
4774 a[i] = 0;
4775 return l;
Guido van Rossum950361c1997-01-24 13:49:28 +00004776}
4777
4778PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00004779_Py_GetDXProfile(PyObject *self, PyObject *args)
Guido van Rossum950361c1997-01-24 13:49:28 +00004780{
4781#ifndef DXPAIRS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004782 return getarray(dxp);
Guido van Rossum950361c1997-01-24 13:49:28 +00004783#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00004784 int i;
4785 PyObject *l = PyList_New(257);
4786 if (l == NULL) return NULL;
4787 for (i = 0; i < 257; i++) {
4788 PyObject *x = getarray(dxpairs[i]);
4789 if (x == NULL) {
4790 Py_DECREF(l);
4791 return NULL;
4792 }
4793 PyList_SetItem(l, i, x);
4794 }
4795 return l;
Guido van Rossum950361c1997-01-24 13:49:28 +00004796#endif
4797}
4798
4799#endif