Implement taking address of the external symbol

Author: MrSmith33

source/tests/passing.d

@@ -6307,7 +6307,7 @@ immutable test287 = q{--- test287.vx
 };
 
 
-@TestInfo()
+@TestInfo(&tester288)
 immutable test288 = q{--- test288.vx
 	// Aggregate lowering bug with constant aggregate nested inside non-constant one
 	struct vec3 { f32 x; f32 y; f32 z; }
@@ -6324,3 +6324,32 @@ void tester288(ref TestContext ctx) {
 	static struct Vertex { float pos; vec3 color; }
 	assert(ctx.getFunctionPtr!(Vertex, float)("putQuadAt")(56.0f) == Vertex(56.0f, vec3(1, 0, 0)));
 }
+
+
+/*
+TODO
+@TestInfo(&tester289)
+immutable test289 = q{--- test289.vx
+	// Aggregate of float type
+	struct vec2 { f32 x; f32 y; }
+	vec2 make(f32 x, f32 y) {
+		return vec2(x, y);
+	}
+};
+void tester289(ref TestContext ctx) {
+	static struct vec2 { float x; float y; }
+	assert(ctx.getFunctionPtr!(vec2, float, float)("make")(56.0f, 30.0f) == vec2(56.0f, 30.0f));
+}*/
+
+
+@TestInfo(&tester290, [HostSymbol("noop", cast(void*)&external_noop)])
+immutable test290 = q{--- test290.vx
+	// Taking address of the external symbol
+	@extern(module, "host") void noop();
+	void* run() {
+		return &noop;
+	}
+};
+void tester290(ref TestContext ctx) {
+	assert(ctx.getFunctionPtr!(void*)("run")() == &external_noop);
+}

source/vox/be/emit_mc_amd64.d

@@ -907,10 +907,19 @@ struct CodeEmitter
 			// copy address of function into register
 			case MoveType.func_to_reg:
 				context.assertf(dst.physRegClass == AMD64_REG_CLASS.GPR, "func_to_reg %s", dst);
-				// HACK, TODO: 32bit version of reg is incoming, while for ptr 64bits are needed
-				MemAddress addr = memAddrRipDisp32(0);
-				gen.lea(dstReg, addr, cast(ArgType)IrArgSize.size64);
-				addRefTo(src);
+				FunctionDeclNode* func = context.getFunction(src);
+				LinkIndex entityIndex = func.backendData.objectSymIndex;
+				ObjectSymbol* sym = context.objSymTab.getSymbol(entityIndex);
+				if (sym.isIndirect) {
+					// read address from the import section
+					MemAddress addr = memAddrRipDisp32(0);
+					gen.mov(dstReg, addr, cast(ArgType)IrArgSize.size64);
+				} else {
+					// take address of the symbol
+					MemAddress addr = memAddrRipDisp32(0);
+					gen.lea(dstReg, addr, cast(ArgType)IrArgSize.size64);
+				}
+				addRefTo(entityIndex);
 				break;
 
 			case MoveType.reg_to_reg:

source/vox/be/obj.d

@@ -92,10 +92,12 @@ enum ObjectSymbolFlags : ushort {
 	isIndirect           = 1 << 3,
 	/// If true, data can be printed for debug as a string
 	isString             = 1 << 4,
+	/// If true, data can be printed for debug as an address/pointer
+	isPointer            = 1 << 5,
 	/// If true, data can be printed for debug as a float
-	isFloat              = 1 << 5,
+	isFloat              = 1 << 6,
 	/// Marked if transitively used from any root symbol (only used for imported symbols atm)
-	isReferenced         = 1 << 6,
+	isReferenced         = 1 << 7,
 }
 
 enum ObjectSymbolKind : ushort {
@@ -121,7 +123,7 @@ struct ObjectSymbol
 	Identifier id;
 	/// Points to initializer if it is provided. (Can be null)
 	ubyte* dataPtr;
-	/// Offset from the start of section. Is equal to dataPtr if host symbol
+	/// Offset from the start of section. Can be equal to dataPtr if host symbol
 	ulong sectionOffset;
 	/// Length in bytes. Doesn't include padding and zero termination
 	/// Is set in setInitializer (when has initializer), or manually (when zero inited, or is external host symbol)
@@ -144,6 +146,7 @@ struct ObjectSymbol
 	bool needsZeroTermination() { return cast(bool)(flags & ObjectSymbolFlags.needsZeroTermination); }
 	bool isIndirect() { return cast(bool)(flags & ObjectSymbolFlags.isIndirect); }
 	bool isString() { return cast(bool)(flags & ObjectSymbolFlags.isString); }
+	bool isPointer() { return cast(bool)(flags & ObjectSymbolFlags.isPointer); }
 	bool isReferenced() { return cast(bool)(flags & ObjectSymbolFlags.isReferenced); }
 
 	void setInitializer(ubyte[] data) {
@@ -182,11 +185,16 @@ struct ObjectModule
 	bool isLocal() { return kind == ObjectModuleKind.isLocal; }
 	bool isImported() { return kind == ObjectModuleKind.isImported; }
 	bool isExternal() { return isLocal || isImported; }
+
+	bool isReferenced() { return cast(bool)(flags & ObjectModuleFlags.isReferenced); }
+	bool isVerbose() { return cast(bool)(flags & ObjectModuleFlags.isVerbose); }
 }
 
 enum ObjectModuleFlags : ushort {
 	/// Marked if transitively used from any root symbol (only used for imported symbols atm)
 	isReferenced = 1 << 0,
+	/// Only printed in dump when verbose printing is enabled
+	isVerbose    = 1 << 1,
 }
 
 @(LinkIndexKind.section)
@@ -333,12 +341,16 @@ struct ObjectSymbolTable
 
 	void dump(CompilationContext* c)
 	{
-		LinkIndex modIndex = firstModule;
-		while (modIndex.isDefined)
+		for (LinkIndex modIndex = firstModule; modIndex.isDefined; modIndex = getModule(modIndex).nextModule)
 		{
 			ObjectModule* mod = getModule(modIndex);
 			writefln("%s %s", modIndex, c.idString(mod.id));
 
+			if (mod.isVerbose) {
+				writeln(`  (hidden as isVerbose)`);
+				continue;
+			}
+
 			LinkIndex symIndex = mod.firstSymbol;
 			while (symIndex.isDefined)
 			{
@@ -355,6 +367,16 @@ struct ObjectSymbolTable
 				writefln("    address: 0x%08X", section.sectionAddress + sym.sectionOffset);
 				writefln("    section: 0x%08X %s", section.sectionAddress, c.idString(section.id));
 				writefln("    data: %s bytes", sym.length);
+				if (sym.isString) {
+					writefln(`      as string: "%s"`, (cast(char*)(sym.dataPtr))[0..sym.length]);
+				}
+				if (sym.isPointer) {
+					switch(sym.length) {
+						case 4:  writefln(`      as ptr: 0x%X`, *cast(uint*)sym.dataPtr); break;
+						case 8:  writefln(`      as ptr: 0x%X`, *cast(ulong*)sym.dataPtr); break;
+						default: break;
+					}
+				}
 				if (sym.dataPtr) {
 					printHex(sym.dataPtr[0..sym.length], 16, PrintAscii.no, "      ");
 				}
@@ -363,14 +385,13 @@ struct ObjectSymbolTable
 				while (symRefIndex.isDefined)
 				{
 					ObjectSymbolReference* symRef = getReference(symRefIndex);
-					writefln("    %s -> %s: off 0x%08X extra %s %s",
+					writefln("    %s -> %s: off 0x%08X extraOff %s %s",
 						symRefIndex, symRef.referencedSymbol, symRef.refOffset,
 						symRef.extraOffset, symRef.refKind);
 					symRefIndex = symRef.nextReference;
 				}
 				symIndex = sym.nextSymbol;
 			}
-			modIndex = mod.nextModule;
 		}
 	}
 

source/vox/context.d

@@ -660,47 +660,67 @@ struct CompilationContext
 		return externalModuleIndex;
 	}
 
-	void addHostSymbol(LinkIndex hostModuleIndex, Identifier symId, void* symPtr)
+	// Automatically choses to use direct referencing or to use import table to access symbol
+	// Adds to external symbol table
+	LinkIndex addHostSymbol(LinkIndex hostModuleIndex, Identifier symId, void* symPtr)
 	{
-		LinkIndex importedSymbolIndex;
-
+		LinkIndex symIndex;
 		if (canReferenceFromCode(symPtr))
-		{
-			ObjectSymbol importedSymbol = {
-				kind : ObjectSymbolKind.isHost,
-				id : symId,
-				dataPtr : cast(ubyte*)symPtr,
-				sectionOffset : cast(ulong)symPtr,
-				sectionIndex : builtinSections[ObjectSectionType.host],
-				moduleIndex : hostModuleIndex,
-			};
-			importedSymbolIndex = objSymTab.addSymbol(importedSymbol);
-		}
+			symIndex = addHostSymbolDirect(hostModuleIndex, symId, symPtr);
 		else
-		{
-			ulong sectionOffset = importBuffer.length;
-			ulong ptr = cast(ulong)symPtr;
-			importBuffer.put(*cast(ubyte[8]*)&ptr);
-
-			ObjectSymbol importedSymbol = {
-				kind : ObjectSymbolKind.isHost,
-				flags : ObjectSymbolFlags.isIndirect,
-				id : symId,
-				sectionOffset : sectionOffset,
-				sectionIndex : builtinSections[ObjectSectionType.imports],
-				moduleIndex : hostModuleIndex,
-			};
-			importedSymbolIndex = objSymTab.addSymbol(importedSymbol);
-		}
-		Identifier modId = objSymTab.getModule(hostModuleIndex).id;
-		externalSymbols.put(arrayArena, ExternalSymbolId(modId, symId), importedSymbolIndex);
+			symIndex = addHostSymbolIndirect(hostModuleIndex, symId, symPtr);
+
+		registerExternalSymbol(hostModuleIndex, symId, symIndex);
+
+		return symIndex;
+	}
+
+	// Force host symbol to be accessed directly
+	private LinkIndex addHostSymbolDirect(LinkIndex hostModuleIndex, Identifier symId, void* symPtr)
+	{
+		ObjectSymbol sym = {
+			kind : ObjectSymbolKind.isHost,
+			id : symId,
+			dataPtr : cast(ubyte*)symPtr,
+			sectionOffset : cast(ulong)symPtr,
+			sectionIndex : builtinSections[ObjectSectionType.host],
+			moduleIndex : hostModuleIndex,
+		};
+		return objSymTab.addSymbol(sym);
+	}
+
+	// Force host symbol to be accessed through import table
+	private LinkIndex addHostSymbolIndirect(LinkIndex hostModuleIndex, Identifier symId, void* symPtr)
+	{
+		ulong sectionOffset = importBuffer.length;
+		ubyte* dataPtr = importBuffer.nextPtr;
+		size_t ptr = cast(size_t)symPtr;
+		importBuffer.put(*cast(ubyte[size_t.sizeof]*)&ptr);
+
+		ObjectSymbol sym = {
+			kind : ObjectSymbolKind.isHost,
+			flags : ObjectSymbolFlags.isIndirect | ObjectSymbolFlags.isPointer,
+			id : symId,
+			dataPtr : dataPtr,
+			length : size_t.sizeof,
+			sectionOffset : sectionOffset,
+			sectionIndex : builtinSections[ObjectSectionType.imports],
+			moduleIndex : hostModuleIndex,
+		};
+		return objSymTab.addSymbol(sym);
+	}
+
+	private void registerExternalSymbol(LinkIndex moduleIndex, Identifier symId, LinkIndex symIndex)
+	{
+		Identifier modId = objSymTab.getModule(moduleIndex).id;
+		externalSymbols.put(arrayArena, ExternalSymbolId(modId, symId), symIndex);
 	}
 
 	LinkIndex addDllModuleSymbol(LinkIndex dllModuleIndex, Identifier symId)
 	{
 		ObjectSymbol importedSymbol = {
 			kind : ObjectSymbolKind.isImported,
-			flags : ObjectSymbolFlags.isIndirect,
+			flags : ObjectSymbolFlags.isIndirect | ObjectSymbolFlags.isPointer,
 			id : symId,
 			alignmentPower : 3, // pointer size
 			sectionIndex : builtinSections[ObjectSectionType.imports],
@@ -1242,6 +1262,7 @@ void createBuiltinFunctions(CompilationContext* c)
 {
 	ObjectModule builtinModule = {
 		kind : ObjectModuleKind.isHost,
+		flags : ObjectModuleFlags.isVerbose,
 		id : c.idMap.getOrReg(c, ":builtin")
 	};
 	c.builtinModuleIndex = c.objSymTab.addModule(builtinModule);
@@ -1273,19 +1294,7 @@ void createBuiltinFunctions(CompilationContext* c)
 		funcNode.state = AstNodeState.type_check_done;
 		funcNode.flags |= FuncDeclFlags.isBuiltin;
 
-		ulong sectionOffset = c.importBuffer.length;
-		ulong ptr = cast(ulong)&builtin_function_stub;
-		c.importBuffer.put(*cast(ubyte[8]*)&ptr);
-
-		ObjectSymbol sym = {
-			kind : ObjectSymbolKind.isHost,
-			flags : ObjectSymbolFlags.isIndirect,
-			id : id,
-			sectionOffset : sectionOffset,
-			sectionIndex : c.builtinSections[ObjectSectionType.imports],
-			moduleIndex : c.builtinModuleIndex,
-		};
-		funcNode.backendData.objectSymIndex = c.objSymTab.addSymbol(sym);
+		funcNode.backendData.objectSymIndex = c.addHostSymbolIndirect(c.builtinModuleIndex, id, &builtin_function_stub);
 
 		c.assertf(func == reqIndex,
 			"Result AstIndex of builtin node %s (%s) is not equal to required (%s). Creation order must match CommonAstNodes order",

source/vox/fe/ast/decl/func.d

@@ -50,6 +50,8 @@ struct FunctionDeclNode {
 	bool isCtfeOnly(CompilationContext* c) {
 		return signature.get!FunctionSignatureNode(c).isCtfeOnly;
 	}
+	/// External functions have no body
+	bool isExternal() { return block_stmt.isUndefined; }
 
 	this(TokenIndex loc, AstIndex _module, ScopeIndex parameterScope, AstIndex signature, Identifier id)
 	{
@@ -69,9 +71,6 @@ struct FunctionDeclNode {
 		AstIndex index = get_ast_index(&this, c);
 		return IrIndex(index.storageIndex, IrValueKind.func);
 	}
-
-	/// External functions have no body
-	bool isExternal() { return block_stmt.isUndefined; }
 }
 
 void print_func(FunctionDeclNode* node, ref AstPrintState state)