| Location | Tool | Test ID | Function | Issue |
|---|---|---|---|---|
| /builddir/build/BUILD/Python-2.7.3/Objects/frameobject.c:507:13 | clang-analyzer | Access to field 'co_nlocals' results in a dereference of a null pointer (loaded from field 'f_code') | ||
| /builddir/build/BUILD/Python-2.7.3/Objects/frameobject.c:507:13 | clang-analyzer | Access to field 'co_nlocals' results in a dereference of a null pointer (loaded from field 'f_code') |
1 /* Frame object implementation */
2
3 #include "Python.h"
4
5 #include "code.h"
6 #include "frameobject.h"
7 #include "opcode.h"
8 #include "structmember.h"
9
10 #undef MIN
11 #undef MAX
12 #define MIN(a, b) ((a) < (b) ? (a) : (b))
13 #define MAX(a, b) ((a) > (b) ? (a) : (b))
14
15 #define OFF(x) offsetof(PyFrameObject, x)
16
17 static PyMemberDef frame_memberlist[] = {
18 {"f_back", T_OBJECT, OFF(f_back), RO},
19 {"f_code", T_OBJECT, OFF(f_code), RO},
20 {"f_builtins", T_OBJECT, OFF(f_builtins),RO},
21 {"f_globals", T_OBJECT, OFF(f_globals), RO},
22 {"f_lasti", T_INT, OFF(f_lasti), RO},
23 {NULL} /* Sentinel */
24 };
25
26 #define WARN_GET_SET(NAME) \
27 static PyObject * frame_get_ ## NAME(PyFrameObject *f) { \
28 if (PyErr_WarnPy3k(#NAME " has been removed in 3.x", 2) < 0) \
29 return NULL; \
30 if (f->NAME) { \
31 Py_INCREF(f->NAME); \
32 return f->NAME; \
33 } \
34 Py_RETURN_NONE; \
35 } \
36 static int frame_set_ ## NAME(PyFrameObject *f, PyObject *new) { \
37 if (PyErr_WarnPy3k(#NAME " has been removed in 3.x", 2) < 0) \
38 return -1; \
39 if (f->NAME) { \
40 Py_CLEAR(f->NAME); \
41 } \
42 if (new == Py_None) \
43 new = NULL; \
44 Py_XINCREF(new); \
45 f->NAME = new; \
46 return 0; \
47 }
48
49
50 WARN_GET_SET(f_exc_traceback)
51 WARN_GET_SET(f_exc_type)
52 WARN_GET_SET(f_exc_value)
53
54
55 static PyObject *
56 frame_getlocals(PyFrameObject *f, void *closure)
57 {
58 PyFrame_FastToLocals(f);
59 Py_INCREF(f->f_locals);
60 return f->f_locals;
61 }
62
63 int
64 PyFrame_GetLineNumber(PyFrameObject *f)
65 {
66 if (f->f_trace)
67 return f->f_lineno;
68 else
69 return PyCode_Addr2Line(f->f_code, f->f_lasti);
70 }
71
72 static PyObject *
73 frame_getlineno(PyFrameObject *f, void *closure)
74 {
75 return PyInt_FromLong(PyFrame_GetLineNumber(f));
76 }
77
78 /* Setter for f_lineno - you can set f_lineno from within a trace function in
79 * order to jump to a given line of code, subject to some restrictions. Most
80 * lines are OK to jump to because they don't make any assumptions about the
81 * state of the stack (obvious because you could remove the line and the code
82 * would still work without any stack errors), but there are some constructs
83 * that limit jumping:
84 *
85 * o Lines with an 'except' statement on them can't be jumped to, because
86 * they expect an exception to be on the top of the stack.
87 * o Lines that live in a 'finally' block can't be jumped from or to, since
88 * the END_FINALLY expects to clean up the stack after the 'try' block.
89 * o 'try'/'for'/'while' blocks can't be jumped into because the blockstack
90 * needs to be set up before their code runs, and for 'for' loops the
91 * iterator needs to be on the stack.
92 */
93 static int
94 frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno)
95 {
96 int new_lineno = 0; /* The new value of f_lineno */
97 int new_lasti = 0; /* The new value of f_lasti */
98 int new_iblock = 0; /* The new value of f_iblock */
99 unsigned char *code = NULL; /* The bytecode for the frame... */
100 Py_ssize_t code_len = 0; /* ...and its length */
101 unsigned char *lnotab = NULL; /* Iterating over co_lnotab */
102 Py_ssize_t lnotab_len = 0; /* (ditto) */
103 int offset = 0; /* (ditto) */
104 int line = 0; /* (ditto) */
105 int addr = 0; /* (ditto) */
106 int min_addr = 0; /* Scanning the SETUPs and POPs */
107 int max_addr = 0; /* (ditto) */
108 int delta_iblock = 0; /* (ditto) */
109 int min_delta_iblock = 0; /* (ditto) */
110 int min_iblock = 0; /* (ditto) */
111 int f_lasti_setup_addr = 0; /* Policing no-jump-into-finally */
112 int new_lasti_setup_addr = 0; /* (ditto) */
113 int blockstack[CO_MAXBLOCKS]; /* Walking the 'finally' blocks */
114 int in_finally[CO_MAXBLOCKS]; /* (ditto) */
115 int blockstack_top = 0; /* (ditto) */
116 unsigned char setup_op = 0; /* (ditto) */
117
118 /* f_lineno must be an integer. */
119 if (!PyInt_Check(p_new_lineno)) {
120 PyErr_SetString(PyExc_ValueError,
121 "lineno must be an integer");
122 return -1;
123 }
124
125 /* You can only do this from within a trace function, not via
126 * _getframe or similar hackery. */
127 if (!f->f_trace)
128 {
129 PyErr_Format(PyExc_ValueError,
130 "f_lineno can only be set by a"
131 " line trace function");
132 return -1;
133 }
134
135 /* Fail if the line comes before the start of the code block. */
136 new_lineno = (int) PyInt_AsLong(p_new_lineno);
137 if (new_lineno < f->f_code->co_firstlineno) {
138 PyErr_Format(PyExc_ValueError,
139 "line %d comes before the current code block",
140 new_lineno);
141 return -1;
142 }
143 else if (new_lineno == f->f_code->co_firstlineno) {
144 new_lasti = 0;
145 new_lineno = f->f_code->co_firstlineno;
146 }
147 else {
148 /* Find the bytecode offset for the start of the given
149 * line, or the first code-owning line after it. */
150 char *tmp;
151 PyString_AsStringAndSize(f->f_code->co_lnotab,
152 &tmp, &lnotab_len);
153 lnotab = (unsigned char *) tmp;
154 addr = 0;
155 line = f->f_code->co_firstlineno;
156 new_lasti = -1;
157 for (offset = 0; offset < lnotab_len; offset += 2) {
158 addr += lnotab[offset];
159 line += lnotab[offset+1];
160 if (line >= new_lineno) {
161 new_lasti = addr;
162 new_lineno = line;
163 break;
164 }
165 }
166 }
167
168 /* If we didn't reach the requested line, return an error. */
169 if (new_lasti == -1) {
170 PyErr_Format(PyExc_ValueError,
171 "line %d comes after the current code block",
172 new_lineno);
173 return -1;
174 }
175
176 /* We're now ready to look at the bytecode. */
177 PyString_AsStringAndSize(f->f_code->co_code, (char **)&code, &code_len);
178 min_addr = MIN(new_lasti, f->f_lasti);
179 max_addr = MAX(new_lasti, f->f_lasti);
180
181 /* You can't jump onto a line with an 'except' statement on it -
182 * they expect to have an exception on the top of the stack, which
183 * won't be true if you jump to them. They always start with code
184 * that either pops the exception using POP_TOP (plain 'except:'
185 * lines do this) or duplicates the exception on the stack using
186 * DUP_TOP (if there's an exception type specified). See compile.c,
187 * 'com_try_except' for the full details. There aren't any other
188 * cases (AFAIK) where a line's code can start with DUP_TOP or
189 * POP_TOP, but if any ever appear, they'll be subject to the same
190 * restriction (but with a different error message). */
191 if (code[new_lasti] == DUP_TOP || code[new_lasti] == POP_TOP) {
192 PyErr_SetString(PyExc_ValueError,
193 "can't jump to 'except' line as there's no exception");
194 return -1;
195 }
196
197 /* You can't jump into or out of a 'finally' block because the 'try'
198 * block leaves something on the stack for the END_FINALLY to clean
199 * up. So we walk the bytecode, maintaining a simulated blockstack.
200 * When we reach the old or new address and it's in a 'finally' block
201 * we note the address of the corresponding SETUP_FINALLY. The jump
202 * is only legal if neither address is in a 'finally' block or
203 * they're both in the same one. 'blockstack' is a stack of the
204 * bytecode addresses of the SETUP_X opcodes, and 'in_finally' tracks
205 * whether we're in a 'finally' block at each blockstack level. */
206 f_lasti_setup_addr = -1;
207 new_lasti_setup_addr = -1;
208 memset(blockstack, '\0', sizeof(blockstack));
209 memset(in_finally, '\0', sizeof(in_finally));
210 blockstack_top = 0;
211 for (addr = 0; addr < code_len; addr++) {
212 unsigned char op = code[addr];
213 switch (op) {
214 case SETUP_LOOP:
215 case SETUP_EXCEPT:
216 case SETUP_FINALLY:
217 blockstack[blockstack_top++] = addr;
218 in_finally[blockstack_top-1] = 0;
219 break;
220
221 case POP_BLOCK:
222 assert(blockstack_top > 0);
223 setup_op = code[blockstack[blockstack_top-1]];
224 if (setup_op == SETUP_FINALLY) {
225 in_finally[blockstack_top-1] = 1;
226 }
227 else {
228 blockstack_top--;
229 }
230 break;
231
232 case END_FINALLY:
233 /* Ignore END_FINALLYs for SETUP_EXCEPTs - they exist
234 * in the bytecode but don't correspond to an actual
235 * 'finally' block. (If blockstack_top is 0, we must
236 * be seeing such an END_FINALLY.) */
237 if (blockstack_top > 0) {
238 setup_op = code[blockstack[blockstack_top-1]];
239 if (setup_op == SETUP_FINALLY) {
240 blockstack_top--;
241 }
242 }
243 break;
244 }
245
246 /* For the addresses we're interested in, see whether they're
247 * within a 'finally' block and if so, remember the address
248 * of the SETUP_FINALLY. */
249 if (addr == new_lasti || addr == f->f_lasti) {
250 int i = 0;
251 int setup_addr = -1;
252 for (i = blockstack_top-1; i >= 0; i--) {
253 if (in_finally[i]) {
254 setup_addr = blockstack[i];
255 break;
256 }
257 }
258
259 if (setup_addr != -1) {
260 if (addr == new_lasti) {
261 new_lasti_setup_addr = setup_addr;
262 }
263
264 if (addr == f->f_lasti) {
265 f_lasti_setup_addr = setup_addr;
266 }
267 }
268 }
269
270 if (op >= HAVE_ARGUMENT) {
271 addr += 2;
272 }
273 }
274
275 /* Verify that the blockstack tracking code didn't get lost. */
276 assert(blockstack_top == 0);
277
278 /* After all that, are we jumping into / out of a 'finally' block? */
279 if (new_lasti_setup_addr != f_lasti_setup_addr) {
280 PyErr_SetString(PyExc_ValueError,
281 "can't jump into or out of a 'finally' block");
282 return -1;
283 }
284
285
286 /* Police block-jumping (you can't jump into the middle of a block)
287 * and ensure that the blockstack finishes up in a sensible state (by
288 * popping any blocks we're jumping out of). We look at all the
289 * blockstack operations between the current position and the new
290 * one, and keep track of how many blocks we drop out of on the way.
291 * By also keeping track of the lowest blockstack position we see, we
292 * can tell whether the jump goes into any blocks without coming out
293 * again - in that case we raise an exception below. */
294 delta_iblock = 0;
295 for (addr = min_addr; addr < max_addr; addr++) {
296 unsigned char op = code[addr];
297 switch (op) {
298 case SETUP_LOOP:
299 case SETUP_EXCEPT:
300 case SETUP_FINALLY:
301 delta_iblock++;
302 break;
303
304 case POP_BLOCK:
305 delta_iblock--;
306 break;
307 }
308
309 min_delta_iblock = MIN(min_delta_iblock, delta_iblock);
310
311 if (op >= HAVE_ARGUMENT) {
312 addr += 2;
313 }
314 }
315
316 /* Derive the absolute iblock values from the deltas. */
317 min_iblock = f->f_iblock + min_delta_iblock;
318 if (new_lasti > f->f_lasti) {
319 /* Forwards jump. */
320 new_iblock = f->f_iblock + delta_iblock;
321 }
322 else {
323 /* Backwards jump. */
324 new_iblock = f->f_iblock - delta_iblock;
325 }
326
327 /* Are we jumping into a block? */
328 if (new_iblock > min_iblock) {
329 PyErr_SetString(PyExc_ValueError,
330 "can't jump into the middle of a block");
331 return -1;
332 }
333
334 /* Pop any blocks that we're jumping out of. */
335 while (f->f_iblock > new_iblock) {
336 PyTryBlock *b = &f->f_blockstack[--f->f_iblock];
337 while ((f->f_stacktop - f->f_valuestack) > b->b_level) {
338 PyObject *v = (*--f->f_stacktop);
339 Py_DECREF(v);
340 }
341 }
342
343 /* Finally set the new f_lineno and f_lasti and return OK. */
344 f->f_lineno = new_lineno;
345 f->f_lasti = new_lasti;
346 return 0;
347 }
348
349 static PyObject *
350 frame_gettrace(PyFrameObject *f, void *closure)
351 {
352 PyObject* trace = f->f_trace;
353
354 if (trace == NULL)
355 trace = Py_None;
356
357 Py_INCREF(trace);
358
359 return trace;
360 }
361
362 static int
363 frame_settrace(PyFrameObject *f, PyObject* v, void *closure)
364 {
365 PyObject* old_value;
366
367 /* We rely on f_lineno being accurate when f_trace is set. */
368 f->f_lineno = PyFrame_GetLineNumber(f);
369
370 old_value = f->f_trace;
371 Py_XINCREF(v);
372 f->f_trace = v;
373 Py_XDECREF(old_value);
374
375 return 0;
376 }
377
378 static PyObject *
379 frame_getrestricted(PyFrameObject *f, void *closure)
380 {
381 return PyBool_FromLong(PyFrame_IsRestricted(f));
382 }
383
384 static PyGetSetDef frame_getsetlist[] = {
385 {"f_locals", (getter)frame_getlocals, NULL, NULL},
386 {"f_lineno", (getter)frame_getlineno,
387 (setter)frame_setlineno, NULL},
388 {"f_trace", (getter)frame_gettrace, (setter)frame_settrace, NULL},
389 {"f_restricted",(getter)frame_getrestricted,NULL, NULL},
390 {"f_exc_traceback", (getter)frame_get_f_exc_traceback,
391 (setter)frame_set_f_exc_traceback, NULL},
392 {"f_exc_type", (getter)frame_get_f_exc_type,
393 (setter)frame_set_f_exc_type, NULL},
394 {"f_exc_value", (getter)frame_get_f_exc_value,
395 (setter)frame_set_f_exc_value, NULL},
396 {0}
397 };
398
399 /* Stack frames are allocated and deallocated at a considerable rate.
400 In an attempt to improve the speed of function calls, we:
401
402 1. Hold a single "zombie" frame on each code object. This retains
403 the allocated and initialised frame object from an invocation of
404 the code object. The zombie is reanimated the next time we need a
405 frame object for that code object. Doing this saves the malloc/
406 realloc required when using a free_list frame that isn't the
407 correct size. It also saves some field initialisation.
408
409 In zombie mode, no field of PyFrameObject holds a reference, but
410 the following fields are still valid:
411
412 * ob_type, ob_size, f_code, f_valuestack;
413
414 * f_locals, f_trace,
415 f_exc_type, f_exc_value, f_exc_traceback are NULL;
416
417 * f_localsplus does not require re-allocation and
418 the local variables in f_localsplus are NULL.
419
420 2. We also maintain a separate free list of stack frames (just like
421 integers are allocated in a special way -- see intobject.c). When
422 a stack frame is on the free list, only the following members have
423 a meaning:
424 ob_type == &Frametype
425 f_back next item on free list, or NULL
426 f_stacksize size of value stack
427 ob_size size of localsplus
428 Note that the value and block stacks are preserved -- this can save
429 another malloc() call or two (and two free() calls as well!).
430 Also note that, unlike for integers, each frame object is a
431 malloc'ed object in its own right -- it is only the actual calls to
432 malloc() that we are trying to save here, not the administration.
433 After all, while a typical program may make millions of calls, a
434 call depth of more than 20 or 30 is probably already exceptional
435 unless the program contains run-away recursion. I hope.
436
437 Later, PyFrame_MAXFREELIST was added to bound the # of frames saved on
438 free_list. Else programs creating lots of cyclic trash involving
439 frames could provoke free_list into growing without bound.
440 */
441
442 static PyFrameObject *free_list = NULL;
443 static int numfree = 0; /* number of frames currently in free_list */
444 /* max value for numfree */
445 #define PyFrame_MAXFREELIST 200
446
447 static void
448 frame_dealloc(PyFrameObject *f)
449 {
450 PyObject **p, **valuestack;
451 PyCodeObject *co;
452
453 PyObject_GC_UnTrack(f);
454 Py_TRASHCAN_SAFE_BEGIN(f)
455 /* Kill all local variables */
456 valuestack = f->f_valuestack;
457 for (p = f->f_localsplus; p < valuestack; p++)
458 Py_CLEAR(*p);
459
460 /* Free stack */
461 if (f->f_stacktop != NULL) {
462 for (p = valuestack; p < f->f_stacktop; p++)
463 Py_XDECREF(*p);
464 }
465
466 Py_XDECREF(f->f_back);
467 Py_DECREF(f->f_builtins);
468 Py_DECREF(f->f_globals);
469 Py_CLEAR(f->f_locals);
470 Py_CLEAR(f->f_trace);
471 Py_CLEAR(f->f_exc_type);
472 Py_CLEAR(f->f_exc_value);
473 Py_CLEAR(f->f_exc_traceback);
474
475 co = f->f_code;
476 if (co->co_zombieframe == NULL)
477 co->co_zombieframe = f;
478 else if (numfree < PyFrame_MAXFREELIST) {
479 ++numfree;
480 f->f_back = free_list;
481 free_list = f;
482 }
483 else
484 PyObject_GC_Del(f);
485
486 Py_DECREF(co);
487 Py_TRASHCAN_SAFE_END(f)
488 }
489
490 static int
491 frame_traverse(PyFrameObject *f, visitproc visit, void *arg)
492 {
493 PyObject **fastlocals, **p;
494 int i, slots;
495
496 Py_VISIT(f->f_back);
497 Py_VISIT(f->f_code);
498 Py_VISIT(f->f_builtins);
499 Py_VISIT(f->f_globals);
500 Py_VISIT(f->f_locals);
501 Py_VISIT(f->f_trace);
502 Py_VISIT(f->f_exc_type);
503 Py_VISIT(f->f_exc_value);
504 Py_VISIT(f->f_exc_traceback);
505
506 /* locals */
507 slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars) + PyTuple_GET_SIZE(f->f_code->co_freevars);
(emitted by clang-analyzer)TODO: a detailed trace is available in the data model (not yet rendered in this report)
(emitted by clang-analyzer)TODO: a detailed trace is available in the data model (not yet rendered in this report)
508 fastlocals = f->f_localsplus;
509 for (i = slots; --i >= 0; ++fastlocals)
510 Py_VISIT(*fastlocals);
511
512 /* stack */
513 if (f->f_stacktop != NULL) {
514 for (p = f->f_valuestack; p < f->f_stacktop; p++)
515 Py_VISIT(*p);
516 }
517 return 0;
518 }
519
520 static void
521 frame_clear(PyFrameObject *f)
522 {
523 PyObject **fastlocals, **p, **oldtop;
524 int i, slots;
525
526 /* Before anything else, make sure that this frame is clearly marked
527 * as being defunct! Else, e.g., a generator reachable from this
528 * frame may also point to this frame, believe itself to still be
529 * active, and try cleaning up this frame again.
530 */
531 oldtop = f->f_stacktop;
532 f->f_stacktop = NULL;
533
534 Py_CLEAR(f->f_exc_type);
535 Py_CLEAR(f->f_exc_value);
536 Py_CLEAR(f->f_exc_traceback);
537 Py_CLEAR(f->f_trace);
538
539 /* locals */
540 slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars) + PyTuple_GET_SIZE(f->f_code->co_freevars);
541 fastlocals = f->f_localsplus;
542 for (i = slots; --i >= 0; ++fastlocals)
543 Py_CLEAR(*fastlocals);
544
545 /* stack */
546 if (oldtop != NULL) {
547 for (p = f->f_valuestack; p < oldtop; p++)
548 Py_CLEAR(*p);
549 }
550 }
551
552 static PyObject *
553 frame_sizeof(PyFrameObject *f)
554 {
555 Py_ssize_t res, extras, ncells, nfrees;
556
557 ncells = PyTuple_GET_SIZE(f->f_code->co_cellvars);
558 nfrees = PyTuple_GET_SIZE(f->f_code->co_freevars);
559 extras = f->f_code->co_stacksize + f->f_code->co_nlocals +
560 ncells + nfrees;
561 /* subtract one as it is already included in PyFrameObject */
562 res = sizeof(PyFrameObject) + (extras-1) * sizeof(PyObject *);
563
564 return PyInt_FromSsize_t(res);
565 }
566
567 PyDoc_STRVAR(sizeof__doc__,
568 "F.__sizeof__() -> size of F in memory, in bytes");
569
570 static PyMethodDef frame_methods[] = {
571 {"__sizeof__", (PyCFunction)frame_sizeof, METH_NOARGS,
572 sizeof__doc__},
573 {NULL, NULL} /* sentinel */
574 };
575
576 PyTypeObject PyFrame_Type = {
577 PyVarObject_HEAD_INIT(&PyType_Type, 0)
578 "frame",
579 sizeof(PyFrameObject),
580 sizeof(PyObject *),
581 (destructor)frame_dealloc, /* tp_dealloc */
582 0, /* tp_print */
583 0, /* tp_getattr */
584 0, /* tp_setattr */
585 0, /* tp_compare */
586 0, /* tp_repr */
587 0, /* tp_as_number */
588 0, /* tp_as_sequence */
589 0, /* tp_as_mapping */
590 0, /* tp_hash */
591 0, /* tp_call */
592 0, /* tp_str */
593 PyObject_GenericGetAttr, /* tp_getattro */
594 PyObject_GenericSetAttr, /* tp_setattro */
595 0, /* tp_as_buffer */
596 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
597 0, /* tp_doc */
598 (traverseproc)frame_traverse, /* tp_traverse */
599 (inquiry)frame_clear, /* tp_clear */
600 0, /* tp_richcompare */
601 0, /* tp_weaklistoffset */
602 0, /* tp_iter */
603 0, /* tp_iternext */
604 frame_methods, /* tp_methods */
605 frame_memberlist, /* tp_members */
606 frame_getsetlist, /* tp_getset */
607 0, /* tp_base */
608 0, /* tp_dict */
609 };
610
611 static PyObject *builtin_object;
612
613 int _PyFrame_Init()
614 {
615 builtin_object = PyString_InternFromString("__builtins__");
616 if (builtin_object == NULL)
617 return 0;
618 return 1;
619 }
620
621 PyFrameObject *
622 PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals,
623 PyObject *locals)
624 {
625 PyFrameObject *back = tstate->frame;
626 PyFrameObject *f;
627 PyObject *builtins;
628 Py_ssize_t i;
629
630 #ifdef Py_DEBUG
631 if (code == NULL || globals == NULL || !PyDict_Check(globals) ||
632 (locals != NULL && !PyMapping_Check(locals))) {
633 PyErr_BadInternalCall();
634 return NULL;
635 }
636 #endif
637 if (back == NULL || back->f_globals != globals) {
638 builtins = PyDict_GetItem(globals, builtin_object);
639 if (builtins) {
640 if (PyModule_Check(builtins)) {
641 builtins = PyModule_GetDict(builtins);
642 assert(!builtins || PyDict_Check(builtins));
643 }
644 else if (!PyDict_Check(builtins))
645 builtins = NULL;
646 }
647 if (builtins == NULL) {
648 /* No builtins! Make up a minimal one
649 Give them 'None', at least. */
650 builtins = PyDict_New();
651 if (builtins == NULL ||
652 PyDict_SetItemString(
653 builtins, "None", Py_None) < 0)
654 return NULL;
655 }
656 else
657 Py_INCREF(builtins);
658
659 }
660 else {
661 /* If we share the globals, we share the builtins.
662 Save a lookup and a call. */
663 builtins = back->f_builtins;
664 assert(builtins != NULL && PyDict_Check(builtins));
665 Py_INCREF(builtins);
666 }
667 if (code->co_zombieframe != NULL) {
668 f = code->co_zombieframe;
669 code->co_zombieframe = NULL;
670 _Py_NewReference((PyObject *)f);
671 assert(f->f_code == code);
672 }
673 else {
674 Py_ssize_t extras, ncells, nfrees;
675 ncells = PyTuple_GET_SIZE(code->co_cellvars);
676 nfrees = PyTuple_GET_SIZE(code->co_freevars);
677 extras = code->co_stacksize + code->co_nlocals + ncells +
678 nfrees;
679 if (free_list == NULL) {
680 f = PyObject_GC_NewVar(PyFrameObject, &PyFrame_Type,
681 extras);
682 if (f == NULL) {
683 Py_DECREF(builtins);
684 return NULL;
685 }
686 }
687 else {
688 assert(numfree > 0);
689 --numfree;
690 f = free_list;
691 free_list = free_list->f_back;
692 if (Py_SIZE(f) < extras) {
693 f = PyObject_GC_Resize(PyFrameObject, f, extras);
694 if (f == NULL) {
695 Py_DECREF(builtins);
696 return NULL;
697 }
698 }
699 _Py_NewReference((PyObject *)f);
700 }
701
702 f->f_code = code;
703 extras = code->co_nlocals + ncells + nfrees;
704 f->f_valuestack = f->f_localsplus + extras;
705 for (i=0; i<extras; i++)
706 f->f_localsplus[i] = NULL;
707 f->f_locals = NULL;
708 f->f_trace = NULL;
709 f->f_exc_type = f->f_exc_value = f->f_exc_traceback = NULL;
710 }
711 f->f_stacktop = f->f_valuestack;
712 f->f_builtins = builtins;
713 Py_XINCREF(back);
714 f->f_back = back;
715 Py_INCREF(code);
716 Py_INCREF(globals);
717 f->f_globals = globals;
718 /* Most functions have CO_NEWLOCALS and CO_OPTIMIZED set. */
719 if ((code->co_flags & (CO_NEWLOCALS | CO_OPTIMIZED)) ==
720 (CO_NEWLOCALS | CO_OPTIMIZED))
721 ; /* f_locals = NULL; will be set by PyFrame_FastToLocals() */
722 else if (code->co_flags & CO_NEWLOCALS) {
723 locals = PyDict_New();
724 if (locals == NULL) {
725 Py_DECREF(f);
726 return NULL;
727 }
728 f->f_locals = locals;
729 }
730 else {
731 if (locals == NULL)
732 locals = globals;
733 Py_INCREF(locals);
734 f->f_locals = locals;
735 }
736 f->f_tstate = tstate;
737
738 f->f_lasti = -1;
739 f->f_lineno = code->co_firstlineno;
740 f->f_iblock = 0;
741
742 _PyObject_GC_TRACK(f);
743 return f;
744 }
745
746 /* Block management */
747
748 void
749 PyFrame_BlockSetup(PyFrameObject *f, int type, int handler, int level)
750 {
751 PyTryBlock *b;
752 if (f->f_iblock >= CO_MAXBLOCKS)
753 Py_FatalError("XXX block stack overflow");
754 b = &f->f_blockstack[f->f_iblock++];
755 b->b_type = type;
756 b->b_level = level;
757 b->b_handler = handler;
758 }
759
760 PyTryBlock *
761 PyFrame_BlockPop(PyFrameObject *f)
762 {
763 PyTryBlock *b;
764 if (f->f_iblock <= 0)
765 Py_FatalError("XXX block stack underflow");
766 b = &f->f_blockstack[--f->f_iblock];
767 return b;
768 }
769
770 /* Convert between "fast" version of locals and dictionary version.
771
772 map and values are input arguments. map is a tuple of strings.
773 values is an array of PyObject*. At index i, map[i] is the name of
774 the variable with value values[i]. The function copies the first
775 nmap variable from map/values into dict. If values[i] is NULL,
776 the variable is deleted from dict.
777
778 If deref is true, then the values being copied are cell variables
779 and the value is extracted from the cell variable before being put
780 in dict.
781
782 Exceptions raised while modifying the dict are silently ignored,
783 because there is no good way to report them.
784 */
785
786 static void
787 map_to_dict(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values,
788 int deref)
789 {
790 Py_ssize_t j;
791 assert(PyTuple_Check(map));
792 assert(PyDict_Check(dict));
793 assert(PyTuple_Size(map) >= nmap);
794 for (j = nmap; --j >= 0; ) {
795 PyObject *key = PyTuple_GET_ITEM(map, j);
796 PyObject *value = values[j];
797 assert(PyString_Check(key));
798 if (deref) {
799 assert(PyCell_Check(value));
800 value = PyCell_GET(value);
801 }
802 if (value == NULL) {
803 if (PyObject_DelItem(dict, key) != 0)
804 PyErr_Clear();
805 }
806 else {
807 if (PyObject_SetItem(dict, key, value) != 0)
808 PyErr_Clear();
809 }
810 }
811 }
812
813 /* Copy values from the "locals" dict into the fast locals.
814
815 dict is an input argument containing string keys representing
816 variables names and arbitrary PyObject* as values.
817
818 map and values are input arguments. map is a tuple of strings.
819 values is an array of PyObject*. At index i, map[i] is the name of
820 the variable with value values[i]. The function copies the first
821 nmap variable from map/values into dict. If values[i] is NULL,
822 the variable is deleted from dict.
823
824 If deref is true, then the values being copied are cell variables
825 and the value is extracted from the cell variable before being put
826 in dict. If clear is true, then variables in map but not in dict
827 are set to NULL in map; if clear is false, variables missing in
828 dict are ignored.
829
830 Exceptions raised while modifying the dict are silently ignored,
831 because there is no good way to report them.
832 */
833
834 static void
835 dict_to_map(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values,
836 int deref, int clear)
837 {
838 Py_ssize_t j;
839 assert(PyTuple_Check(map));
840 assert(PyDict_Check(dict));
841 assert(PyTuple_Size(map) >= nmap);
842 for (j = nmap; --j >= 0; ) {
843 PyObject *key = PyTuple_GET_ITEM(map, j);
844 PyObject *value = PyObject_GetItem(dict, key);
845 assert(PyString_Check(key));
846 /* We only care about NULLs if clear is true. */
847 if (value == NULL) {
848 PyErr_Clear();
849 if (!clear)
850 continue;
851 }
852 if (deref) {
853 assert(PyCell_Check(values[j]));
854 if (PyCell_GET(values[j]) != value) {
855 if (PyCell_Set(values[j], value) < 0)
856 PyErr_Clear();
857 }
858 } else if (values[j] != value) {
859 Py_XINCREF(value);
860 Py_XDECREF(values[j]);
861 values[j] = value;
862 }
863 Py_XDECREF(value);
864 }
865 }
866
867 void
868 PyFrame_FastToLocals(PyFrameObject *f)
869 {
870 /* Merge fast locals into f->f_locals */
871 PyObject *locals, *map;
872 PyObject **fast;
873 PyObject *error_type, *error_value, *error_traceback;
874 PyCodeObject *co;
875 Py_ssize_t j;
876 int ncells, nfreevars;
877 if (f == NULL)
878 return;
879 locals = f->f_locals;
880 if (locals == NULL) {
881 locals = f->f_locals = PyDict_New();
882 if (locals == NULL) {
883 PyErr_Clear(); /* Can't report it :-( */
884 return;
885 }
886 }
887 co = f->f_code;
888 map = co->co_varnames;
889 if (!PyTuple_Check(map))
890 return;
891 PyErr_Fetch(&error_type, &error_value, &error_traceback);
892 fast = f->f_localsplus;
893 j = PyTuple_GET_SIZE(map);
894 if (j > co->co_nlocals)
895 j = co->co_nlocals;
896 if (co->co_nlocals)
897 map_to_dict(map, j, locals, fast, 0);
898 ncells = PyTuple_GET_SIZE(co->co_cellvars);
899 nfreevars = PyTuple_GET_SIZE(co->co_freevars);
900 if (ncells || nfreevars) {
901 map_to_dict(co->co_cellvars, ncells,
902 locals, fast + co->co_nlocals, 1);
903 /* If the namespace is unoptimized, then one of the
904 following cases applies:
905 1. It does not contain free variables, because it
906 uses import * or is a top-level namespace.
907 2. It is a class namespace.
908 We don't want to accidentally copy free variables
909 into the locals dict used by the class.
910 */
911 if (co->co_flags & CO_OPTIMIZED) {
912 map_to_dict(co->co_freevars, nfreevars,
913 locals, fast + co->co_nlocals + ncells, 1);
914 }
915 }
916 PyErr_Restore(error_type, error_value, error_traceback);
917 }
918
919 void
920 PyFrame_LocalsToFast(PyFrameObject *f, int clear)
921 {
922 /* Merge f->f_locals into fast locals */
923 PyObject *locals, *map;
924 PyObject **fast;
925 PyObject *error_type, *error_value, *error_traceback;
926 PyCodeObject *co;
927 Py_ssize_t j;
928 int ncells, nfreevars;
929 if (f == NULL)
930 return;
931 locals = f->f_locals;
932 co = f->f_code;
933 map = co->co_varnames;
934 if (locals == NULL)
935 return;
936 if (!PyTuple_Check(map))
937 return;
938 PyErr_Fetch(&error_type, &error_value, &error_traceback);
939 fast = f->f_localsplus;
940 j = PyTuple_GET_SIZE(map);
941 if (j > co->co_nlocals)
942 j = co->co_nlocals;
943 if (co->co_nlocals)
944 dict_to_map(co->co_varnames, j, locals, fast, 0, clear);
945 ncells = PyTuple_GET_SIZE(co->co_cellvars);
946 nfreevars = PyTuple_GET_SIZE(co->co_freevars);
947 if (ncells || nfreevars) {
948 dict_to_map(co->co_cellvars, ncells,
949 locals, fast + co->co_nlocals, 1, clear);
950 /* Same test as in PyFrame_FastToLocals() above. */
951 if (co->co_flags & CO_OPTIMIZED) {
952 dict_to_map(co->co_freevars, nfreevars,
953 locals, fast + co->co_nlocals + ncells, 1,
954 clear);
955 }
956 }
957 PyErr_Restore(error_type, error_value, error_traceback);
958 }
959
960 /* Clear out the free list */
961 int
962 PyFrame_ClearFreeList(void)
963 {
964 int freelist_size = numfree;
965
966 while (free_list != NULL) {
967 PyFrameObject *f = free_list;
968 free_list = free_list->f_back;
969 PyObject_GC_Del(f);
970 --numfree;
971 }
972 assert(numfree == 0);
973 return freelist_size;
974 }
975
976 void
977 PyFrame_Fini(void)
978 {
979 (void)PyFrame_ClearFreeList();
980 Py_XDECREF(builtin_object);
981 builtin_object = NULL;
982 }
983
984 /* Print summary info about the state of the optimized allocator */
985 void
986 _PyFrame_DebugMallocStats(FILE *out)
987 {
988 _PyDebugAllocatorStats(out,
989 "free PyFrameObject",
990 numfree, sizeof(PyFrameObject));
991 }