Only use the stack for variables whose address is actually taken

Author: totalspectrum

Changelog.txt

@@ -4,6 +4,7 @@ Version 7.0.0
 - Added some of the v44 Spin2 builtin methods like byteswap
 - Cleaned up the Spin parser to enable direct access to struct/obj members
 - Fixed long relative branches (tjz, djnz, etc.)
+- Only use the stack for variables whose address is actually taken (thanks to Ada for this!)
 
 Version 6.9.10
 - Fix compilation error when GETWORD is replaced by MOV or MUL

Test/Expect/stest163.pasm

@@ -9,13 +9,9 @@ _main
 	add	sp, #4
 	mov	fp, sp
 	add	sp, #104
-	mov	_var01, fp
-	add	fp, #100
-	wrlong	_var01, fp
-	mov	_var02, #65
-	wrbyte	_var02, _var01
-	rdlong	outa, fp
-	sub	fp, #100
+	mov	_var01, #65
+	wrbyte	_var01, fp
+	mov	outa, fp
 	mov	sp, fp
 	sub	sp, #4
 	rdlong	fp, sp
@@ -33,6 +29,4 @@ stackspace
 	org	COG_BSS_START
 _var01
 	res	1
-_var02
-	res	1
 	fit	496

Test/Expect/stest280.pasm

@@ -9,24 +9,20 @@ _blah1
 	add	sp, #4
 	mov	fp, sp
 	add	sp, #48
-	add	fp, #4
-	wrlong	arg01, fp
-	add	fp, #4
+	mov	_var01, arg01
 	mov	arg01, fp
-	sub	fp, #8
+	add	arg01, #8
 	mov	arg02, #0
 	mov	arg03, #40
 LR__0001
 	wrbyte	arg02, arg01
 	add	arg01, #1
 	djnz	arg03, #LR__0001
-	add	fp, #4
-	rdlong	result1, fp
-	shl	result1, #2
-	add	fp, #4
-	add	result1, fp
-	rdlong	result1, result1
-	sub	fp, #8
+	shl	_var01, #2
+	mov	result1, fp
+	add	result1, #8
+	add	_var01, result1
+	rdlong	result1, _var01
 	mov	sp, fp
 	sub	sp, #4
 	rdlong	fp, sp
@@ -38,42 +34,38 @@ _blah2
 	add	sp, #4
 	mov	fp, sp
 	add	sp, #20
-	add	fp, #4
-	wrlong	arg01, fp
-	add	fp, #4
+	mov	_var01, arg01
 	mov	arg01, fp
-	sub	fp, #8
+	add	arg01, #8
 	mov	arg02, ptr__dat__
 	mov	arg03, #8
 	cmps	arg01, arg02 wc
  if_ae	jmp	#LR__0011
-	mov	_var01, #8
+	mov	_var02, #8
 LR__0010
 	rdbyte	result1, arg02
 	wrbyte	result1, arg01
 	add	arg01, #1
 	add	arg02, #1
-	djnz	_var01, #LR__0010
+	djnz	_var02, #LR__0010
 	jmp	#LR__0014
 LR__0011
 	add	arg01, arg03
 	add	arg02, arg03
-	mov	_var02, arg03 wz
+	mov	_var03, arg03 wz
  if_e	jmp	#LR__0013
 LR__0012
 	sub	arg01, #1
 	sub	arg02, #1
-	rdbyte	_var01, arg02
-	wrbyte	_var01, arg01
-	djnz	_var02, #LR__0012
+	rdbyte	_var02, arg02
+	wrbyte	_var02, arg01
+	djnz	_var03, #LR__0012
 LR__0013
 LR__0014
-	add	fp, #4
-	rdlong	result1, fp
-	add	fp, #4
-	add	result1, fp
-	rdbyte	result1, result1
-	sub	fp, #8
+	mov	result1, fp
+	add	result1, #8
+	add	_var01, result1
+	rdbyte	result1, _var01
 	mov	sp, fp
 	sub	sp, #4
 	rdlong	fp, sp
@@ -100,6 +92,8 @@ _var01
 	res	1
 _var02
 	res	1
+_var03
+	res	1
 arg01
 	res	1
 arg02

backends/asm/outasm.c

@@ -31,8 +31,8 @@
 #define IS_FAST_CALL(f) ( (f == 0) || !FuncData(f) || FuncData(f)->convention == FAST_CALL)
 #define IS_STACK_CALL(f) ( (f != 0) && FuncData(f)->convention == STACK_CALL)
 
-#define ALL_VARS_ON_STACK(f) ( IS_STACK_CALL(f) || f->local_address_taken || f->closure)
-#define ANY_VARS_ON_STACK(f) ( ALL_VARS_ON_STACK(f) || f->stack_local )
+#define ALL_VARS_ON_STACK(f) ( IS_STACK_CALL(f) || f->force_locals_to_stack || (f->local_address_taken && IsSpinLang(f->language) && !(f->optimize_flags & OPT_SPIN_STRICTMEM)) || f->closure)
+#define ANY_VARS_ON_STACK(f) ( ALL_VARS_ON_STACK(f) || f->stack_local || f->local_address_taken )
 
 #define IS_LEAF(func) ((gl_compress == 0) && ((func)->is_leaf || (FuncData(func) && FuncData(func)->effectivelyLeaf)))
 
@@ -299,6 +299,9 @@ PutVarOnStack(Function *func, Symbol *sym, int size)
     if (sym->kind == SYM_LOCALVAR && TypeGoesOnStack((AST *)sym->v.ptr)) {
         return true;
     }
+    if (sym->flags & SYMF_ADDRESSABLE) {
+        return true;
+    }
     return false;
 }
 

cmdline.c

@@ -538,7 +538,7 @@ static FlagTable optflag[] = {
     { "local-reuse", OPT_LOCAL_REUSE},
     { "aggressive-mem", OPT_AGGRESSIVE_MEM},
     { "cold-code", OPT_COLD_CODE},
-    
+    { "spin-strict-memory", OPT_SPIN_STRICTMEM},
     { "experimental", OPT_EXPERIMENTAL },
     { "all", OPT_FLAGS_ALL },
 };

frontends/basic/basiclang.c

@@ -927,12 +927,17 @@ doBasicTransform(AST **astptr, bool transformFuncall)
     {
         doBasicTransform(&ast->left, transformFuncall);
         doBasicTransform(&ast->right, transformFuncall);
-        if (IsLocalVariable(ast->left)) {
+        Symbol *sym;
+        if (IsLocalVariableEx(ast->left, &sym)) {
             curfunc->local_address_taken = 1;
+            if (sym) {
+                sym->flags |= SYMF_ADDRESSABLE;
+            } else {
+                curfunc->force_locals_to_stack = 1; // fallback if we couldn't get a symbol
+            }
         }
         // taking the address of a function may restrict how
         // we can call it (stack vs. register calling)
-        Symbol *sym;
         Function *f = NULL;
         sym = FindCalledFuncSymbol(ast, NULL, 0);
         if (sym && sym->kind == SYM_FUNCTION) {
@@ -997,7 +1002,7 @@ doBasicTransform(AST **astptr, bool transformFuncall)
         doBasicTransform(&ast->right, transformFuncall);
         // keep local variables on stack, so they will be preserved
         // if an exception throws us back here without cleanup
-        curfunc->local_address_taken = 1;
+        curfunc->force_locals_to_stack = 1;
         break;
     case AST_READ:
         doBasicTransform(&ast->left, transformFuncall);

frontends/c/clang.c

@@ -1,6 +1,6 @@
 /*
  * Spin to C/C++ converter
- * Copyright 2011-2023 Total Spectrum Software Inc.
+ * Copyright 2011-2024 Total Spectrum Software Inc.
  * See the file COPYING for terms of use
  *
  * code for C specific features
@@ -66,12 +66,17 @@ doCTransform(AST **astptr, unsigned cflags)
         {
             doCTransform(&ast->left, cflags);
             doCTransform(&ast->right, cflags);
-            if (curfunc && IsLocalVariable(ast->left)) {
+            Symbol *sym;
+            if (curfunc && IsLocalVariableEx(ast->left, &sym)) {
                 curfunc->local_address_taken = 1;
+                if (sym) {
+                    sym->flags |= SYMF_ADDRESSABLE;
+                } else {
+                    curfunc->force_locals_to_stack = 1; // fallback if we couldn't get a symbol
+                }
             }
             // taking the address of a function may restrict how
             // we can call it (stack vs. register calling)
-            Symbol *sym;
             Function *f = NULL;
             sym = FindCalledFuncSymbol(ast, NULL, 0);
             if (sym && sym->kind == SYM_FUNCTION) {
@@ -107,7 +112,7 @@ doCTransform(AST **astptr, unsigned cflags)
         // keep local variables on stack, so they will be preserved
         // if an exception throws us back here without cleanup
         if (curfunc) {
-            curfunc->local_address_taken = 1;
+            curfunc->force_locals_to_stack = 1;
         } else {
             ERROR(ast, "setjmp/longjmp outside of a function");
         }

frontends/common.h

@@ -193,9 +193,10 @@ extern int gl_optimize_flags; /* flags for optimization */
 #define OPT_AGGRESSIVE_MEM      0x00200000  /* aggressive load/store optimization */
 #define OPT_COLD_CODE           0x00400000  /* move cold code to end of function */
 #define OPT_MERGE_DUPLICATES    0x00800000  /* merge duplicate functions */
+#define OPT_SPIN_STRICTMEM      0x01000000  /* strict memory semantics for Spin */
 
 #define OPT_EXPERIMENTAL        0x80000000  /* gate new or experimental optimizations */
-#define OPT_FLAGS_ALL           0xffffffff
+#define OPT_FLAGS_ALL           (0xffffffff & ~OPT_SPIN_STRICTMEM)
 
 #define OPT_ASM_BASIC  (OPT_BASIC_REGS|OPT_BRANCHES|OPT_PEEPHOLE|OPT_CONST_PROPAGATE|OPT_REMOVE_FEATURES|OPT_MAKE_MACROS)
 
@@ -450,6 +451,7 @@ typedef struct funcdef {
     unsigned cog_task:1;     // 1 if function is started in another cog
     unsigned used_as_ptr:1;  // 1 if function's address is taken as a pointer
     unsigned local_address_taken: 1; // 1 if a local variable or parameter has its address taken
+    unsigned force_locals_to_stack: 1; // 1 if function must store all locals on the stack
     unsigned no_inline:1;    // 1 if function cannot be inlined
     unsigned prefer_inline:1; // 1 if function should be inlined more often
     unsigned is_leaf:1;      // 1 if function is a leaf function
@@ -980,6 +982,9 @@ AST *GetComments(void);
 /* is an AST identifier a local variable? */
 bool IsLocalVariable(AST *ast);
 
+/* like IsLocalVariable but looks up symbol too */
+bool IsLocalVariableEx(AST *ast, Symbol **symout);
+
 /* push the current types identifier */
 void PushCurrentTypes(void);
 

frontends/spin/spinlang.c

@@ -13,9 +13,10 @@
 extern AST *ParsePrintStatement(AST *ast); /* in basiclang.c */
 
 bool
-IsLocalVariable(AST *ast) {
+IsLocalVariableEx(AST *ast, Symbol **symout) {
     Symbol *sym;
 
+    if (symout) *symout = NULL;
     if (!ast) return false;
     if (ast->kind == AST_STMTLIST || ast->kind == AST_SEQUENCE) {
         while (ast && ast->right) {
@@ -29,14 +30,15 @@ IsLocalVariable(AST *ast) {
     }
     switch (ast->kind) {
     case AST_CAST:
-        return IsLocalVariable(ast->right);
+        return IsLocalVariableEx(ast->right, symout);
     case AST_IDENTIFIER:
         sym = LookupSymbol(ast->d.string);
         if (!sym) return false;
         switch (sym->kind) {
         case SYM_RESULT:
         case SYM_LOCALVAR:
         case SYM_PARAMETER:
+            if (symout) *symout = sym;
             return true;
         default:
             return false;
@@ -45,7 +47,7 @@ IsLocalVariable(AST *ast) {
     case AST_RANGEREF:
     case AST_METHODREF:
     case AST_ARRAYREF:
-        if (IsLocalVariable(ast->left)) {
+        if (IsLocalVariableEx(ast->left, symout)) {
             // check for pointer dereference, which is not
             // actually going to cause us grief
             if (IsPointerType(ExprType(ast->left))) {
@@ -61,6 +63,11 @@ IsLocalVariable(AST *ast) {
     }
 }
 
+bool
+IsLocalVariable(AST *ast) {
+    return IsLocalVariableEx(ast, NULL);
+}
+
 /*
  * check for a variable having its address taken
  */
@@ -551,7 +558,7 @@ doSpinTransform(AST **astptr, int level, AST *parent)
         // in that you can only set up a catch on a call
         // and can't differentiate a normal return from an abort.
         if (gl_output != OUTPUT_BYTECODE /*|| gl_interp_kind == INTERP_KIND_NUCODE */ ) {
-            curfunc->local_address_taken = 1; // if we do a catch we will want data on stack
+            curfunc->force_locals_to_stack = 1; // if we do a catch we will want data on stack
             AstReportAs(ast, &saveinfo); // any newly created AST nodes should reflect debug info from this one
             *astptr = ast = NewAST(AST_TRYENV,
                                 NewAST(AST_CONDRESULT,
@@ -792,15 +799,25 @@ doSpinTransform(AST **astptr, int level, AST *parent)
         if (ast->left && ast->left->kind != AST_RANGEREF) {
             doSpinTransform(&ast->left, 0, ast);
         }
-        if (IsLocalVariable(ast->left)) {
+        if (IsLocalVariableEx(ast->left, &sym)) {
             curfunc->local_address_taken = 1;
+            if (sym) {
+                sym->flags |= SYMF_ADDRESSABLE;
+            } else {
+                curfunc->force_locals_to_stack = 1;
+            }
         }
         break;
     case AST_ADDROF:
     case AST_ABSADDROF:
         doSpinTransform(&ast->left, 0, ast);
-        if (IsLocalVariable(ast->left)) {
+        if (IsLocalVariableEx(ast->left, &sym)) {
             curfunc->local_address_taken = 1;
+            if (sym) {
+                sym->flags |= SYMF_ADDRESSABLE;
+            } else {
+                curfunc->force_locals_to_stack = 1;
+            }
         }
         break;
     case AST_MEMREF:
@@ -853,6 +870,7 @@ doSpinTransform(AST **astptr, int level, AST *parent)
                         *ast = *NewAST(AST_ARRAYREF, memref, ast->right);
                         if (isLocal) {
                             SetLocalArray(curfunc, sym, NULL);
+                            sym->flags |= SYMF_ADDRESSABLE;
                             curfunc->local_address_taken = 1;
                         }
                         AstReportDone(&saveinfo);

frontends/types.c

@@ -909,8 +909,14 @@ static AST *ScalePointer(AST *type, AST *val)
 // return the address of an array
 AST *ArrayAddress(AST *expr)
 {
-    if (curfunc && IsLocalVariable(expr)) {
+    Symbol *sym;
+    if (curfunc && IsLocalVariableEx(expr, &sym)) {
         curfunc->local_address_taken = 1;
+        if (sym) {
+            sym->flags |= SYMF_ADDRESSABLE;
+        } else {
+            curfunc->force_locals_to_stack = 1; // fallback if we couldn't get a symbol
+        }
     }
     return NewAST(AST_ABSADDROF,
                   NewAST(AST_ARRAYREF, expr, AstInteger(0)),
@@ -1332,9 +1338,15 @@ AST *CoerceAssignTypes(AST *line, int kind, AST **astptr, AST *desttype, AST *sr
             AST *copy = MakeOperatorCall(struct_copy, lptr, rptr, sizeExpr);
             *astptr = copy;
         } else {
+            Symbol *sym;
             *astptr = NewAST(AST_ADDROF, expr, NULL);
-            if (curfunc && IsLocalVariable(expr)) {
+            if (curfunc && IsLocalVariableEx(expr, &sym)) {
                 curfunc->local_address_taken = 1;
+                if (sym) {
+                    sym->flags |= SYMF_ADDRESSABLE;
+                } else {
+                    curfunc->force_locals_to_stack = 1; // fallback if we couldn't get a symbol
+                }
             }
         }
         srctype = NewAST(AST_REFTYPE, srctype, NULL);