445:, which are allowed to access the context of their enclosing routines, i.e., the parameters and local variables within the scope of the outer routines. Such static nesting can repeat (a function declared within a function declared within a function…). The implementation must provide a means by which a called function at any given static nesting level can reference the enclosing frame at each enclosing nesting level. This reference is commonly implemented by a pointer to the frame of the most recently activated instance of the enclosing function, called a "downstack link" or "static link", to distinguish it from the "dynamic link" that refers to the immediate caller (which need not be the static parent function).
684:(as it keeps track of static nesting during dynamic and recursive calls) and provides the routine (as well as any other routines it may invoke) access to the local data of its encapsulating routines at every nesting level. Some architectures, compilers, or optimization cases store one link for each enclosing level (not just the immediately enclosing), so that deeply nested routines that access shallow data do not have to traverse several links; this strategy is often called a "display".
907:
523:
36:
767:
branch to the instruction at the return address. Under many calling conventions, the items popped off the stack by the epilogue include the original argument values, in which case there usually are no further stack manipulations that need to be done by the caller. With some calling conventions, however, it is the caller's responsibility to remove the arguments from the stack after the return.
621:, the value of the stack pointer just before the function was called. Each stack frame contains a stack pointer to the top of the frame immediately below. The stack pointer is a mutable register shared between all invocations. A frame pointer of a given invocation of a function is a copy of the stack pointer as it was before the function was invoked.
866:
In a language with free pointers or non-checked array writes (such as in C), the mixing of control flow data which affects the execution of code (the return addresses or the saved frame pointers) and simple program data (parameters or return values) in a call stack is a security risk, and is possibly
843:
The call stack can sometimes be inspected as the program is running. Depending on how the program is written and compiled, the information on the stack can be used to determine intermediate values and function call traces. This has been used to generate fine-grained automated tests, and in cases like
641:
uses (not shown in the diagram above). The value is saved upon entry to the subroutine. Having such a field in a known location in the stack frame enables code to access each frame successively underneath the currently executing routine's frame, and also allows the routine to easily restore the frame
238:
the return address off the call stack and transfers control to that address. If a called subroutine calls on yet another subroutine, it will push another return address onto the call stack, and so on, with the information stacking up and unstacking as the program dictates. If the pushing consumes all
191:
A call stack is used for several related purposes, but the main reason for having one is to keep track of the point to which each active subroutine should return control when it finishes executing. An active subroutine is one that has been called, but is yet to complete execution, after which control
746:
For instruction set architectures in which the instruction used to call a subroutine puts the return address into a register, rather than pushing it onto the stack, the prologue will commonly save the return address by pushing the value onto the call stack, although if the called subroutine does not
624:
The locations of all other fields in the frame can be defined relative either to the top of the frame, as negative offsets of the stack pointer, or relative to the top of the frame below, as positive offsets of the frame pointer. The location of the frame pointer itself must inherently be defined as
882:
One such attack involves filling one buffer with arbitrary executable code, and then overflowing this or some other buffer to overwrite some return address with a value that points directly to the executable code. As a result, when the function returns, the computer executes that code. This kind of
452:
which is indexed to locate a desired frame. The depth of a routine's lexical nesting is a known constant, so the size of a routine's display is fixed. Also, the number of containing scopes to traverse is known, the index into the display is also fixed. Usually, a routine's display is located in its
396:
will be used to pass the values, but if there are more parameters than can be handled this way, memory space will be needed. The call stack works well as a place for these parameters, especially since each call to a subroutine, which will have differing values for parameters, will be given separate
766:
When a subroutine is ready to return, it executes an epilogue that undoes the steps of the prologue. This will typically restore saved register values (such as the frame pointer value) from the stack frame, pop the entire stack frame off the stack by changing the stack pointer value, and finally
726:
Usually the call stack manipulation needed at the site of a call to a subroutine is minimal (which is good since there can be many call sites for each subroutine to be called). The values for the actual arguments are evaluated at the call site, since they are specific to the particular call, and
704:
For some purposes, the stack frame of a subroutine and that of its caller can be considered to overlap, the overlap consisting of the area where the parameters are passed from the caller to the callee. In some environments, the caller pushes each argument onto the stack, thus extending its stack
581:
A diagram like this can be drawn in either direction as long as the placement of the top, and so direction of stack growth, is understood. Architectures differ as to whether call stacks grow towards higher addresses or towards lower addresses, so the logic of any diagram is not dependent on this
481:
Beside the return address, in some environments there may be other machine or software states that need to be restored when a subroutine returns. This might include things like privilege level, exception-handling information, arithmetic modes, and so on. If needed, this may be stored in the call
795:
statement to transfer control out of a nested function and into a previously invoked outer function. This operation requires the stack to be unwound, removing as many stack frames as necessary to restore the proper context to transfer control to the target statement within the enclosing outer
821:, the stack is (logically) unwound and then rewound with the stack of the continuation. This is not the only way to implement continuations; for example, using multiple, explicit stacks, application of a continuation can simply activate its stack and wind a value to be passed. The
460:
The display entries denoting containing scopes are obtained from the appropriate prefix of the caller's display. An inner routine which recurses creates separate call frames for each invocation. In this case, all of the inner routine's static links point to the same outer routine
851:
Taking regular-time samples of the call stack can be useful in profiling the performance of programs as, if a subroutine's address appears in the call stack sampling data many times, it is likely to act as a code bottleneck and should be inspected for performance problems.
374:, the variables that are known only within the active subroutine and do not retain values after it returns. It is often convenient to allocate space for this use by simply moving the top of the stack by enough to provide the space. This is very fast when compared to
359:
is automatically supported. When a function calls itself recursively, a return address needs to be stored for each activation of the function so that it can later be used to return from the function activation. Stack structures provide this capability automatically.
687:
Access links can be optimized away when an inner function does not access any (non-constant) local data in the encapsulation, as is the case with pure functions communicating only via arguments and return values, for example. Some historical computers, such as the
418:
Operands for arithmetic or logical operations are most often placed into registers and operated on there. However, in some situations the operands may be stacked up to an arbitrary depth, which means something more than registers must be used (this is the case of
585:
The stack frame at the top of the stack is for the currently executing routine, which can access information within its frame (such as parameters or local variables) in any order. The stack frame usually includes at least the following items (in push order):
784:. In this case, the stack frame of a function contains one or more entries specifying exception handlers. When an exception is thrown, the stack is unwound until a handler is found that is prepared to handle (catch) the type of the thrown exception.
750:
If frame pointers are being used, the prologue will typically set the new value of the frame pointer register from the stack pointer. Space on the stack for local variables can then be allocated by incrementally changing the stack pointer.
343:. When a subroutine is called, the location (address) of the instruction at which the calling routine can later resume must be saved somewhere. Using a stack to save the return address has important advantages over some alternative
775:
Returning from the called function will pop the top frame off the stack, perhaps leaving a return value. The more general act of popping one or more frames off the stack to resume execution elsewhere in the program is called
705:
frame, then invokes the callee. In other environments, the caller has a preallocated area at the top of its stack frame to hold the arguments it supplies to other subroutines it calls. This area is sometimes termed the
696:, had special "display registers" to support nested functions, while compilers for most modern machines (such as the ubiquitous x86) simply reserve a few words on the stack for the pointers, as needed.
570:-dependent data structures containing subroutine state information. Each stack frame corresponds to a call to a subroutine which has not yet terminated with a return. For example, if a subroutine named
498:), although any data can be temporarily placed there using special return-stack handling code so long as the needs of calls and returns are respected; parameters are ordinarily stored on a separate
475:, a block within a procedure may have its own local variables, allocated on block entry and freed on block exit. Similarly, the block may have its own exception handlers, deactivated at block exit.
613:
When stack frame sizes can differ, such as between different functions or between invocations of a particular function, popping a frame off the stack does not constitute a fixed decrement of the
392:
be supplied to them by the code which calls them, and it is not uncommon that space for these parameters may be laid out in the call stack. Generally if there are only a few small parameters,
347:, such as saving the return address before the beginning of the called subroutine or in some other fixed location. One is that each task can have its own stack, and thus the subroutine can be
192:
should be handed back to the point of call. Such activations of subroutines may be nested to any level (recursive as a special case), hence the stack structure. For example, if a subroutine
1221:
494:, for example, ordinarily only the return address, counted loop parameters and indexes, and possibly local variables are stored on the call stack (which in that environment is named the
301:, the specifics of the call stack are usually hidden from the programmer. They are given access only to a set of functions, and not the memory on the stack itself. This is an example of
633:
In most systems a stack frame has a field to contain the previous value of the frame pointer register, the value it had while the caller was executing. For example, the stack frame of
895:. Various mitigations have been proposed, such as storing arrays in a completely separate location from the return stack, as is the case in the Forth programming language.
1294:
1257:
510:
stack in Forth terminology even though there is a call stack since it is usually accessed more explicitly. Some Forths also have a third stack for
1208:
747:
call any other routines it may leave the value in the register. Similarly, the current stack pointer and/or frame pointer values may be pushed.
1009:
731:. The actual call instruction, such as "branch and link", is then typically executed to transfer control to the code of the target subroutine.
1101:
363:
Depending on the language, operating system, and machine environment, a call stack may serve additional purposes, including, for example:
1287:
987:
448:
Instead of a static link, the references to the enclosing static frames may be collected into an array of pointers known as a
1280:
1197:
713:. Under this approach, the size of the area is calculated by the compiler to be the largest needed by any called subroutine.
351:, that is, able to be active simultaneously for different tasks doing different things. Another benefit is that by providing
247:. Adding a block's or subroutine's entry to the call stack is sometimes called "winding", and removing entries "unwinding".
1170:
Wilson, P. R.; Johnstone, M. S.; Neely, M.; Boles, D. (1995). "Dynamic storage allocation: A survey and critical review".
100:
309:, on the other hand, require programmers to be involved in manipulating the stack. The actual details of the stack in a
72:
829:
to be executed in specified points on "unwinding" or "rewinding" of the control stack when a continuation is invoked.
1085:
119:
1037:
838:
781:
79:
298:
181:
826:
302:
209:
57:
1254:
946:
822:
434:
334:
17:
86:
1303:
755:
567:
491:
389:
356:
921:
912:
892:
868:
788:
382:. Note that each separate activation of a subroutine gets its own separate space in the stack for locals.
250:
There is usually exactly one call stack associated with a running program (or more accurately, with each
53:
1461:
1408:
743:, since it does the necessary housekeeping before the code for the statements of the routine is begun.
438:
279:
235:
231:
218:
141:
68:
1403:
1372:
375:
255:
1017:
234:, the caller pushes the return address onto the stack, and the called subroutine, when it finishes,
1320:
1210:
MCS-4 Assembly
Language Programming Manual - The INTELLEC 4 Microcomputer System Programming Manual
420:
398:
267:
1180:
1068:
1109:
693:
454:
406:
46:
1050:
490:). In some environments there may be more or fewer functions assigned to the call stack. In the
1377:
1175:
1063:
848:(GDB) implements interactive inspection of the call stack of a running, but paused, C program.
352:
888:
872:
861:
1456:
1387:
977:
936:
310:
672:
activation of the procedure that most closely encapsulates the callee, i.e. the immediate
486:
The typical call stack is used for the return address, locals, and parameters (known as a
176:". Although maintenance of the call stack is important for the proper functioning of most
8:
1352:
1335:
780:
and must be performed when non-local control structures are used, such as those used for
457:
implemented such a display in hardware which supported up to 32 levels of static nesting.
259:
93:
1430:
1418:
1325:
1146:
982:
926:
728:
659:
393:
379:
344:
263:
1435:
1272:
1217:
1193:
1081:
740:
563:
306:
244:
1413:
1185:
1158:
1073:
689:
442:
318:
251:
149:
133:
887:, but similar attacks can succeed even with W^X protection enabled, including the
1261:
941:
876:
727:
either pushed onto the stack or placed into registers, as determined by the used
665:
655:
578:, the top part of the call stack might be laid out like in the adjacent picture.
322:
185:
204:
must know where to return when its execution completes. To accomplish this, the
1423:
1367:
1340:
844:
Ruby and
Smalltalk, to implement first-class continuations. As an example, the
511:
424:
371:
290:
is accessed more explicitly than the call stack and is commonly referred to as
274:). Since there is only one in this important context, it can be referred to as
240:
205:
1450:
1357:
1189:
951:
787:
Some languages have other control structures that require general unwinding.
758:
allows explicit winding of the call stack (called there the "return stack").
348:
1347:
845:
818:
1077:
668:
also have a field in the call frame that points to the stack frame of the
1382:
1362:
956:
807:
1130:
739:
In the called subroutine, the first code executed is usually termed the
427:, is called an evaluation stack, and may occupy space in the call stack.
1241:
1162:
271:
145:
810:
allows control of what happens when the stack is unwound by using the
931:
370:
A subroutine frequently needs memory space for storing the values of
1174:. Lecture Notes in Computer Science. Vol. 986. pp. 1–116.
1058:. 17th International Symposium on Software Reliability Engineering (
906:
522:
35:
1266:
797:
617:. At function return, the stack pointer is instead restored to the
468:
314:
177:
637:
would have a memory location holding the frame pointer value that
222:, is pushed onto the top of the call stack as part of each call.
590:
the arguments (parameter values) passed to the routine (if any);
1244:
implements an internal stack rather than an in-memory stack.)
1237:
1059:
593:
the return address back to the routine's caller (e.g. in the
402:
239:
of the space allocated for the call stack, an error called a
628:
884:
792:
472:
1131:"The Forth Programming Language - Why YOU should learn it"
339:
As noted above, the primary purpose of a call stack is to
1169:
574:
is currently running, having been called by a subroutine
144:
data structure that stores information about the active
1302:
1255:
Function
Calling and Frame Pointer Operations in 68000
1216:(Preliminary ed.). Santa Clara, California, USA:
604:
space for the local variables of the routine (if any).
526:
Call stack layout for upward-growing stacks after the
423:). The stack of such operands, rather like that in an
188:
provide special instructions for manipulating stacks.
902:
1220:. December 1973. pp. 2-7–2-8. MCS-030-1273-1.
180:, the details are normally hidden and automatic in
60:. Unsourced material may be challenged and removed.
278:stack (implicitly "of the task"); however, in the
262:), although additional stacks may be created for
1448:
1052:Call Stack Coverage for GUI Test-Suite Reduction
734:
405:, the list of parameters may also include the
328:
1288:
1048:
397:space on the call stack for those values. In
975:
649:
608:
542:), which is the currently executing routine
1295:
1281:
388:Subroutines often require that values for
152:. This type of stack is also known as an
1179:
1102:"Debugging with GDB: Examining the Stack"
1067:
629:Storing the address to the caller's frame
243:occurs, generally causing the program to
120:Learn how and when to remove this message
1145:
976:Krzyzanowski, Paul (February 16, 2018).
625:a negative offset of the stack pointer.
521:
27:Data structure used in computer programs
806:functions that act as non-local gotos.
721:
230:Since the call stack is organized as a
14:
1449:
1276:
875:, which are the most common type of
761:
482:stack just as the return address is.
172:, and is often shortened to simply "
58:adding citations to reliable sources
29:
1269:- a platform-independent unwind API
664:Programming languages that support
24:
1139:
433:Some programming languages (e.g.,
25:
1473:
1248:
1149:(1960). "Recursive Programming".
1038:Alternative Microprocessor Design
676:of the callee. This is called an
582:addressing choice by convention.
1049:McMaster, S.; Memon, A. (2006).
905:
839:Profiling (computer programming)
299:high-level programming languages
182:high-level programming languages
34:
1227:from the original on 2020-03-01
990:from the original on 2021-08-28
796:function. Similarly, C has the
646:frame, just before it returns.
45:needs additional citations for
1123:
1094:
1042:
1031:
1002:
969:
883:an attack can be blocked with
225:
13:
1:
963:
947:Stack-based memory allocation
832:
597:stack frame, an address into
335:Stack-based memory allocation
1304:Application binary interface
1108:. 1997-10-17. Archived from
1016:. 2003-06-22. Archived from
770:
517:
430:Enclosing subroutine context
200:from four different places,
7:
922:Automatic memory allocation
913:Computer programming portal
898:
893:return-oriented programming
891:or the attacks coming from
855:
823:Scheme programming language
735:Subroutine entry processing
329:Functions of the call stack
10:
1478:
1409:Foreign function interface
859:
836:
756:Forth programming language
699:
653:
492:Forth programming language
341:store the return addresses
332:
280:Forth programming language
1404:Binary-code compatibility
1396:
1373:Position-independent code
1311:
1010:"Understanding the Stack"
650:Lexically nested routines
467:In some languages, e.g.,
453:own stack frame, but the
441:) support declaration of
399:object-oriented languages
376:dynamic memory allocation
1190:10.1007/3-540-60368-9_19
609:Stack and frame pointers
268:cooperative multitasking
707:outgoing arguments area
694:Burroughs large systems
692:and somewhat later the
1062:'06). pp. 33–44.
873:stack buffer overflows
716:
543:
464:Enclosed block context
1267:The libunwind project
1151:Numerische Mathematik
1078:10.1109/ISSRE.2006.19
889:return-to-libc attack
862:Stack buffer overflow
654:Further information:
530:subroutine (shown in
525:
1388:Virtual method table
937:Overhead (computing)
722:Call site processing
321:, and the available
311:programming language
54:improve this article
1353:Memory segmentation
1240:'s 4-bit processor
1106:chemie.fu-berlin.de
741:subroutine prologue
506:, typically called
394:processor registers
345:calling conventions
294:stack (see below).
196:calls a subroutine
1326:Calling convention
1260:2010-07-24 at the
1207:"2.4. The Stack".
1163:10.1007/BF01386232
983:Rutgers University
927:Calling convention
814:special operator.
782:exception handling
729:calling convention
666:nested subroutines
660:Non-local variable
556:activation records
544:
478:Other return state
443:nested subroutines
367:Local data storage
307:assembly languages
1462:Memory management
1444:
1443:
1436:Year 2038 problem
1218:Intel Corporation
1199:978-3-540-60368-9
1172:Memory Management
825:allows arbitrary
762:Return processing
564:machine dependent
560:activation frames
421:register spilling
385:Parameter passing
378:, which uses the
130:
129:
122:
104:
16:(Redirected from
1469:
1414:Language binding
1297:
1290:
1283:
1274:
1273:
1235:
1233:
1232:
1226:
1215:
1203:
1183:
1166:
1134:
1127:
1121:
1120:
1118:
1117:
1098:
1092:
1091:
1071:
1057:
1046:
1040:
1035:
1029:
1028:
1026:
1025:
1006:
1000:
999:
997:
995:
973:
915:
910:
909:
817:When applying a
813:
804:
800:
791:allows a global
690:Electrologica X8
640:
636:
600:
596:
577:
573:
541:
537:
533:
529:
415:Evaluation stack
409:
319:operating system
313:depend upon the
215:
203:
199:
195:
186:instruction sets
184:. Many computer
150:computer program
134:computer science
125:
118:
114:
111:
105:
103:
62:
38:
30:
21:
1477:
1476:
1472:
1471:
1470:
1468:
1467:
1466:
1447:
1446:
1445:
1440:
1392:
1313:
1307:
1301:
1262:Wayback Machine
1251:
1230:
1228:
1224:
1213:
1206:
1200:
1147:Dijkstra, E. W.
1142:
1140:Further reading
1137:
1128:
1124:
1115:
1113:
1100:
1099:
1095:
1088:
1055:
1047:
1043:
1036:
1032:
1023:
1021:
1008:
1007:
1003:
993:
991:
974:
970:
966:
961:
942:Spaghetti stack
911:
904:
901:
877:buffer overflow
864:
858:
841:
835:
811:
802:
798:
778:stack unwinding
773:
764:
737:
724:
719:
702:
662:
656:Nested function
652:
642:pointer to the
638:
634:
631:
611:
598:
594:
575:
571:
550:is composed of
539:
535:
531:
527:
520:
504:parameter stack
455:Burroughs B6500
407:
372:local variables
337:
331:
323:instruction set
288:parameter stack
228:
213:
201:
197:
193:
154:execution stack
126:
115:
109:
106:
63:
61:
51:
39:
28:
23:
22:
15:
12:
11:
5:
1475:
1465:
1464:
1459:
1442:
1441:
1439:
1438:
1433:
1428:
1427:
1426:
1416:
1411:
1406:
1400:
1398:
1397:Related topics
1394:
1393:
1391:
1390:
1385:
1380:
1375:
1370:
1368:Opaque pointer
1365:
1360:
1355:
1350:
1345:
1344:
1343:
1333:
1328:
1323:
1317:
1315:
1309:
1308:
1300:
1299:
1292:
1285:
1277:
1271:
1270:
1264:
1250:
1249:External links
1247:
1246:
1245:
1204:
1198:
1167:
1157:(1): 312–318.
1141:
1138:
1136:
1135:
1122:
1093:
1086:
1041:
1030:
1001:
978:"Stack frames"
967:
965:
962:
960:
959:
954:
949:
944:
939:
934:
929:
924:
918:
917:
916:
900:
897:
860:Main article:
857:
854:
834:
831:
812:unwind-protect
772:
769:
763:
760:
736:
733:
723:
720:
718:
715:
701:
698:
651:
648:
630:
627:
610:
607:
606:
605:
602:
591:
519:
516:
512:floating-point
484:
483:
479:
476:
465:
462:
458:
446:
431:
428:
425:RPN calculator
416:
413:
386:
383:
368:
330:
327:
241:stack overflow
227:
224:
219:return address
212:that jumps to
208:following the
166:run-time stack
128:
127:
110:September 2012
42:
40:
33:
26:
9:
6:
4:
3:
2:
1474:
1463:
1460:
1458:
1455:
1454:
1452:
1437:
1434:
1432:
1429:
1425:
1422:
1421:
1420:
1417:
1415:
1412:
1410:
1407:
1405:
1402:
1401:
1399:
1395:
1389:
1386:
1384:
1381:
1379:
1376:
1374:
1371:
1369:
1366:
1364:
1361:
1359:
1358:Name mangling
1356:
1354:
1351:
1349:
1346:
1342:
1339:
1338:
1337:
1334:
1332:
1329:
1327:
1324:
1322:
1319:
1318:
1316:
1310:
1305:
1298:
1293:
1291:
1286:
1284:
1279:
1278:
1275:
1268:
1265:
1263:
1259:
1256:
1253:
1252:
1243:
1239:
1223:
1219:
1212:
1211:
1205:
1201:
1195:
1191:
1187:
1182:
1181:10.1.1.47.275
1177:
1173:
1168:
1164:
1160:
1156:
1152:
1148:
1144:
1143:
1132:
1126:
1112:on 2021-04-14
1111:
1107:
1103:
1097:
1089:
1087:0-7695-2684-5
1083:
1079:
1075:
1070:
1069:10.1.1.88.873
1065:
1061:
1054:
1053:
1045:
1039:
1034:
1020:on 2013-02-25
1019:
1015:
1011:
1005:
989:
985:
984:
979:
972:
968:
958:
955:
953:
952:Stack machine
950:
948:
945:
943:
940:
938:
935:
933:
930:
928:
925:
923:
920:
919:
914:
908:
903:
896:
894:
890:
886:
880:
878:
874:
870:
863:
853:
849:
847:
840:
830:
828:
824:
820:
815:
809:
805:
794:
790:
785:
783:
779:
768:
759:
757:
752:
748:
744:
742:
732:
730:
714:
712:
708:
697:
695:
691:
685:
683:
679:
675:
671:
667:
661:
657:
647:
645:
626:
622:
620:
619:frame pointer
616:
615:stack pointer
603:
601:'s code); and
592:
589:
588:
587:
583:
579:
569:
565:
562:). These are
561:
557:
554:(also called
553:
549:
524:
515:
513:
509:
505:
501:
497:
493:
489:
480:
477:
474:
470:
466:
463:
459:
456:
451:
447:
444:
440:
436:
432:
429:
426:
422:
417:
414:
411:
404:
400:
395:
391:
387:
384:
381:
377:
373:
369:
366:
365:
364:
361:
358:
354:
350:
346:
342:
336:
326:
324:
320:
316:
312:
308:
304:
300:
295:
293:
289:
285:
281:
277:
273:
269:
265:
261:
257:
253:
248:
246:
242:
237:
236:pulls or pops
233:
223:
221:
220:
211:
207:
189:
187:
183:
179:
175:
171:
170:machine stack
167:
163:
162:control stack
159:
158:program stack
155:
151:
147:
143:
139:
135:
124:
121:
113:
102:
99:
95:
92:
88:
85:
81:
78:
74:
71: –
70:
66:
65:Find sources:
59:
55:
49:
48:
43:This article
41:
37:
32:
31:
19:
18:Frame pointer
1348:Machine code
1330:
1229:. Retrieved
1209:
1171:
1154:
1150:
1129:Doug Hoyte.
1125:
1114:. Retrieved
1110:the original
1105:
1096:
1051:
1044:
1033:
1022:. Retrieved
1018:the original
1013:
1004:
994:December 19,
992:. Retrieved
981:
971:
881:
865:
850:
846:GNU Debugger
842:
819:continuation
816:
786:
777:
774:
765:
753:
749:
745:
738:
725:
711:callout area
710:
706:
703:
686:
681:
677:
673:
669:
663:
643:
632:
623:
618:
614:
612:
584:
580:
559:
555:
552:stack frames
551:
547:
545:
514:parameters.
507:
503:
499:
496:return stack
495:
487:
485:
449:
362:
340:
338:
296:
291:
287:
283:
275:
266:handling or
249:
229:
217:
190:
173:
169:
165:
161:
157:
153:
137:
131:
116:
107:
97:
90:
83:
76:
69:"Call stack"
64:
52:Please help
47:verification
44:
1457:Subroutines
1383:System call
1363:Object code
1314:conventions
957:Stack trace
869:exploitable
808:Common Lisp
682:static link
678:access link
349:thread-safe
303:abstraction
226:Description
210:instruction
146:subroutines
1451:Categories
1378:Relocation
1331:Call stack
1231:2020-03-02
1116:2014-12-16
1024:2014-05-21
1014:cs.umd.edu
964:References
837:See also:
833:Inspection
639:DrawSquare
599:DrawSquare
576:DrawSquare
548:call stack
538:(shown in
528:DrawSquare
500:data stack
488:call frame
390:parameters
380:heap space
353:reentrancy
333:See also:
284:data stack
272:setcontext
194:DrawSquare
138:call stack
80:newspapers
1321:Alignment
1176:CiteSeerX
1064:CiteSeerX
932:Coroutine
771:Unwinding
534:) called
518:Structure
357:recursion
270:(as with
174:the stack
1258:Archived
1222:Archived
988:Archived
899:See also
871:through
856:Security
644:caller's
635:DrawLine
595:DrawLine
572:DrawLine
536:DrawLine
469:ALGOL 60
461:context.
401:such as
315:compiler
214:DrawLine
202:DrawLine
198:DrawLine
178:software
1424:dynamic
1336:Library
803:longjmp
700:Overlap
450:display
410:pointer
305:. Most
260:process
206:address
94:scholar
1431:Loader
1419:Linker
1341:static
1312:Parts,
1196:
1178:
1084:
1066:
827:thunks
799:setjmp
789:Pascal
670:latest
435:Pascal
264:signal
256:thread
216:, the
96:
89:
82:
75:
67:
1306:(ABI)
1238:Intel
1236:(NB.
1225:(PDF)
1214:(PDF)
1060:ISSRE
1056:(PDF)
674:scope
540:green
258:of a
245:crash
232:stack
168:, or
148:of a
142:stack
140:is a
101:JSTOR
87:books
1242:4004
1194:ISBN
1082:ISBN
996:2021
801:and
793:goto
754:The
658:and
566:and
532:blue
473:PL/I
437:and
408:this
282:the
252:task
136:, a
73:news
1186:doi
1159:doi
1074:doi
885:W^X
717:Use
709:or
680:or
568:ABI
558:or
508:the
502:or
439:Ada
403:C++
297:In
292:the
286:or
276:the
254:or
132:In
56:by
1453::
1192:.
1184:.
1153:.
1104:.
1080:.
1072:.
1012:.
986:.
980:.
879:.
546:A
471:,
355:,
325:.
317:,
164:,
160:,
156:,
1296:e
1289:t
1282:v
1234:.
1202:.
1188::
1165:.
1161::
1155:2
1133:.
1119:.
1090:.
1076::
1027:.
998:.
412:.
123:)
117:(
112:)
108:(
98:·
91:·
84:·
77:·
50:.
20:)
Text is available under the Creative Commons Attribution-ShareAlike License. Additional terms may apply.
