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