Code Generation - Revision history

Root: /* Accessing global (permanent) variables */

2023-06-01T15:16:19Z

Accessing global (permanent) variables

← Older revision		Revision as of 15:16, 1 June 2023
Line 209:		Line 209:
	</source>		</source>

	If ADDR is immediately followed by LDINT, then the two instructions may be replaced by a single one with the same effect: ADDRV. Similarly, ADDR+STINT = ADDRA.		If ADDR is immediately followed by LDINT, then the two instructions may be replaced by a single one with the same effect: ADDRV. Similarly, ADDR+STINT = ADDRA. Note that this, in most cases, will correspond to an optimization and its use by the code generator will be impossible or very limited.

	<source lang="asm">		<source lang="asm">

Root: /* Accessing local variables */

2023-06-01T15:15:52Z

Accessing local variables

← Older revision		Revision as of 15:15, 1 June 2023
Line 246:		Line 246:
	</source>		</source>

	If LOCAL is immediately followed by LDINT, then the two instructions may be replaced by a single one with the same effect: LOCV. Similarly, LOCAL+STINT = LOCA.		If LOCAL is immediately followed by LDINT, then the two instructions may be replaced by a single one with the same effect: LOCV. Similarly, LOCAL+STINT = LOCA. Note that this, in most cases, will correspond to an optimization and its use by the code generator will be impossible or very limited.

	<source lang="asm">		<source lang="asm">

Root: /* Exercises */

2022-06-14T18:01:25Z

Exercises

← Older revision		Revision as of 18:01, 14 June 2022
Line 288:		Line 288:
	* [[Code Generation/Exercise 16\|Exercise 16]] - '''heapSort''', etc.		* [[Code Generation/Exercise 16\|Exercise 16]] - '''heapSort''', etc.
	* [[Code Generation/Exercise 17\|Exercise 17]] - '''find'''		* [[Code Generation/Exercise 17\|Exercise 17]] - '''find'''
			* [[Code Generation/Exercise 18\|Exercise 18]] - fragmentos com variações

	[[category:Compiladores]]		[[category:Compiladores]]
	[[category:Ensino]]		[[category:Ensino]]

Root: /* Cycles */

2022-06-14T12:54:06Z

Cycles

← Older revision		Revision as of 12:54, 14 June 2022
Line 32:		Line 32:
	LABEL condition		LABEL condition
	;; evaluate condition expression		;; evaluate condition expression
	JZ ~~endwhile~~		JZ endcycle
	;; evaluate block		;; evaluate block
	JMP condition		JMP condition
	LABEL ~~endwhile~~		LABEL endcycle
			</source>

			Basic structure of a '''do-while''' cycle:

			<source lang="asm">
			LABEL startcycle
			;; evaluate block
			LABEL condition
			;; evaluate condition expression
			JNZ startcycle
			LABEL endcycle
	</source>		</source>

Root: /* The Postfix Machine */

2022-06-08T15:33:04Z

The Postfix Machine

← Older revision		Revision as of 15:33, 8 June 2022
Line 11:		Line 11:
	== The Postfix Machine ==		== The Postfix Machine ==

	~~SL0 -~~ single ~~stack,~~ large stack, 0 operand ~~machine~~.		The Postfix machine is a stack machine possessing a single large stack and 0-operand instructions (SL0).

	Three special purpose registers: IP (instruction pointer, a.k.a, program counter), for jumps and function calls; FP (frame pointer, a.k.a. base pointer), the basis of the frame pointer for each function; SP (stack pointer), keeps track of the top of the stack.		Three special purpose registers: IP (instruction pointer, a.k.a, program counter), for jumps and function calls; FP (frame pointer, a.k.a. base pointer), the basis of the frame pointer for each function; SP (stack pointer), keeps track of the top of the stack.

Root: /* The Postfix Machine */

2022-06-08T15:31:34Z

The Postfix Machine

← Older revision		Revision as of 15:31, 8 June 2022
Line 19:		Line 19:
	Almost all operations use the stack as input and output (exceptions are instructions for returning values from functions in accordance with CDecl), and instructions that use either immediate arguments or arguments in global memory (i.e., with explicit named addressing).		Almost all operations use the stack as input and output (exceptions are instructions for returning values from functions in accordance with CDecl), and instructions that use either immediate arguments or arguments in global memory (i.e., with explicit named addressing).

	The [[Postfix Reference Guide\|Postfix reference guide]] ~~(a.k.a. Appendix B)~~ contains further details about the Postfix machine and its operations.		The [[Postfix Reference Guide\|Postfix reference guide]] contains further details about the Postfix machine and its operations.

	== Basic Structures (code) ==		== Basic Structures (code) ==

Root: /* Cycles */

2022-06-08T15:30:35Z

Cycles

← Older revision		Revision as of 15:30, 8 June 2022
Line 27:		Line 27:
	=== Cycles ===		=== Cycles ===

	Basic structure of a "while" cycle:		Basic structure of a '''while''' cycle:

	<source lang="asm">		<source lang="asm">
Line 38:		Line 38:
	</source>		</source>

	Basic structure of a C-style "for" cycle:		Basic structure of a C-style '''for''' cycle:

	<source lang="asm">		<source lang="asm">

Root: /* "Break" and "Continue" Instructions */

2022-06-08T15:30:00Z

"Break" and "Continue" Instructions

← Older revision		Revision as of 15:30, 8 June 2022
Line 54:		Line 54:
	=== "Break" and "Continue" Instructions ===		=== "Break" and "Continue" Instructions ===

	The C-style "break" and "continue" instructions must jump, respectively, to the end of the cycle or to its condition (for deciding on whether to execute the next iteration). In the case of "for" cycles, the jump to the condition is not direct, but rather via a jump to the increment label.		The C-style '''break''' and '''continue''' instructions must jump, respectively, to the end of the cycle or to its condition (for deciding on whether to execute the next iteration). In the case of '''for''' cycles, the jump to the condition is not direct, but rather via a jump to the increment label.

	If there are multiple nested cycles, the code generator must keep track of the innermost one, so that it can generate the appropriate jumps. This can be achieved through the use of address stacks (one for '''break''' labels and another for '''continue''' labels).		If there are multiple nested cycles, the code generator must keep track of the innermost one, so that it can generate the appropriate jumps. This can be achieved through the use of address stacks (one for '''break''' labels and another for '''continue''' labels).

Root: /* "Break" and "Continue" Instructions */

2022-06-08T15:29:21Z

"Break" and "Continue" Instructions

← Older revision		Revision as of 15:29, 8 June 2022
Line 56:		Line 56:
	The C-style "break" and "continue" instructions must jump, respectively, to the end of the cycle or to its condition (for deciding on whether to execute the next iteration). In the case of "for" cycles, the jump to the condition is not direct, but rather via a jump to the increment label.		The C-style "break" and "continue" instructions must jump, respectively, to the end of the cycle or to its condition (for deciding on whether to execute the next iteration). In the case of "for" cycles, the jump to the condition is not direct, but rather via a jump to the increment label.

	If there are multiple nested cycles, the code generator must keep track of the innermost one, so that it can generate the appropriate jumps. This can be achieved through the use of address stacks (one for ~~the condition~~ labels and another for ~~increment~~ labels).		If there are multiple nested cycles, the code generator must keep track of the innermost one, so that it can generate the appropriate jumps. This can be achieved through the use of address stacks (one for '''break''' labels and another for '''continue''' labels).

	=== If-Then and If-Then-Else Instructions ===		=== If-Then and If-Then-Else Instructions ===

Root: /* Topics */

2022-06-08T15:27:44Z

Topics

← Older revision		Revision as of 15:27, 8 June 2022
Line 5:		Line 5:
	* Code generation: syntax-directed and based on abstract syntax tree.		* Code generation: syntax-directed and based on abstract syntax tree.

	The approach described here is based on generation from the intermediate representation in the form of a an abstract syntax tree formed by the [[nodes]] created during the parsing process.		The approach described here is based on generation from the intermediate representation in the form of an abstract syntax tree formed by the nodes created during the parsing process.

	The target machine is the Postfix engine described below.		The target machine is the Postfix engine described below.