Prototype model for stack based VM

[00blitz]

I'm implementing processor support for a stack based VM and I'm a bit stuck on how to model where the arguments to a function come from.

Architecture background
There is an invocation stack that pretty much serves as a stack frame. The contents of each entry is shown on the left side (in no fixed order).

• arguments, local vars and static fields have a max size of 255 items
• evaluation_stack has a max size of 1024 which is where operands to instructions are pushed and results are stored
  

What I've got
for code that at a high level looks like this (binary data: 5700017834034057000178119e40)

# entry point
def foo(value: int) -> int:
    return increase(value)

def increase(value: int) -> int:
    return value + 1

I get

As seen there are some issues with the output that have some questions about

1. The INITSLOT instruction has 2 operands that indicate the number of slots to reserve for respectively the number of local variables and the number of arguments.

   I have the following cspec

   <compiler_spec>
       <global>
           <range space="ram"/>
           <range space="evaluation"/>
       </global>
       <stackpointer register="sp" space="ram" growth="negative"/>
       <returnaddress>
   	    <varnode space="stack" offset="0" size="2"/>
       </returnaddress>
       <default_proto>
   	    <prototype name="default" stackshift="0" extrapop="unknown">
   	    <input>
   		    <pentry minsize="1" maxsize="1020" align="4">
   			    <addr space="evaluation" offset="1"/>
   		    </pentry>
   	    </input>
   	    <output></output>
   	    </prototype>
       </default_proto>
   </compiler_spec>
   

   My understanding is that the <input> and <output> tags indicate where the resources are located (e.g. stack/ram and the offsets there in). What I don't seem to see is how to indicate how many of these resources should be taken. I can see <pentry> has properties for min/maxsize in terms of data bytes to consume and an alignment to tell the size per item, but how can I tell there's only n amount of items?

2. what is causing the <UNASSIGNED> <RETURN> warnings?

Either answers or a nudge into the right direction how I can find the answer myself is much appreciated.

slaspec

define endian=little;
define alignment=1;

@define SIZE "4"
define space register type=register_space size=$(SIZE);
define space ram type=ram_space size=$(SIZE) default;
define space evaluation type=ram_space size=$(SIZE);
define register offset=0x0 size=$(SIZE) [pc sp];

define token instr(8)
	opcode = (0,7);

define token operand(8)
	tokeni8 = (0,7) signed
	tokenu8 = (0,7)
	tokenu8_2 = (0,7)
	data1 = (0,7) hex;

rel8: reloc is tokeni8 [ reloc=inst_start + tokeni8;] {
	export *[ram]:$(SIZE) reloc; 
}

macro pushRET(addr) {
	sp = sp - 1;
	*:1 (sp) = addr;
}

macro popRET(addr) {
	x = *:1 sp;
	sp = sp + 1;
}

macro push4(val) {
	sp = sp - 4;
	*[evaluation]:4 sp = val;
}

macro pop4(val) {
	val = *[evaluation]:4 sp;
	sp = sp + 4;
}

:INITSLOT ["localvars:"tokenu8, "args:"tokenu8_2] is opcode=0x57; tokenu8; tokenu8_2 {}
:LDARG0 is opcode=0x78 {}

:CALL [rel8] is opcode=0x34; rel8 {
	local next:$(SIZE) = inst_next;
	pushRET(next);
	call rel8;
}

:RET is opcode=0x40 {
	local tmp:$(SIZE)= 0;
	popRET(tmp);
 	return [tmp];
}

:ADD is opcode=0x9e {
	local _val1:4 = 0;
	local _val2:4 = 0;
	local _val3:4 = 0;
	
	pop4(_val1);
	pop4(_val2);
	_val3 = _val1 + _val2;
	push4(_val3);
}

:PUSH1 is opcode=0x11 {
	local _val1:4 = 1;
	push4(_val1);
}

[konchunas]

From my understanding:

1. Declare every available location and let decompiler figure it out by itself
2. It shows decompiler guess. You have to either Edit function and configure proper return location or right-click "Commit params/return" in decompiler window if you agree with its guess.