/*
 * Esercitazioni sulle SysCall in vari linguaggi.
 * Storia di un ottimizzazione.
 *
 * Se si vuole far swappare una sistema quale linux basta giocare
 * con la fork (man 2 fork). Se pero' si vuole lanciare il maggior
 * numero di figli bisogna ottimizzare un po' il codice.
 *
 * Ho preso un programmino relativamente stupido e ho deciso
 * di ridurne la dimensione il + possibile. Sicuramente si puo'
 * ancora fare tanto (a si?),
 * 
 * Prima avevo scritto questo:
 */
#include <unistd.h>
       
int main(void) {
 for(;;) fork();	
}

/* Che a mi dava una roba del tipo: 11288 byte.
 * Lasciamo stare tutte le cose del tipo:
 *
 * for(;;fork()) fork(); o for(fork();fork();fork()) fork();
 * e altri usi impropri del for...
 *
 * Sono poi arrivato a dire questo:
 */

int main(void) {
 asm("
  mov $0x02, %eax
  int $0x80
  jmp .-7
 "); 
}

/* Poco gratificante: 11288 byte. Ho scoperto di pensare
 * come il compilatore, ma niente di +.
 *
 * Ho quindi deciso di abbandonare il C per concepire questo:
 */

BITS 32
GLOBAL _start
_start:
	mov eax,0x02
	int 0x80
	jz _start

; Per chi si fosse perso: 
;    $ nasm -f elf file.asm
;    $ ld file.o
;
; In verita' c'era un passaggio di mezzo in cui usavo la main.
; Cmq questa mi da: 424 byte
; Ma dato che devo sempre appoggiarmi ad un linker per fare
; diventare il mio .o in un ELF, a questo punto ho deciso
; di saltare questo passaggio creando in ASM l'header:

BITS 32
		org	0x08048000
  
ehdr:
		db	0x7F, "ELF", 1, 1, 1
	times 9 db	0
		dw	2
		dw	3
		dd	1 
		dd	_start
		dd	phdr - $$
		dd	0  
		dd	0
		dw	ehdrsize 
		dw	phdrsize 
		dw	1  
		dw	0 
		dw	0  
		dw	0 
  
ehdrsize	equ	$ - ehdr

phdr:    
		dd	1 
		dd	0
		dd	$$  
		dd	$$  
		dd	filesize   
		dd	filesize  
		dd	5 
		dd	0x1000    
  
phdrsize	equ	$ - phdr
  
_start:
		mov eax,2
		int	0x80
		jz	_start

filesize	equ	$ - $$

; Sempre per quelli che si sono persi:
;
;   $ nasm -f elf file.asm
;   $ chmod +x file
;
; Il codice si allunga un po' ma la dimensione no: 93 byte
; Fine inventiva. Altra riduzione non riesco a pensarla.
; 
; EOF