World: r3wp

~size of the stack, I'd guess

yep

no size limits, but it's obviously a lot easier to blow the stack 
if you pass around lots of large structs as values

Even for return types? Are they just left on the top of the stack?

that depends :)

as i said, it's a portability mess

small objects are sometimes passed in registers

i.e. if your struct fits in two machine words, some (x86) compilers 
use eax and edx to return it

other compilers rewrite the function to take an additional parameter 
with a pointer to storage used for returning the struct

(this pointer is then sometimes passed via a register, others pass 
it via the stack)

Would that behavior be standardized for a particular calling convention 
and ABI? For instance, that seems like the kind of thing that would 
have been standardized by stdcall or fastcall, but maybe not for 
cdecl or pascal.

afair it's a mess in all of them

for x86

Sorry for all the questions - I haven't needed to write a C compiler 
yet. All the languages I've written compilers for or hand-compiled 
were really specific about this kind of thing.

on amd64, this is mostly fixed

i have a handy reference by agner fog for intel platforms somewhere

If you find the link, please post it :)

but the gist of it: x86 is fscked, x86_64 is much better :)

here we are: http://agner.org/optimize/calling_conventions.pdf

table 6 in section 7.1 on page 19 sums up the mess that is struct 
passing :)

but beware, that is for c++

but we can say, in practice,  that if Red doesn't support struct 
passed as value (or return)... no one is really going to notice. 
  I have never actually seen code in the real-world which does this... 
simply because its very clumsy to do so.

(in this particular case, though, the situation is not much different 
for C)

maxim: yes

Kaj: "I tested the new section headers on Syllable Desktop.

memmap_instance() RO overlap RW (08048000 + 00001000 -> 08048000)"


besides the entry point address being a problem, this could also 
be due to segment alignment, which we basically ignore, at the moment. 
could you try changing "page-size: 4096" to "page-size: 1" and see 
where that gets us?

Judging by the tables, it looks like passing and returning structs 
in C is better done in internal code than in exported functions. 
There are too many exceptions and fallbacks.

I have to set the start address back to the Linux one to be able 
to compile with a changed page size

A page size of 1 works on Linux, but on Syllable the load error is 
still exactly the same

It seems logic! can't be used as a return value (last expression 
of a function) yet

When I use NULL I get a smaller executable than with 0. Is that correct? 
The Windows backend emits four bytes, but the ELF backend says something 
about ignoring NULL

NULL: a bit strange, need to check the sources for that.

logic!: that's odd, see the 'foo function in test-logic.reds (foo: 
func [a [logic!] return: [logic!]][a])

Types aren't checked yet, are they? I currently have the return type 
defined as integer!

Right, not yet. But the return type is checked when the function 
is used in an expression.

So, better get it right.

That doesn't make it work, though

-= Red/System Compiler =- 
Compiling /users/administrator/Red/reply-server.reds ...
*** datatype not allowed
at:  [false]
>>

Strange...will look into that in a few minutes.

The difference may be between a variable and a constant

Have you redefined 'false?

No, I'm not that militant. :-) I do

;#define no			false
#define no			0

where false doesn't work

I can't reproduce your issue here, can you give me a short example 
of a function making the compiler produce that error?

It must be this one:

send: func [  ; Send message.
	socket		[pointer!]
	data		[pointer!]
	size		[integer!]
	flags		[integer!]
	return: 	[logic!]
;	/local		message [pointer!]
][
	either zero? as-message message data size none none [
		either zero? send-message socket message flags [
			zero? end-message message
		][
			end-message message
			no
		]
	][
		no
	]
]

Ok, will try with a similar pattern of code.

Can't reproduce using:

bar: func [a [integer!] b [integer!] return: [logic!]][
	either zero? a [
		either zero? b [
			print "00"
		][
			print "11"
			false
		]
	][
		false
	]
]
either bar 1 1 [print "KO"][print "OK"]
either bar 0 1 [print "KO"][print "OK"]

I'll try that

This test code compiles and works OK.