don't do implicit return tasks in naked functions

[YashasSamaga]

This commits prevents the compiler from calling destructors and adding the return instructions implicitly in naked functions.

fix for #262

[Y-Less]

Does this still do them in places where return is used explicitly?

[YashasSamaga]

Yes.

#pragma warning disable 203

operator~(Tag:arr[], s) { }

#pragma naked
f(Tag:arg1) {
    #emit CONST.pri 1
	new Tag:loc1;
	{
	    #emit CONST.pri 2
	    new Tag:loc2;
		{
		    #emit CONST.pri 3
			new Tag:loc3;
			#emit CONST.pri 4
		}
		#emit CONST.pri 5
		return;
		#emit CONST.pri 6
	}
	#emit CONST.pri 7
}

#pragma naked
g() {

}

#pragma naked
h(a) for (new i; ; ) {}

normal() {
	new Tag:test;
	{
	    new Tag:test2;
	}
}

main () { f(Tag:5); g(); h(); normal(); }

should produce the following after implementing the suggestions:

CODE 0	; 0
;program exit point
	halt 0

	proc	; operator~(Tag:)
	; line 3
	;$lcl s 10
	;$lcl arr c
	zero.pri
	retn

	proc	; f
	; line 6
	;$lcl arg1 c
	const.pri 1
	; line 8
	break	; 20
	;$lcl loc1 fffffffc
	push.c 0
	;$exp
	const.pri 2
	; line b
	break	; 34
	;$lcl loc2 fffffff8
	push.c 0
	;$exp
	const.pri 3
	; line e
	break	; 48
	;$lcl loc3 fffffff4
	push.c 0
	;$exp
	const.pri 4
	push.pri
	push.c 1
	addr.pri fffffff4
	push.pri
	push.c 8
	call .~40000002	; operator~(Tag:)
	pop.pri
	stack 4
	const.pri 5
	; line 12
	break	; 98
	zero.pri
	push.pri
	push.c 1
	addr.pri fffffff8
	push.pri
	push.c 8
	call .~40000002	; operator~(Tag:)
	push.c 1
	addr.pri fffffffc
	push.pri
	push.c 8
	call .~40000002	; operator~(Tag:)
	push.c 1
	addr.pri c
	push.pri
	push.c 8
	call .~40000002	; operator~(Tag:)
	pop.pri
	stack 8
	retn
	const.pri 6
	const.pri 7

	proc	; g
	; line 19

	proc	; h
	; line 1e
	;$lcl a c
	; line 1e
	break	; 138
	;$lcl i fffffffc
	push.c 0
	;$exp
	jump 2
l.0		; 14c
	; line 1e
	break	; 14c
l.2
	jump 0
l.1		; 158
	stack 4

	proc	; normal
	; line 20
	; line 21
	break	; 164
	;$lcl test fffffffc
	push.c 0
	;$exp
	; line 23
	break	; 170
	;$lcl test2 fffffff8
	push.c 0
	;$exp
	push.pri
	push.c 1
	addr.pri fffffff8
	push.pri
	push.c 8
	call .~40000002	; operator~(Tag:)
	pop.pri
	stack 4
	push.pri
	push.c 1
	addr.pri fffffffc
	push.pri
	push.c 8
	call .~40000002	; operator~(Tag:)
	pop.pri
	stack 4
	zero.pri
	retn

	proc	; main
	; line 27
	; line 27
	break	; 1f0
	push.c 5
	;$par
	push.c 4
	call .f
	;$exp
	; line 27
	break	; 20c
	push.c 0
	call .g
	;$exp
	; line 27
	break	; 220
	push.c 4
	call .h
	;$exp
	; line 27
	break	; 234
	push.c 0
	call .normal
	;$exp
	zero.pri
	retn


STKSIZE 1000

[samphunter]

This looks dangerous. If you forget a return somewhere, you will start executing code of another function. On the other hand, having the implicit return there only costs 8 bytes of memory. I am not sure what the great advantage of this is...

[Y-Less]

If you forget a return somewhere, you will start executing code of another function.

Or to put it another way:

If you get your code wrong, your code will do the wrong thing.

Using things like #pragma naked is taking you out of the standard language limits and telling the compiler "I really know what I'm doing". If you do that then don't know what you're doing, more fool you.

[samphunter]

@Y-Less I would consider myself someone who knows, what they are doing, regarding this stuff. However, I still make mistakes sometimes. And my point is, that I really don't see the advantage.

[YashasSamaga]

@samphunter You have the control. You are essentially telling the compiler that don't add instructions to handle implicit return by marking a function as naked. If you forget to add the return instructions to a naked function, then I think the problem lies on your side as you asked the compiler to not add it and you did not add it.

[samphunter]

@YashasSamaga fair enough. I guess I can always just add explicit return to suppress the warning without using naked.

[Southclaws]

Is this ready to be merged? The justification sounds fine and logical to me.