[ixp1200] Frustration with subroutines...

[Cyrus Hall]

The first solution certainly works, and I used to use it when I only had
a single call point, but now I have need for fairly separated call
points for this given code, and need to get data both in to and out of
the subroutine (a "return value" if you will).  I'm low on code store,
and the subroutine is rather large, so a macro is out of the question.

I gave the second solution a shot, after adding a branch around the code
so it wouldn't execute when included.  IE:

br[after_include#]
#include "file.uc"
after_include#:

However, I continue to get the same errors.  The compiler still
considers the variable initialized in the macro as separate from those
(with the same name) in the subroutine.  IE, "WARNGING: GPR, 'ret_addr',
was referenced, but never assigned to," from within subroutine.   It
would appear that the .local directive is being ignored, although the
compiler does not complain. 

I went back and re-read section 2.2.7 of the Microcode Programmer's
Reference Manual, and it would seem that your suggestion *should*
actually be working.  However, I would guess that uca implements macros
by simple cut-past and substitute, so it's not considered to be part of
the .local declaration.

I also took a look at how the microC complier handles function calls,
only to find that it too uses global registers.  Needless to say, I
don't have many unused registers left either, and I'm trying to avoid
the losing one of them for the entire code space as hard as I can.

Thanks, Cy

On Wed, 2003-08-13 at 15:37, Johnson, Erik J wrote:
> I wouldn't think you would have to make it global, but certainly you
> would have to make the live range through the subroutine (which make
> sense from the functionality you want to achieve).  I am stuck in a
> hotel right now and don't have access to the assembler, but I would
> guess that the following would work
> 
> .local rtn_addr
> 	load_addr[rtn_addr, ret_loc#]
> 	br[sub_func#]
> 	ret_loc#:
> 	//...other code...
> 
> .subroutine
> sub_func#:
> 	//does neat stuff
> 	rtn[rtn_addr]
> .endsub
> .endlocal
> 
> Of course, there are drawbacks to this as well.  The rtn_addr is live
> for the "other code", but perhaps you can re-arrange the code to fix
> this "problem" as follows:
> 
> Some ".h" file
> 
> .local rtn_addr
> #macro my_sub_func[]
> 	load_addr[rtn_addr, ret_loc#]
> 	br[sub_func#]
> 	ret_loc#:
> 
> .subroutine
> sub_func#:
> 	//does neat stuff
> 	rtn[rtn_addr]
> .endsub
> .endlocal
> 
> 
> Some .uc file
> #include "my.h"
> 
> 	my_sub_func[]
> 	// other code
> 
> 
> Wow, now I really wish I had the assembler with me because I probably am
> just fooling myself into thinking this works...
> 
> erik
> 
> ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> Erik J. Johnson
> Intel Research & Development
> erik.j.johnson at intel.com
> NOT SPEAKING FOR INTEL
> ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> 
> 
> -----Original Message-----
> From: Cyrus Hall [mailto:hallcp at cs.colorado.edu] 
> Sent: Wednesday, August 13, 2003 2:07 PM
> To: ixp1200 List
> Subject: [ixp1200] Frustration with subroutines...
> 
> 
> A general question in regards to "passing" registers to branch points. 
> Here is what I would love to be able to do:
> 
> .local rtn_addr
> 	load_addr[rtn_addr, ret_loc#]
> 	br[sub_func#]
> 	ret_loc#:
> .endlocal
> 	//...other code...
> 
> .subroutine
> sub_func#:
> 	//does neat stuff
> 	rtn[rtn_addr]
> .endsub
> 
> IE, I want to declare a variable->register mapping and then be able to
> use that same register in a subroutine.  I've tried fooling around with
> the .subroutine structures assembly with no luck.  Only if rtn_addr is
> live for the entire program does that work.  Is there anyway to control
> live ranges when using subroutines, or will uca force one to waste a
> register by making it global?
> 
> Thanks,
> Cy
>