Editing Trampoline (computing)

{{Short description|Programming technique using indirect jumps}}
{{otheruses|Trampoline}}
{{Multiple issues|
{{Lead too short|date=July 2022}}
{{dicdef|date=May 2023}}
{{split|date=February 2023}}
}}
In [[computer programming]], the word '''trampoline''' has a number of meanings, and is generally associated with [[jump instruction]]s (i.e. moving to different code paths).

==Low-level programming==
Trampolines (sometimes referred to as [[indirect jump]] vectors) are memory locations holding addresses pointing to [[interrupt]] service routines, [[I/O]] routines, etc.  Execution jumps into the trampoline and then immediately jumps out, or bounces, hence the term ''trampoline''. They have many uses:

* Trampoline can be used to overcome the limitations imposed by a [[central processing unit]] (CPU) architecture that expects to always find vectors in fixed locations.
* When an [[operating system]] is booted on a [[symmetric multiprocessing]] (SMP) machine, only one processor, the bootstrap processor, will be active. After the operating system has configured itself, it will instruct the other processors to jump to a piece of trampoline code that will initialize the processors and wait for the operating system to start scheduling threads on them.

==High-level programming==
* As used in some [[Lisp (programming language)|Lisp]] implementations, a trampoline is a loop that iteratively invokes [[thunk (functional programming)|thunk]]-returning functions ([[continuation-passing style]]). A single trampoline suffices to express all control transfers of a program; a program so expressed is trampolined, or in ''trampolined style''; converting a program to trampolined style is trampolining.  Programmers can use trampolined functions to implement [[tail-recursive function]] calls in [[stack-oriented programming language]]s.<ref name="Baker_1995"/>
* In [[Java (programming language)|Java]], ''trampoline'' refers to using [[reflection (computer science)|reflection]] to avoid using [[inner class]]es, for example in event listeners. The time overhead of a reflection call is traded for the space overhead of an inner class. Trampolines in Java usually involve the creation of a ''GenericListener'' to pass events to an outer class.<ref name="muller"/>
* In [[Mono_(software)|Mono Runtime]], trampolines are small, hand-written pieces of assembly code used to perform various tasks.<ref>{{cite web |title=Trampolines |url=https://github.com/mono/website/blob/b4f3b7ad0413743e35e9cfe009302e57c1cd0c61/docs/advanced/runtime/docs/trampolines.md |publisher=Mono Project |date=8 October 2022}}</ref>
* When interfacing pieces of code with incompatible [[calling convention]]s, a trampoline is used to convert the caller's convention into the callee's convention.
** In [[embedded system]]s, trampolines are short snippets of code that start up other snippets of code. For example, rather than write interrupt handlers entirely in assembly language, another option is to write interrupt handlers mostly in C, and use a short trampoline to convert the assembly-language interrupt calling convention into the C calling convention.<ref name="Link"/>
** When passing a [[callback (computer science)|callback]] to a system that expects to call a [[C (programming language)|C]] function, but one wants it to execute the method of a particular instance of a class written in [[C++]], one uses a short ''trampoline'' to convert the C function-calling convention to the C++ method-calling convention. One way of writing such a trampoline is to use a [[thunk (object-oriented programming)|thunk]].<ref name="Stangvik"/> Another method is to use a ''generic listener''.<ref name="muller"/>
* In [[Objective-C]], a trampoline is an object returned by a method that captures and [[reification (computer science)|reifies]] all messages sent to it and then "bounces" those messages on to another object, for example in [[higher order message|higher order messaging]].<ref name="Weiher"/>
* In the [[GNU Compiler Collection|GCC]] [[compiler]], trampoline refers to a technique for implementing pointers to [[nested function]]s when <code>-ftrampolines</code> option is enabled.<ref name="Stackoverflow"/> The trampoline is a small piece of code which is constructed on the fly on the stack when the address of a nested function is taken. The trampoline sets up the static link pointer, which allows the nested function to access local variables of the enclosing function. The function pointer is then simply the address of the trampoline. This avoids having to use [[fat pointer|"fat" function pointer]]s for nested functions which carry both the code address and the static link.<ref name="GCC_Trampolines"/><ref name="GCC_Nested"/><ref name="Breuel"/> This, however, conflicts with the desire to make the stack non-executable for security reasons.
* In the [[esoteric programming language]] [[Befunge]], a trampoline is an instruction to skip the next cell in the [[control flow]].

==No-execute stacks==
Some implementations of trampolines cause a loss of [[NX bit|no-execute stacks]] (NX stack). In the [[GNU Compiler Collection]] (GCC) in particular, a [[nested function]] builds a trampoline on the stack at runtime, and then calls the nested function through the data on stack. The trampoline requires the stack to be executable.

No-execute stacks and nested functions are mutually exclusive under GCC. If a nested function is used in the development of a program, then the NX stack is silently lost. GCC offers the <code>-Wtrampolines</code> warning to alert of the condition.

Software engineered using [[software development security|secure development lifecycle]] often do not allow the use of nested functions due to the loss of NX stacks.<ref name="Walton"/>

==See also==
* [[DLL trampolining]]
* [[Retpoline]]

==References==
{{Reflist|refs=
<ref name="Baker_1995">{{cite journal |author-last=Baker |author-first=Henry G. |author-link=Henry Baker (computer scientist) |date=September 1995 |title=CONS Should Not CONS Its Arguments, Part II: Cheney on the M.T.A. |journal=[[ACM SIGPLAN Notices]] |volume=30 |issue=9 |pages=17&ndash;20 |doi=10.1145/214448.214454 |s2cid=20720831 |url=http://home.pipeline.com/~hbaker1/CheneyMTA.html |url-status=dead |archive-url=https://web.archive.org/web/20161111222522/http://home.pipeline.com/~hbaker1/CheneyMTA.html |archive-date=2016-11-11|url-access=subscription }}</ref>
<ref name="Walton">{{cite web |title=C-Based Toolchain Hardening |author-last1=Walton |author-first1=Jeffrey |author-first2=Jim |author-last2=Manico |author-first3=Kevin |author-last3=Wall |date=2018-03-02 |orig-year=2013 |publisher=The Open Web Application Security Project (OWASP) |url=http://www.owasp.org/index.php/C-Based_Toolchain_Hardening#GCC.2FBinutils |access-date=2018-03-02 |url-status=live |archive-url=https://web.archive.org/web/20180527105523/https://www.owasp.org/index.php/C-Based_Toolchain_Hardening |archive-date=2018-05-27}}</ref>
<ref name="muller">{{cite web |title=Asserting Control Over the GUI: Commands, Defaults, and Resource Bundles |author-first=Hans |author-last=Muller |date=2005-01-31 |website=today.java.net |at=Trampolines |url=http://today.java.net/pub/a/today/2005/01/31/controlGUI.html#trampolines |access-date=2015-11-06 }} [https://community.oracle.com/docs/DOC-983126<!-- https://web.archive.org/web/20180527102717/https://community.oracle.com/docs/DOC-983126 -->]</ref>
<ref name="Link">{{cite journal |author-first=Joseph M. |author-last=Link |title=Trampolines for Embedded Systems: Minimizing interrupt handlers latency |date=2001-09-01 |journal=[[Dr. Dobb's Journal]] |url=http://www.drdobbs.com/184404772 |access-date=2018-05-26 |url-status=live |archive-url=https://web.archive.org/web/20180527101123/http://www.drdobbs.com/embedded-systems/trampolines-for-embedded-systems/184404772 |archive-date=2018-05-27}}</ref>
<ref name="Stangvik">{{cite web |title=Thunking in Win32 with C++ |author-first=Einar Otto |author-last=Stangvik |date=2006-08-16 |url=http://www.codeproject.com/Articles/16785/Thunking-in-Win32-Simplifying-Callbacks-to-Non-sta |url-status=dead |archive-url=https://web.archive.org/web/20121015180318/http://www.codeproject.com/Articles/16785/Thunking-in-Win32-Simplifying-Callbacks-to-Non-sta |archive-date=2012-10-15}}</ref>
<ref name="Weiher">{{cite web |title=Higher Order Messaging (HOM) |author-first=Marcel |author-last=Weiher |date=2004 |url=http://www.metaobject.com/papers/HOM-Presentation.pdf |access-date=2018-05-26 |url-status=live |archive-url=https://web.archive.org/web/20180527101632/http://www.metaobject.com/papers/HOM-Presentation.pdf |archive-date=2018-05-27}}</ref>
<ref name="GCC_Trampolines">{{cite web |title=Trampolines for Nested Functions |at=18.11 |date=2018 |orig-year=2002 |work=Using the GNU Compiler Collection (GCC) |url=http://gcc.gnu.org/onlinedocs/gccint/Trampolines.html |access-date=2018-05-26 |url-status=live |archive-url=https://web.archive.org/web/20180527105902/http://gcc.gnu.org/onlinedocs/gccint/Trampolines.html |archive-date=2018-05-27}}</ref>
<ref name="GCC_Nested">{{cite web |title=Nested functions |at=6.4 |date=2018 |orig-year=2002 |work=Using the GNU Compiler Collection (GCC) |url=http://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html |access-date=2018-05-26 |url-status=live |archive-url=https://web.archive.org/web/20180527105902/http://gcc.gnu.org/onlinedocs/gccint/Trampolines.html |archive-date=2018-05-27}}</ref>
<ref name="Breuel">{{cite web |author-first=Thomas M. |author-last=Breuel |title=Lexical Closures for C++ |date=2013 |url=http://www-cs-students.stanford.edu/~blynn/files/lexic.pdf |access-date=2018-05-26 |url-status=live |archive-url=https://web.archive.org/web/20171212030215/http://www-cs-students.stanford.edu/~blynn//files/lexic.pdf |archive-date=2017-12-12}}</ref>
<ref name="Stackoverflow">{{cite web |author=fuz |title=Implementation of nested functions |date=2011-11-18 |work=[[StackOverflow]] |url=https://stackoverflow.com/questions/8179521/implementation-of-nested-functions |access-date=2018-05-26 |url-status=live |archive-url=https://web.archive.org/web/20160329071658/http://stackoverflow.com/questions/8179521/implementation-of-nested-functions |archive-date=2016-03-29}}</ref>
}}

[[Category:Computing terminology]]