make @@@ for functions return the address of the first instruction

totalspectrum · totalspectrum · commit d3cadbe048da · 2025-07-22T14:13:21.000-03:00
diff --git a/Changelog.txt b/Changelog.txt
@@ -1,4 +1,6 @@
 Version 7.4.1
+- Made `@@@func` return the address of the first instruction of the
+function func, in both Spin2 and C.
 - Fixed an internal error computing offsets in structures stored in registers
 
 Version 7.4.0
diff --git a/backends/asm/inlineasm.c b/backends/asm/inlineasm.c
@@ -48,6 +48,9 @@ extern void ValidateObjbase(void);
 extern Operand *objbase;
 extern void ValidateHeapptr(void);
 extern Operand *heapptr;
+extern void ValidateMethodTable(void);
+extern Operand *method_table_base;
+
 extern Operand *resultreg[];
 extern Operand *arg1, *arg2;
 
@@ -136,6 +139,11 @@ CompileInlineOperand(IRList *irl, AST *expr, int *effects, int immflag)
                 r = frameptr;
                 r_address = immflag;
             }
+            else if (!strcmp(name, "__methods__")) {
+                ValidateMethodTable();
+                r = method_table_base;
+                r_address = immflag;
+            }
             else if (!strcmp(name, "__heap_ptr")) {
                 ValidateHeapptr();
                 r = heapptr;
diff --git a/backends/asm/outasm.c b/backends/asm/outasm.c
@@ -89,8 +89,8 @@ static Operand *stacktop;  // indirect reference through stackptr
 Operand *frameptr;
 static Operand *linkreg;
 
-static Operand *method_table_base;
-static Operand *method_table_label;
+Operand *method_table_base;
+Operand *method_table_label;
 
 Operand *heapptr;
 static Operand *heaplabel;
@@ -294,7 +294,7 @@ PutVarOnStack(Function *func, Symbol *sym, int size)
     return false;
 }
 
-static void ValidateMethodTable()
+void ValidateMethodTable()
 {
     if (!method_table_base) {
         method_table_label = NewOperand(IMM_HUB_LABEL, "__methodtable__", 0);
diff --git a/backends/becommon.c b/backends/becommon.c
@@ -34,9 +34,10 @@
 #include "becommon.h"
 
 static AST *make_methodptr;
+static AST *get_rawfuncaddr;
 
 AST *
-BuildMethodPointer(AST *ast)
+BuildMethodPointer(AST *ast, bool is_abs)
 {
     Symbol *sym;
     AST *objast;
@@ -78,9 +79,16 @@ BuildMethodPointer(AST *ast)
     if (!make_methodptr) {
         make_methodptr = AstIdentifier("_make_methodptr");
     }
+    if (!get_rawfuncaddr) {
+        get_rawfuncaddr = AstIdentifier("_get_rawfuncaddr");
+    }
     call = NewAST(AST_EXPRLIST, funcaddr, NULL);
     call = NewAST(AST_EXPRLIST, objast, call);
-    result = NewAST(AST_FUNCCALL, make_methodptr, call);
+    if (is_abs) {
+        result = NewAST(AST_FUNCCALL, get_rawfuncaddr, call);
+    } else {
+        result = NewAST(AST_FUNCCALL, make_methodptr, call);
+    }
     // cast the result to the correct function pointer type
     result = NewAST(AST_CAST, funcptrtype, result);
     return result;
diff --git a/backends/becommon.h b/backends/becommon.h
@@ -5,7 +5,7 @@
 #include "symbol.h"
 #include "expr.h"
 
-AST *BuildMethodPointer(AST *ast);
+AST *BuildMethodPointer(AST *ast, bool is_abs);
 void OutputAlignLong(Flexbuf *fb);
 void OutputDataBlob(Flexbuf *fb, Flexbuf *databuf, Flexbuf *relocbuf, const char *startLabel, bool emitLabel);
 
diff --git a/doc/c.md b/doc/c.md
@@ -330,6 +330,10 @@ switch (x) {
 }
 ```
 
+### Absolute address of functions
+
+As discussed in the general documentation, function pointers are complicated objects which are not necessarily the address of the first instruction of the function. In the rare cases where some inline assembly requires access to this information, use the absolute address operator (`@@@`, as in Spin2) to obtain it; that is, `@@@foo` is the address of the first instruction of `foo`. Note that trying to call this directly may produce undefined behavior if the function accesses any member variables, including global variables. See the discussion in the general (language independent) documentation for more details.
+
 ### Statement expressions
 
 A compound statement enclosed in parentheses may appear as an expression. This is a GCC extension which allows loops, switches, and similar features to appear within an expression.
diff --git a/doc/general.md b/doc/general.md
@@ -173,6 +173,14 @@ Some inline assembly blocks may also be marked to be copied to fcache before exe
 
 Loops will be placed in fcache only if (a) they will fit, and (b) they contain no branches to outside the loop (including subroutine calls). The size of the fcache may be set by the `--fcache` flag, but is generally 256 longs on P2 and 32 longs on P1.
 
+### Pointers to functions
+
+All functions are internally represented as object methods; this is true even of top level C and BASIC functions. In order to call a method, both the function address and the address of the object's data are required. This means that method pointers must somehow encode both of these. Different compiler targets do this in different ways, so it does mean that, in general, an expression like `@foo` is *not* the address of the function `foo` in memory. For example, in the default P2 assembly backend a method pointer is 32 bits, with the top 12 bits being an index into the global method table and the bottom 20 being the address of the object data.
+
+This should usually be transparent to the programmer, but in some cases (e.g. for interacting with assembly language) it may be desireable to obtain the address of the function directly. This may be done with the absolute address operator, that is, `@@@foo` will be the location in memory of the first instruction of function `foo`.
+
+Note that calling `@@@foo` directly will produce undefined results if `foo` accesses any member specific data, either directly or indirectly. So getting the absolute address of a function is *not* something you would normally want to do!
+
 ## Interrupt Service Routines
 
 The code generated by FlexSpin is *not* interrupt safe, so it is not possible to run interrupt service routines (ISRs) in the same COG as compiled code. ISRs may, of course, run in COGs that contain only PASM code launched by `coginit`.
diff --git a/doc/spin.md b/doc/spin.md
@@ -477,6 +477,14 @@ The `:2` indicates that fptr is a pointer to a function which returns 2 results.
 
 It is the programmer's responsibility to make sure that the number of results and arguments passed to a method called via a pointer are correct. No type checking is done.
 
+#### Internal representation
+
+In order to call a method, both the function address and the address of the object's data are required. This means that method pointers must somehow encode both of these. Different compiler targets do this in different ways, so it does mean that, in general, an expression like `@foo` is *not* the address of the function `foo` in memory.
+
+This should usually be transparent to the programmer, but in some cases (e.g. for interacting with assembly language) it may be desireable to obtain the address of the function directly. This may be done with the absolute address operator, that is, `@@@foo` will be the location in memory of the first instruction of function `foo`.
+
+Note that calling `foo` directly (e.g. with `CALL(foo)`) will produce undefined results if `foo` accesses any member specific data, either directly or indirectly. So getting the absolute address of a function is *not* something you would normally want to do!
+
 ### Multiple return values and assignments
 
 flexspin allows multiple return values and assignments. For example, to swap two variables `a` and `b` you can write:
diff --git a/frontends/basic/basic.y b/frontends/basic/basic.y
@@ -531,6 +531,7 @@ AdjustParamForByVal(AST *param)
 %token BAS_NE         "<>"
 %token BAS_SHL        "shl"
 %token BAS_SHR        "shr"
+%token BAS_ABSADDR    "@@@"
 
 %token BAS_ADD_ASSIGN "+="
 %token BAS_SUB_ASSIGN "-="
@@ -550,7 +551,7 @@ AdjustParamForByVal(AST *param)
 %left '*' '/' BAS_MOD
 %left BAS_SHL BAS_SHR
 %left BAS_NOT
-%left '@'
+%left '@' BAS_ABSADDR
 %left BAS_NEW
 %left '.'
 %left '('
@@ -1693,6 +1694,8 @@ pseudofunc_expr:
     }
   | '@' unary_expr
     { $$ = NewAST(AST_ADDROF, $2, NULL); }
+  | BAS_ABSADDR unary_expr
+    { $$ = NewAST(AST_ABSADDROF, $2, NULL); }
 ;
 
 unary_expr:
diff --git a/frontends/c/cgram.y b/frontends/c/cgram.y
@@ -1028,6 +1028,7 @@ ConstructDefaultValue(AST *decl, AST *val)
 
 %token C_LIMITMIN_OP "#<"
 %token C_LIMITMAX_OP "#>"
+%token C_ABSADDR_OP  "@@@"
 
 %token C_TYPEDEF "typedef"
 %token C_EXTERN "extern"
@@ -1395,7 +1396,9 @@ unary_expression
 	| unary_operator cast_expression
             {
                 $$ = $1;
-                if ($$->kind == AST_ADDROF || $$->kind == AST_ARRAYREF)
+                if ($$->kind == AST_ADDROF ||
+                    $$->kind == AST_ABSADDROF ||
+                    $$->kind == AST_ARRAYREF)
                     $$->left = $2;
                 else
                     $$->right = $2;
@@ -1411,6 +1414,8 @@ unary_operator
             { $$ = NewAST(AST_ADDROF, NULL, NULL); }
 	| '@'
             { $$ = NewAST(AST_ADDROF, NULL, NULL); }
+	| C_ABSADDR_OP
+            { $$ = NewAST(AST_ABSADDROF, NULL, NULL); }
 	| '*'
             { $$ = NewAST(AST_ARRAYREF, NULL, AstInteger(0)); }
 	| '+'
diff --git a/frontends/lexer.c b/frontends/lexer.c
@@ -4728,6 +4728,13 @@ getBasicToken(LexStream *L, AST **ast_ptr)
         } else {
             lexungetc(L, c2);
         }
+    } else if (c == '@') {
+        int c2 = lexgetc(L);
+        if (c2 == '@' && lexpeekc(L) == '@') {
+            c = BAS_ABSADDR;
+        } else {
+            lexungetc(L, c2);
+        }
     } else if (lexpeekc(L) == '=' && strchr("+-*/", c) != 0) {
         (void)lexgetc(L); // get the =
         switch (c) {
@@ -5151,6 +5158,14 @@ getCToken(LexStream *L, AST **ast_ptr)
         } else {
             lexungetc(L, c2);
         }
+    } else if (c == '@') {
+        c2 = lexgetc(L);
+        if (c2 == '@' && lexpeekc(L) == '@') {
+            c2 = lexgetc(L);
+            c = C_ABSADDR_OP;
+        } else {
+            lexungetc(L, c2);
+        }
     } else if (c == '|') {
         c2 = lexgetc(L);
         if (c2 == '=') {
diff --git a/frontends/spin/spinlang.c b/frontends/spin/spinlang.c
@@ -262,8 +262,8 @@ SetLocalArray(Function *fdef, Symbol *sym, AST *body)
  * scan a function body for various special conditions
  * "expectType" marks a parameter type that is expected
  */
-extern AST *FunctionAddress(AST *); // in types.c
-extern AST *BuildMethodPointer(AST *); // in becommon.c
+extern AST *FunctionAddress(AST *, bool is_abs); // in types.c
+extern AST *BuildMethodPointer(AST *, bool is_abs); // in becommon.c
 
 static void
 ScanFunctionBody(Function *fdef, AST *body, AST *upper, AST *expectType)
@@ -329,7 +329,7 @@ ScanFunctionBody(Function *fdef, AST *body, AST *upper, AST *expectType)
                     }
                 } else if (sym && sym->kind == SYM_FUNCTION) {
                     // insert an explicit function address
-                    AST *getaddr = FunctionAddress(body->left);
+                    AST *getaddr = FunctionAddress(body->left, body->kind == AST_ABSADDROF);
                     fdef->is_leaf = 0;
                     if (upper->right == body) {
                         upper->right = getaddr;
@@ -360,7 +360,7 @@ ScanFunctionBody(Function *fdef, AST *body, AST *upper, AST *expectType)
             // fix up @foo.bar
             AST *typ = ExprType(ast);
             if (IsFunctionType(typ)) {
-                AST *getaddr = BuildMethodPointer(body);
+                AST *getaddr = BuildMethodPointer(body, body->kind == AST_ABSADDROF);
                 fdef->is_leaf = 0;
                 if (upper->right == body) {
                     upper->right = getaddr;
diff --git a/frontends/types.c b/frontends/types.c
@@ -938,18 +938,18 @@ AST *StructAddress(AST *expr)
 }
 
 // return the address of a function
-AST *FunctionAddress(AST *expr)
+AST *FunctionAddress(AST *expr, bool is_abs)
 {
     if (expr && expr->kind == AST_METHODREF) {
         if (IsSymbol(expr->right)) {
             expr = NewAST(AST_ABSADDROF, expr, NULL);
-            expr = BuildMethodPointer(expr);
+            expr = BuildMethodPointer(expr, is_abs);
             return expr;
         }
     }
     if (IsSymbol(expr)) {
         expr = NewAST(AST_ABSADDROF, expr, NULL);
-        expr = BuildMethodPointer(expr);
+        expr = BuildMethodPointer(expr, is_abs);
     }
     return expr;
 }
@@ -994,11 +994,11 @@ AST *CoerceOperatorTypes(AST *ast, AST *lefttype, AST *righttype)
         righttype = ArrayToPointerType(righttype);
     }
     if (IsFunctionType(lefttype) && !IsPointerType(lefttype)) {
-        ast->left = FunctionAddress(ast->left);
+        ast->left = FunctionAddress(ast->left, false);
         lefttype = FunctionPointerType(lefttype);
     }
     if (IsFunctionType(righttype) && !IsPointerType(righttype)) {
-        ast->right = FunctionAddress(ast->right);
+        ast->right = FunctionAddress(ast->right, false);
         righttype = FunctionPointerType(righttype);
     }
     if (IsBoolType(rettype)) {
@@ -1431,7 +1431,7 @@ AST *CoerceAssignTypes(AST *line, int kind, AST **astptr, AST *desttype, AST *sr
     if (IsFunctionType(srctype) && IsPointerType(desttype) && !IsPointerType(srctype)) {
         srctype = FunctionPointerType(srctype);
         if (astptr) {
-            expr = FunctionAddress(expr);
+            expr = FunctionAddress(expr, false);
             *astptr = expr;
         } else {
             ERROR(line, "Unable to convert function result to pointer");
@@ -1580,7 +1580,7 @@ doCast(AST *desttype, AST *srctype, AST *src)
         srctype = ast_type_ptr_void;
     } else if (IsFunctionType(srctype) && !IsPointerType(srctype)) {
         // need to create a handle for it
-        src = FunctionAddress(src);
+        src = FunctionAddress(src, false);
         srctype = FunctionPointerType(srctype);
     }
     if (IsFunctionType(desttype) && !IsPointerType(desttype)) {
@@ -2024,7 +2024,7 @@ static AST *doCheckTypes(AST *ast)
     case AST_ADDROF:
     case AST_ABSADDROF:
         if (IsFunctionType(ltype) && !IsPointerType(ltype)) {
-            *ast = *BuildMethodPointer(ast);
+            *ast = *BuildMethodPointer(ast, ast->kind == AST_ABSADDROF);
             return ltype;
         }
         return NewAST(AST_PTRTYPE, ltype, NULL);
diff --git a/sys/bytecode_rom.spin b/sys/bytecode_rom.spin
@@ -504,6 +504,10 @@ pri _make_methodptr(o, func) | ptr
     long[ptr+4] := func
   return ptr
 
+pri _get_rawfuncaddr(o, func) | ptr
+  ptr := func
+  return ptr
+
 '
 ' create a class interface from a definite object o and
 ' a skeleton list of functions skel containing n entries
diff --git a/sys/bytecode_rom.spin.h b/sys/bytecode_rom.spin.h
diff --git a/sys/nucode_util.spin b/sys/nucode_util.spin
diff --git a/sys/nucode_util.spin.h b/sys/nucode_util.spin.h
diff --git a/sys/p1_code.spin b/sys/p1_code.spin
diff --git a/sys/p1_code.spin.h b/sys/p1_code.spin.h
diff --git a/sys/p2_code.spin b/sys/p2_code.spin
diff --git a/sys/p2_code.spin.h b/sys/p2_code.spin.h

Original file line number	Diff line number	Diff line change
`@@ -330,6 +330,10 @@ switch (x) {`
`330`	`330`	`}`
`331`	`331`	```
`332`	`332`
	`333`	`+### Absolute address of functions`
	`334`	`+`
	`335`	+As discussed in the general documentation, function pointers are complicated objects which are not necessarily the address of the first instruction of the function. In the rare cases where some inline assembly requires access to this information, use the absolute address operator (`@@@`, as in Spin2) to obtain it; that is, `@@@foo` is the address of the first instruction of `foo`. Note that trying to call this directly may produce undefined behavior if the function accesses any member variables, including global variables. See the discussion in the general (language independent) documentation for more details.
	`336`	`+`
`333`	`337`	`### Statement expressions`
`334`	`338`
`335`	`339`	`A compound statement enclosed in parentheses may appear as an expression. This is a GCC extension which allows loops, switches, and similar features to appear within an expression.`