Inline Specifier - Revision history

243 user3 at 05:41, 11 January 2023

2023-01-11T05:41:22Z

Proj user8 at 02:08, 15 December 2016

2016-12-15T02:08:00Z

Proj user8: /* Basic Example of the inline Specifier */

2016-12-15T02:06:49Z

‎Basic Example of the inline Specifier

Proj user8: /* Inline Specifier With a Recursive Function */

2016-12-15T02:04:09Z

‎Inline Specifier With a Recursive Function

Proj user8 at 02:01, 15 December 2016

2016-12-15T02:01:22Z

Proj user8: /* Inline Specifier With a Recursive Function */

2016-12-15T02:00:08Z

‎Inline Specifier With a Recursive Function

Proj user8: /* Basic Example of the inline Specifier */

2016-12-15T01:56:58Z

‎Basic Example of the inline Specifier

Proj user8: /* Inline Specifier With a Recursive Function */

2016-12-15T01:56:34Z

‎Inline Specifier With a Recursive Function

Proj user8: /* inline Specifier With a Recursive Function */

2016-12-15T01:40:29Z

‎inline Specifier With a Recursive Function

Proj user8: /* Basic Example of the inline Specifier */

2016-12-15T00:55:00Z

‎Basic Example of the inline Specifier

@@ Line 1: / Line 1: @@
-'''inline''' is a specifier for a function in C/C++ that tells a compiler to replace a function call in assembly with the contents of that function definition. It is most often used when tying to speed up a program as it takes out the overhead of a function call. it is particularly useful with small functions that are called often. However, the specifier will also increase the size of your program as it takes away the benefit of re-usability at the assembly level.
+'''inline''' is a specifier for a function in C/C++ that tells a compiler to replace a function call in assembly with the contents of that function definition. It is most often used when trying to speed up a program as it takes out the overhead of a function call. it is particularly useful with small functions that are called often. However, the specifier will also increase the size of your program as it takes away the benefit of re-usability at the assembly level.
 === Basic Example of the '''Inline''' Specifier ===
-In the following example there are two functions that do the same thing. Except one uses the inline specifier and the other does not. When compiled using compiler optimizations, the function with the inline specifier will not have a function call. Rather, the functions contents will be put directly in the main function of the assembly output. '''Note:''' If compiled without any optimizations '''-O0''', the inline specifier will be ignored.
+In the following example, there are two functions that do the same thing. Except one uses the inline specifier and the other does not. When compiled using compiler optimizations, the function with the inline specifier will not have a function call. Rather, the contents of the function will be put directly in the main function of the assembly output. '''Note:''' If compiled without any optimizations '''-O0''', the inline specifier will be ignored.
 <syntaxhighlight lang="C">
 #include "stdio.h"

← Older revision		Revision as of 02:08, 15 December 2016
Line 1:		Line 1:
−	'''inline''' is a specifier for a function in C/C++ that tells ~~the~~ compiler to replace ~~the~~ function call in assembly with the contents of ~~the~~ function definition. It is most often used when tying to speed up a program as it takes out the overhead of a function call. it is particularly useful with small functions that are called often. However, the specifier will also increase the size of your program as it takes away the benefit of re-usability at the assembly level.	+	'''inline''' is a specifier for a function in C/C++ that tells a compiler to replace a function call in assembly with the contents of that function definition. It is most often used when tying to speed up a program as it takes out the overhead of a function call. it is particularly useful with small functions that are called often. However, the specifier will also increase the size of your program as it takes away the benefit of re-usability at the assembly level.

	=== Basic Example of the '''Inline''' Specifier ===		=== Basic Example of the '''Inline''' Specifier ===

@@ Line 1: / Line 1: @@
 '''inline''' is a specifier for a function in C/C++ that tells the compiler to replace the function call in assembly with the contents of the function definition. It is most often used when tying to speed up a program as it takes out the overhead of a function call. it is particularly useful with small functions that are called often. However, the specifier will also increase the size of your program as it takes away the benefit of re-usability at the assembly level.
-=== Basic Example of the '''inline''' Specifier ===
+=== Basic Example of the '''Inline''' Specifier ===
 In the following example there are two functions that do the same thing. Except one uses the inline specifier and the other does not. When compiled using compiler optimizations, the function with the inline specifier will not have a function call. Rather, the functions contents will be put directly in the main function of the assembly output. '''Note:''' If compiled without any optimizations '''-O0''', the inline specifier will be ignored.
 <syntaxhighlight lang="C">

@@ Line 93: / Line 93: @@
 </syntaxhighlight>
-<syntaxhighlight lang="C">
+<syntaxhighlight lang="NASM">
 Disassembly of section .text:

← Older revision		Revision as of 02:01, 15 December 2016
Line 1:		Line 1:
−	'''inline''' is a specifier for a function in C/C++ that tells the compiler to replace the function call in assembly with the contents of the function. It is most often used when tying to speed up a program as it takes out the overhead of a function call. it is particularly useful with small functions that are called often. However, the specifier will also increase the size of your program as it takes away the benefit of re-usability at the assembly level.	+	'''inline''' is a specifier for a function in C/C++ that tells the compiler to replace the function call in assembly with the contents of the function definition. It is most often used when tying to speed up a program as it takes out the overhead of a function call. it is particularly useful with small functions that are called often. However, the specifier will also increase the size of your program as it takes away the benefit of re-usability at the assembly level.

	=== Basic Example of the '''inline''' Specifier ===		=== Basic Example of the '''inline''' Specifier ===

@@ Line 59: / Line 59: @@
 === Inline Specifier With a Recursive Function ===
-For recursive functions, the inline specifier will attempt to take out as many recursive calls as possible but it cannot get rid of all of them. In the below example, there are two recursive factorial functions, one without the inline specifier and one with. The implementation without the inline specifier, the compiler simply creates a recursive assembly function call. The implementation with the inline specifier, the compiler optimized to use as many registers as it can to more quickly run the factorial calculations. Instead of recursively calling itself each time there is a factorial call, it computes five factorials using four registers and then if needed will call itself again.
+For recursive functions, the inline specifier will attempt to take out as many recursive calls as possible but it cannot get rid of all of them. In the below example, there are two recursive factorial functions, one without the inline specifier and one with. The implementation without the inline specifier, the compiler simply creates a recursive assembly function call. The implementation with the inline specifier, the compiler optimizes to use as many registers as it can to more quickly run the factorial calculations. It computes five factorials using four registers and then if needed will call itself again.  '''Note:''' This is only an example. Different compilers will optimize in different ways and the optimization will vary depending on how aggressive the optimization is.
 The following was created by Linux g++ with an optimization of '''-O1'''.
 <syntaxhighlight lang="C">

← Older revision		Revision as of 01:40, 15 December 2016
Line 58:		Line 58:
	</syntaxhighlight>		</syntaxhighlight>

−	=== ~~'''inline'''~~ Specifier With a Recursive Function ===	+	=== Inline Specifier With a Recursive Function ===
		+	<syntaxhighlight lang="C">
		+	#include "stdio.h"
		+
		+	int factorial_WITHOUT(int a)
		+	{
		+	if(a < 2){
		+	return 1;
		+	}
		+	else
		+	{
		+	return a * factorial_WITHOUT(a-1);
		+	}
		+	}
		+
		+	inline int factorial_WITH(int a)
		+	{
		+	if(a < 2){
		+	return 1;
		+	}
		+	else
		+	{
		+	return a * factorial_WITH(a-1);
		+	}
		+	}
		+	int main(void)
		+	{
		+	printf("%d\n", factorial_WITHOUT(7));
		+	printf("%d\n", factorial_WITH(7));
		+	return 1;
		+	}
		+	</syntaxhighlight>
		+
		+	<syntaxhighlight lang="C">
		+	Disassembly of section .text:
		+
		+	00000000 <factorial_WITHOUT(int)>:
		+	_Z17factorial_WITHOUTi():
		+	0: 53 push %ebx
		+	1: 83 ec 08 sub $0x8,%esp
		+	4: 8b 5c 24 10 mov 0x10(%esp),%ebx
		+	8: b8 01 00 00 00 mov $0x1,%eax
		+	d: 83 fb 01 cmp $0x1,%ebx
		+	10: 7e 12 jle 24 <factorial_WITHOUT(int)+0x24>
		+	12: 83 ec 0c sub $0xc,%esp
		+	15: 8d 43 ff lea -0x1(%ebx),%eax
		+	18: 50 push %eax
		+	19: e8 fc ff ff ff call 1a <factorial_WITHOUT(int)+0x1a> 1a: R_386_PC32 factorial_WITHOUT(int)
		+	1e: 83 c4 10 add $0x10,%esp
		+	21: 0f af c3 imul %ebx,%eax
		+	24: 83 c4 08 add $0x8,%esp
		+	27: 5b pop %ebx
		+	28: c3 ret
		+
		+	00000029 <main>:
		+	main():
		+	29: 8d 4c 24 04 lea 0x4(%esp),%ecx
		+	2d: 83 e4 f0 and $0xfffffff0,%esp
		+	30: ff 71 fc pushl -0x4(%ecx)
		+	33: 55 push %ebp
		+	34: 89 e5 mov %esp,%ebp
		+	36: 51 push %ecx
		+	37: 83 ec 10 sub $0x10,%esp
		+	3a: 6a 07 push $0x7
		+	3c: e8 fc ff ff ff call 3d <main+0x14> 3d: R_386_PC32 factorial_WITHOUT(int)
		+	41: 83 c4 0c add $0xc,%esp
		+	44: 50 push %eax
		+	45: 68 00 00 00 00 push $0x0 46: R_386_32 .rodata.str1.1
		+	4a: 6a 01 push $0x1
		+	4c: e8 fc ff ff ff call 4d <main+0x24> 4d: R_386_PC32 __printf_chk
		+	51: c7 04 24 05 00 00 00 movl $0x5,(%esp)
		+	58: e8 fc ff ff ff call 59 <main+0x30> 59: R_386_PC32 factorial_WITH(int)
		+	5d: 83 c4 0c add $0xc,%esp
		+	60: 8d 04 40 lea (%eax,%eax,2),%eax
		+	63: 6b c0 0e imul $0xe,%eax,%eax
		+	66: 50 push %eax
		+	67: 68 00 00 00 00 push $0x0 68: R_386_32 .rodata.str1.1
		+	6c: 6a 01 push $0x1
		+	6e: e8 fc ff ff ff call 6f <main+0x46> 6f: R_386_PC32 __printf_chk
		+	73: 83 c4 10 add $0x10,%esp
		+	76: b8 01 00 00 00 mov $0x1,%eax
		+	7b: 8b 4d fc mov -0x4(%ebp),%ecx
		+	7e: c9 leave
		+	7f: 8d 61 fc lea -0x4(%ecx),%esp
		+	82: c3 ret
		+
		+	Disassembly of section .text._Z14factorial_WITHi:
		+
		+	00000000 <factorial_WITH(int)>:
		+	_Z14factorial_WITHi():
		+	0: 55 push %ebp
		+	1: 57 push %edi
		+	2: 56 push %esi
		+	3: 53 push %ebx
		+	4: 83 ec 1c sub $0x1c,%esp
		+	7: 8b 5c 24 30 mov 0x30(%esp),%ebx
		+	b: b8 01 00 00 00 mov $0x1,%eax
		+	10: 83 fb 01 cmp $0x1,%ebx
		+	13: 7e 4b jle 60 <factorial_WITH(int)+0x60>
		+	15: 8d 73 ff lea -0x1(%ebx),%esi
		+	18: 83 fe 01 cmp $0x1,%esi
		+	1b: 7e 40 jle 5d <factorial_WITH(int)+0x5d>
		+	1d: 8d 7b fe lea -0x2(%ebx),%edi
		+	20: 83 ff 01 cmp $0x1,%edi
		+	23: 7e 35 jle 5a <factorial_WITH(int)+0x5a>
		+	25: 8d 6b fd lea -0x3(%ebx),%ebp
		+	28: 83 fd 01 cmp $0x1,%ebp
		+	2b: 7e 2a jle 57 <factorial_WITH(int)+0x57>
		+	2d: 8d 43 fc lea -0x4(%ebx),%eax
		+	30: 89 c2 mov %eax,%edx
		+	32: b8 01 00 00 00 mov $0x1,%eax
		+	37: 89 54 24 0c mov %edx,0xc(%esp)
		+	3b: 83 fa 01 cmp $0x1,%edx
		+	3e: 7e 14 jle 54 <factorial_WITH(int)+0x54>
		+	40: 83 ec 0c sub $0xc,%esp
		+	43: 8d 43 fb lea -0x5(%ebx),%eax
		+	46: 50 push %eax
		+	47: e8 fc ff ff ff call 48 <factorial_WITH(int)+0x48> 48: R_386_PC32 factorial_WITH(int)
		+	4c: 83 c4 10 add $0x10,%esp
		+	4f: 0f af 44 24 0c imul 0xc(%esp),%eax
		+	54: 0f af c5 imul %ebp,%eax
		+	57: 0f af c7 imul %edi,%eax
		+	5a: 0f af c6 imul %esi,%eax
		+	5d: 0f af c3 imul %ebx,%eax
		+	60: 83 c4 1c add $0x1c,%esp
		+	63: 5b pop %ebx
		+	64: 5e pop %esi
		+	65: 5f pop %edi
		+	66: 5d pop %ebp
		+	67: c3 ret
		+	</syntaxhighlight>

@@ Line 23: / Line 23: @@
+}
 </syntaxhighlight>
-The following output was compiled with an optimization of '''-O1''
+The following output was compiled with an optimization of '''-O1'''
 <syntaxhighlight lang="NASM">
 00000000 <print_NON_inline()>: