Stack overflow - Revision history

OAbot: Open access bot: url-access updated in citation with #oabot.

2025-05-25T20:17:50Z

Open access bot: url-access updated in citation with #oabot.

← Previous revision		Revision as of 20:17, 25 May 2025
Line 64:		Line 64:
	\|archive-url = https://web.archive.org/web/20070105152327/http://www.schemers.org/Documents/Standards/R5RS/		\|archive-url = https://web.archive.org/web/20070105152327/http://www.schemers.org/Documents/Standards/R5RS/
	\|url-status = live		\|url-status = live
			\|url-access= subscription
	}}</ref>		}}</ref>

	===Very deep recursion===		===Very deep recursion===

Jruderman at 00:07, 27 June 2024

2024-06-27T00:07:43Z

← Previous revision		Revision as of 00:07, 27 June 2024
Line 180:		Line 180:
	On a C implementation with 8 byte [[Double-precision floating-point format\|double-precision floats]], the declared array consumes 8 [[megabytes]] of data; if this is more memory than is available on the stack (as set by thread creation parameters or operating system limits), a stack overflow will occur.		On a C implementation with 8 byte [[Double-precision floating-point format\|double-precision floats]], the declared array consumes 8 [[megabytes]] of data; if this is more memory than is available on the stack (as set by thread creation parameters or operating system limits), a stack overflow will occur.

			===Constrained environment===
	Stack overflows are made worse by anything that reduces the effective stack size of a given program. For example, the same program being run without multiple threads might work fine, but as soon as multi-threading is enabled the program will crash. This is because most programs with threads have less stack space per thread than a program with no threading support. Because kernels are generally multi-threaded, people new to [[Kernel (operating system)\|kernel]] development are usually discouraged from using recursive algorithms or large stack buffers.<ref name="apple1">{{cite web		Stack overflows are made worse by anything that reduces the effective stack size of a given program. For example, the same program being run without multiple threads might work fine, but as soon as multi-threading is enabled the program will crash. This is because most programs with threads have less stack space per thread than a program with no threading support. Because kernels are generally multi-threaded, people new to [[Kernel (operating system)\|kernel]] development are usually discouraged from using recursive algorithms or large stack buffers.<ref name="apple1">{{cite web
	\| publisher= [[Apple Inc]].		\| publisher= [[Apple Inc]].
Line 194:		Line 195:

	*[[Buffer overflow]]		*[[Buffer overflow]]
		⚫	**[[Heap overflow]]
		⚫	**[[Stack buffer overflow]]
	*[[Call stack]]		*[[Call stack]]
⚫	*[[Heap overflow]]
⚫	*[[Stack buffer overflow]]
	*[[Double fault]]		*[[Double fault]]
			*[[Out of memory]]

	==References==		==References==

Soni: Reverted edit by 2600:1006:B163:DAF0:71F0:88BA:E242:921A (talk) to last version by GreenC

2024-05-17T09:46:32Z

Reverted edit by 2600:1006:B163:DAF0:71F0:88BA:E242:921A (talk) to last version by GreenC

← Previous revision		Revision as of 09:46, 17 May 2024
Line 1:		Line 1:
	{{Short description\|Type of software bug}}		{{Short description\|Type of software bug}}
	{{for multi\|the website\|Stack Overflow\|other uses}}		{{for multi\|the website\|Stack Overflow\|other uses}}
	In software, a '''stack overflow''' occurs if the [[call stack]] pointer exceeds the [[Stack (abstract data type)\|stack]] bound. The call stack may consist of a limited amount of [[address space]], often determined at the start of the program. The size of the call stack depends on many factors, including the programming language, machine architecture, multi-threading, and amount of available memory. When a program attempts to use more space than is available on the call stack (that is, when it attempts to access memory beyond the call stack's bounds, which is essentially a [[buffer overflow]]), the stack is said to ''overflow'', typically resulting in a program.		In software, a '''stack overflow''' occurs if the [[call stack]] pointer exceeds the [[Stack (abstract data type)\|stack]] bound. The call stack may consist of a limited amount of [[address space]], often determined at the start of the program. The size of the call stack depends on many factors, including the programming language, machine architecture, multi-threading, and amount of available memory. When a program attempts to use more space than is available on the call stack (that is, when it attempts to access memory beyond the call stack's bounds, which is essentially a [[buffer overflow]]), the stack is said to ''overflow'', typically resulting in a program [[Crash (computing)\|crash]].<ref name="fortran1">{{cite web
			\|last = Burley
			\|first = James Craig
			\|title = Using and Porting GNU Fortran
			\|url = http://sunsite.ualberta.ca/Documentation/Gnu/gcc-2.95.2/html_node/g77_597.html
			\|date = 1991-06-01
			\|url-status = dead
			\|archive-url = https://web.archive.org/web/20120206112619/http://sunsite.ualberta.ca/Documentation/Gnu/gcc-2.95.2/html_node/g77_597.html
			\|archive-date = 2012-02-06
			}}</ref>

	==Causes==		==Causes==

2600:1006:B163:DAF0:71F0:88BA:E242:921A: added content

2024-05-17T09:27:30Z

added content

← Previous revision		Revision as of 09:27, 17 May 2024
Line 1:		Line 1:
	{{Short description\|Type of software bug}}		{{Short description\|Type of software bug}}
	{{for multi\|the website\|Stack Overflow\|other uses}}		{{for multi\|the website\|Stack Overflow\|other uses}}
	In software, a '''stack overflow''' occurs if the [[call stack]] pointer exceeds the [[Stack (abstract data type)\|stack]] bound. The call stack may consist of a limited amount of [[address space]], often determined at the start of the program. The size of the call stack depends on many factors, including the programming language, machine architecture, multi-threading, and amount of available memory. When a program attempts to use more space than is available on the call stack (that is, when it attempts to access memory beyond the call stack's bounds, which is essentially a [[buffer overflow]]), the stack is said to ''overflow'', typically resulting in a program ~~[[Crash (computing)\|crash]]~~.~~<ref name="fortran1">{{cite web~~		In software, a '''stack overflow''' occurs if the [[call stack]] pointer exceeds the [[Stack (abstract data type)\|stack]] bound. The call stack may consist of a limited amount of [[address space]], often determined at the start of the program. The size of the call stack depends on many factors, including the programming language, machine architecture, multi-threading, and amount of available memory. When a program attempts to use more space than is available on the call stack (that is, when it attempts to access memory beyond the call stack's bounds, which is essentially a [[buffer overflow]]), the stack is said to ''overflow'', typically resulting in a program.
	\|last = Burley
	\|first = James Craig
	\|title = Using and Porting GNU Fortran
	\|url = http://sunsite.ualberta.ca/Documentation/Gnu/gcc-2.95.2/html_node/g77_597.html
	\|date = 1991-06-01
	\|url-status = dead
	\|archive-url = https://web.archive.org/web/20120206112619/http://sunsite.ualberta.ca/Documentation/Gnu/gcc-2.95.2/html_node/g77_597.html
	\|archive-date = 2012-02-06
	}}</ref>

	==Causes==		==Causes==

GreenC: /* External links */

2023-08-30T20:34:03Z

External links

← Previous revision		Revision as of 20:34, 30 August 2023
Line 203:		Line 203:

	==External links==		==External links==
	* [http://software.intel.com/en-us/blogs/2010/07/01/the-reasons-why-64-bit-programs-require-more-stack-memory/ The reasons why 64-bit programs require more stack memory] {{webarchive \| url = https://web.archive.org/web/20171104123645/http://software.intel.com/en-us/blogs/2010/07/01/the-reasons-why-64-bit-programs-require-more-stack-memory/ \| date = ~~2022~~ November 4}}		* [http://software.intel.com/en-us/blogs/2010/07/01/the-reasons-why-64-bit-programs-require-more-stack-memory/ The reasons why 64-bit programs require more stack memory] {{webarchive \| url = https://web.archive.org/web/20171104123645/http://software.intel.com/en-us/blogs/2010/07/01/the-reasons-why-64-bit-programs-require-more-stack-memory/ \| date = 4 November 2017}}

	{{Memory management navbox}}		{{Memory management navbox}}

Yello231: Rescuing 5 sources and tagging 0 as dead.) #IABot (v2.0.9.5

2023-06-10T15:15:43Z

Rescuing 5 sources and tagging 0 as dead.) #IABot (v2.0.9.5

← Previous revision		Revision as of 15:15, 10 June 2023
Line 15:		Line 15:
	===Infinite recursion===		===Infinite recursion===
	{{Main\|Infinite recursion}}		{{Main\|Infinite recursion}}
	The most-common cause of stack overflow is excessively deep or infinite recursion, in which a function calls itself so many times that the space needed to store the variables and information associated with each call is more than can fit on the stack.<ref name="segFault">[https://stackoverflow.com/questions/2685413/what-is-the-difference-between-a-segmentation-fault-and-a-stack-overflow/2685434#2685434 What is the difference between a segmentation fault and a stack overflow?] at [[Stack Overflow]]</ref>		The most-common cause of stack overflow is excessively deep or infinite recursion, in which a function calls itself so many times that the space needed to store the variables and information associated with each call is more than can fit on the stack.<ref name="segFault">[https://stackoverflow.com/questions/2685413/what-is-the-difference-between-a-segmentation-fault-and-a-stack-overflow/2685434#2685434 What is the difference between a segmentation fault and a stack overflow?] {{Webarchive\|url=https://web.archive.org/web/20210913132615/https://stackoverflow.com/questions/2685413/what-is-the-difference-between-a-segmentation-fault-and-a-stack-overflow/2685434#2685434 \|date=2021-09-13 }} at [[Stack Overflow]]</ref>

	An example of infinite recursion in [[C (programming language)\|C]].		An example of infinite recursion in [[C (programming language)\|C]].
Line 34:		Line 34:
	}}</ref>		}}</ref>

	Some C compiler options will effectively enable [[tail-call optimization]]; for example, compiling the above simple program using [[GNU Compiler Collection\|gcc]] with <code>-O1</code> will result in a segmentation fault, but not when using <code>-O2</code> or <code>-O3</code>, since these optimization levels imply the <code>-foptimize-sibling-calls</code> compiler option.<ref>{{cite web\|title=Using the GNU Compiler Collection (GCC): Optimize Options\|url=https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html\|access-date=2017-08-20}}</ref> Other languages, such as [[Scheme (programming language)\|Scheme]], require all implementations to include tail-recursion as part of the language standard.<ref>{{cite journal		Some C compiler options will effectively enable [[tail-call optimization]]; for example, compiling the above simple program using [[GNU Compiler Collection\|gcc]] with <code>-O1</code> will result in a segmentation fault, but not when using <code>-O2</code> or <code>-O3</code>, since these optimization levels imply the <code>-foptimize-sibling-calls</code> compiler option.<ref>{{cite web\|title=Using the GNU Compiler Collection (GCC): Optimize Options\|url=https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html\|access-date=2017-08-20\|archive-date=2017-08-20\|archive-url=https://web.archive.org/web/20170820201527/https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html\|url-status=live}}</ref> Other languages, such as [[Scheme (programming language)\|Scheme]], require all implementations to include tail-recursion as part of the language standard.<ref>{{cite journal
	\|author=Richard Kelsey		\|author = Richard Kelsey
	\|date=August 1998		\|date = August 1998
	\|title=Revised<sup>5</sup> Report on the Algorithmic Language Scheme		\|title = Revised<sup>5</sup> Report on the Algorithmic Language Scheme
	\|url=http://www.schemers.org/Documents/Standards/R5RS/		\|url = http://www.schemers.org/Documents/Standards/R5RS/
	\|journal=Higher-Order and Symbolic Computation		\|journal = Higher-Order and Symbolic Computation
	\|volume~~=11~~ ~~\|issue=1~~ ~~\|pages~~=~~7–105~~		\|volume = 11
			\|issue = 1
⚫	\|doi=10.1023/A:1010051815785
			\|pages = 7–105
⚫	\|accessdate=2012-08-09
		⚫	\|doi = 10.1023/A:1010051815785
⚫	\|author2=William Clinger
		⚫	\|accessdate = 2012-08-09
⚫	\|author3=Jonathan Rees
		⚫	\|author2 = William Clinger
⚫	\|display-authors=3
		⚫	\|author3 = Jonathan Rees
	\|last4=Rozas \|first4=G.J.
		⚫	\|display-authors = 3
	\|last5=Adams Iv \|first5=N.I.
			\|last4 = Rozas
	\|last6=Friedman \|first6=D.P.
			\|first4 = G.J.
	\|last7=Kohlbecker \|first7=E.
			\|last5 = Adams Iv
	\|last8=Steele Jr. \|first8=G.L.
			\|first5 = N.I.
	\|last9=Bartley \|first9=D.H.\|s2cid=14069423
			\|last6 = Friedman
⚫	}}</ref>
			\|first6 = D.P.
			\|last7 = Kohlbecker
			\|first7 = E.
			\|last8 = Steele Jr.
			\|first8 = G.L.
			\|last9 = Bartley
			\|first9 = D.H.
			\|s2cid = 14069423
			\|archive-date = 2007-01-05
			\|archive-url = https://web.archive.org/web/20070105152327/http://www.schemers.org/Documents/Standards/R5RS/
			\|url-status = live
		⚫	}}</ref>

	===Very deep recursion===		===Very deep recursion===
Line 149:		Line 161:
	\| first = Howard		\| first = Howard
	\| title = Modern Memory Management, Part 2		\| title = Modern Memory Management, Part 2
	\| url=http://www.onlamp.com/pub/a/onlamp/2005/11/23/memory-management-2.html		\| url = http://www.onlamp.com/pub/a/onlamp/2005/11/23/memory-management-2.html
	\| date = 2005-11-23 ~~}}</ref>~~		\| date = 2005-11-23
			\| access-date = 2007-08-14
			\| archive-date = 2012-09-20
			\| archive-url = https://web.archive.org/web/20120920112622/http://onlamp.com/pub/a/onlamp/2005/11/23/memory-management-2.html
			\| url-status = dead
			}}</ref>

	An example of a very large stack variable in [[C (programming language)\|C]]:		An example of a very large stack variable in [[C (programming language)\|C]]:
Line 165:		Line 182:
	Stack overflows are made worse by anything that reduces the effective stack size of a given program. For example, the same program being run without multiple threads might work fine, but as soon as multi-threading is enabled the program will crash. This is because most programs with threads have less stack space per thread than a program with no threading support. Because kernels are generally multi-threaded, people new to [[Kernel (operating system)\|kernel]] development are usually discouraged from using recursive algorithms or large stack buffers.<ref name="apple1">{{cite web		Stack overflows are made worse by anything that reduces the effective stack size of a given program. For example, the same program being run without multiple threads might work fine, but as soon as multi-threading is enabled the program will crash. This is because most programs with threads have less stack space per thread than a program with no threading support. Because kernels are generally multi-threaded, people new to [[Kernel (operating system)\|kernel]] development are usually discouraged from using recursive algorithms or large stack buffers.<ref name="apple1">{{cite web
	\| publisher= [[Apple Inc]].		\| publisher= [[Apple Inc]].
	\| title = Kernel Programming Guide: Performance and Stability Tips		\| title= Kernel Programming Guide: Performance and Stability Tips
	\| url=https://developer.apple.com/library/mac/documentation/Darwin/Conceptual/KernelProgramming/style/style.html#//apple_ref/doc/uid/TP30000905-CH208-TPXREF111		\| url= https://developer.apple.com/library/mac/documentation/Darwin/Conceptual/KernelProgramming/style/style.html#//apple_ref/doc/uid/TP30000905-CH208-TPXREF111
	\| date = 2014-05-02 ~~}}</ref>~~		\| date= 2014-05-02
			\| access-date= 2014-05-02
			\| archive-date= 2014-05-03
			\| archive-url= https://web.archive.org/web/20140503011953/https://developer.apple.com/library/mac/documentation/Darwin/Conceptual/KernelProgramming/style/style.html#//apple_ref/doc/uid/TP30000905-CH208-TPXREF111
			\| url-status= live
			}}</ref>

	==See also==		==See also==

Bumm13: /* External links */ attempt at fixing date mismatch error in /webarchive/ template

2023-03-10T17:22:05Z

External links: attempt at fixing date mismatch error in /webarchive/ template

← Previous revision		Revision as of 17:22, 10 March 2023
Line 181:		Line 181:

	==External links==		==External links==
	* [http://software.intel.com/en-us/blogs/2010/07/01/the-reasons-why-64-bit-programs-require-more-stack-memory/ The reasons why 64-bit programs require more stack memory] {{webarchive \| url = https://web.archive.org/web/20171104123645/http://software.intel.com/en-us/blogs/2010/07/01/the-reasons-why-64-bit-programs-require-more-stack-memory/ \| date = 2022~~-11-04~~}}		* [http://software.intel.com/en-us/blogs/2010/07/01/the-reasons-why-64-bit-programs-require-more-stack-memory/ The reasons why 64-bit programs require more stack memory] {{webarchive \| url = https://web.archive.org/web/20171104123645/http://software.intel.com/en-us/blogs/2010/07/01/the-reasons-why-64-bit-programs-require-more-stack-memory/ \| date = 2022 November 4}}

	{{Memory management navbox}}		{{Memory management navbox}}

Bumm13: /* Infinite recursion */ spacing/spelling fix

2023-03-10T17:20:42Z

Infinite recursion: spacing/spelling fix

← Previous revision		Revision as of 17:20, 10 March 2023
Line 15:		Line 15:
	===Infinite recursion===		===Infinite recursion===
	{{Main\|Infinite recursion}}		{{Main\|Infinite recursion}}
	The most-common cause of stack overflow is excessively deep or infinite recursion, in which a function calls itself so many times that the space needed to store the variables and information associated with each call is more than can fit on the stack.<ref name="segFault">[https://stackoverflow.com/questions/2685413/what-is-the-difference-between-a-segmentation-fault-and-a-stack-overflow/2685434#2685434 What is the difference between a segmentation fault and a stack overflow?] at [[~~StackOverflow~~]]</ref>		The most-common cause of stack overflow is excessively deep or infinite recursion, in which a function calls itself so many times that the space needed to store the variables and information associated with each call is more than can fit on the stack.<ref name="segFault">[https://stackoverflow.com/questions/2685413/what-is-the-difference-between-a-segmentation-fault-and-a-stack-overflow/2685434#2685434 What is the difference between a segmentation fault and a stack overflow?] at [[Stack Overflow]]</ref>

	An example of infinite recursion in [[C (programming language)\|C]].		An example of infinite recursion in [[C (programming language)\|C]].

Bumm13: /* Very large stack variables */ formatting fix

2023-03-10T17:20:08Z

Very large stack variables: formatting fix

← Previous revision		Revision as of 17:20, 10 March 2023
Line 163:		Line 163:
	On a C implementation with 8 byte [[Double-precision floating-point format\|double-precision floats]], the declared array consumes 8 [[megabytes]] of data; if this is more memory than is available on the stack (as set by thread creation parameters or operating system limits), a stack overflow will occur.		On a C implementation with 8 byte [[Double-precision floating-point format\|double-precision floats]], the declared array consumes 8 [[megabytes]] of data; if this is more memory than is available on the stack (as set by thread creation parameters or operating system limits), a stack overflow will occur.

	Stack overflows are made worse by anything that reduces the effective stack size of a given program. For example, the same program being run without multiple threads might work fine, but as soon as multi-threading is enabled the program will crash. This is because most programs with threads have less stack space per thread than a program with no threading support. Because kernels are generally multi-threaded, people new to [[Kernel (~~computer~~ ~~science~~)\|kernel]] development are usually discouraged from using recursive algorithms or large stack buffers.<ref name="apple1">{{cite web		Stack overflows are made worse by anything that reduces the effective stack size of a given program. For example, the same program being run without multiple threads might work fine, but as soon as multi-threading is enabled the program will crash. This is because most programs with threads have less stack space per thread than a program with no threading support. Because kernels are generally multi-threaded, people new to [[Kernel (operating system)\|kernel]] development are usually discouraged from using recursive algorithms or large stack buffers.<ref name="apple1">{{cite web
	\| publisher= [[Apple Inc]].		\| publisher= [[Apple Inc]].
	\| title = Kernel Programming Guide: Performance and Stability Tips		\| title = Kernel Programming Guide: Performance and Stability Tips

Bender the Bot: /* External links */HTTP to HTTPS for Wayback Machine, replaced: http://web.archive.org/ → https://web.archive.org/

2022-10-28T22:51:16Z

External links: HTTP to HTTPS for Wayback Machine, replaced: http://web.archive.org/ → https://web.archive.org/

← Previous revision		Revision as of 22:51, 28 October 2022
Line 181:		Line 181:

	==External links==		==External links==
	* [http://software.intel.com/en-us/blogs/2010/07/01/the-reasons-why-64-bit-programs-require-more-stack-memory/ The reasons why 64-bit programs require more stack memory] {{webarchive \| url = ~~http~~://web.archive.org/web/20171104123645/http://software.intel.com/en-us/blogs/2010/07/01/the-reasons-why-64-bit-programs-require-more-stack-memory/ \| date = 2022-11-04}}		* [http://software.intel.com/en-us/blogs/2010/07/01/the-reasons-why-64-bit-programs-require-more-stack-memory/ The reasons why 64-bit programs require more stack memory] {{webarchive \| url = https://web.archive.org/web/20171104123645/http://software.intel.com/en-us/blogs/2010/07/01/the-reasons-why-64-bit-programs-require-more-stack-memory/ \| date = 2022-11-04}}

	{{Memory management navbox}}		{{Memory management navbox}}