Add mangling modifier 'as long|ulong alias "long"' for Win64

- Name mangling of Long parameters on Win64 are mangled to C++ int by default
- Add syntax to mangle to a C++ long with a modifier in the form 'as [u]long alias "long"'
- The data type size is still 32bit but allows calling external C++ library expecting a C++ long.

Author: jayrm

changelog.txt

@@ -10,6 +10,7 @@ Version 1.06.0
 - WSTRING can be a return type, but only for prototypes (DECLARE) and function pointers, this allows getting PROCPTR() of all fb built-in run time functions
 
 [added]
+- Name mangling of Long parameters on Win64 are mangled to C++ int by default and to C++ long with a modifier in the form 'as [u]long alias "long"'.  The data type size is still 32bit but allows calling external C++ library expecting a C++ long.
 - -noobjinfo option to disable the writing/reading of compile-time library and other linking options from/to .o and .a files. This also disables the use of fbextra.x (the supplemental linker script) for discarding the .fbctinf sections, which is useful when using the gold linker that doesn't support this kind of linker script.
 - Linux console Inkey() now recognizes F11 and F12
 - 2D render through OpenGL on Windows and Linux via screencontrol (angros47)

src/compiler/parser-decl-symbtype.bas

@@ -393,6 +393,38 @@ function hIntegerTypeFromBitSize _
 
 end function
 
+private function cMangleModifier _
+	( _
+	) as integer
+
+	static as zstring * FB_MAXNAMELEN+1 aliasid
+	function = FALSE
+
+	'' ALIAS?
+	if( lexGetToken( ) = FB_TK_ALIAS ) then
+		lexSkipToken( )
+
+		'' "long"
+		if( lexGetClass( ) = FB_TKCLASS_STRLITERAL ) then
+			aliasid = *lexGetText( )
+			lexSkipToken( )
+
+			select case lcase( aliasid )
+			case "long"
+				function = fbIs64bit( ) and ((env.target.options and FB_TARGETOPT_UNIX) = 0)
+			case ""
+				errReport( FB_ERRMSG_EMPTYALIASSTRING )
+			case else
+				errReport( FB_ERRMSG_SYNTAXERROR )	
+			end select
+		else
+			errReport( FB_ERRMSG_SYNTAXERROR )
+		end if
+
+	end if
+
+end function
+
 '':::::
 ''SymbolType      =   CONST? UNSIGNED? (
 ''				      ANY
@@ -528,10 +560,16 @@ function cSymbolType _
 		case FB_TK_LONG
 			lexSkipToken( )
 			dtype = FB_DATATYPE_LONG
+			if( cMangleModifier() ) then
+				dtype = typeSetMangleDt( dtype, FB_DATATYPE_INTEGER )
+			end if
 
 		case FB_TK_ULONG
 			lexSkipToken( )
 			dtype = FB_DATATYPE_ULONG
+			if( cMangleModifier() ) then
+				dtype = typeSetMangleDt( dtype, FB_DATATYPE_UINT )
+			end if
 
 		case FB_TK_LONGINT
 			lexSkipToken( )
@@ -668,7 +706,11 @@ function cSymbolType _
 				dtype = FB_DATATYPE_UINT
 
 			case FB_DATATYPE_LONG
-				dtype = FB_DATATYPE_ULONG
+				if( typeIsMangleDt( dtype ) ) then
+					dtype = typeSetMangleDt( FB_DATATYPE_ULONG, FB_DATATYPE_UINT )
+				else
+					dtype = FB_DATATYPE_ULONG
+				end if
 
 			case FB_DATATYPE_LONGINT
 				dtype = FB_DATATYPE_ULONGINT

src/compiler/symb-mangling.bas

@@ -319,7 +319,7 @@ function hMangleBuiltInType _
 		byref add_abbrev as integer _
 	) as zstring ptr
 
-	assert( dtype = typeGetDtOnly( dtype ) )
+	assert( dtype = (typeGetDtOnly( dtype ) or (dtype and FB_DT_MANGLEMASK)) )
 
 	''
 	'' Plain unqualified C++ built-in types are not considered for abbreviation.
@@ -357,14 +357,31 @@ function hMangleBuiltInType _
 	''    64bit fbc it was reversed, allowing the same FB and C++ code to work
 	''    together on both 32bit and 64bit.
 	''
+	''  - as special expection for windows 64bit, to get a 32bit type that will
+	''    mangle to C++ long, allow 'as [u]long alias "[u]long"' declarations.
+	''    The size of LONG/ULONG does not change, it's 32bit, only the mangling,
+	''    so fbc programs can call C++ code requiring 'long int' arguments.
+
 	if( fbIs64bit( ) and ((env.target.options and FB_TARGETOPT_UNIX) = 0) ) then
 		'' Windows 64bit
-		'' Itanium C++ ABI compatible mangling of non-C++ built-in types (vendor extended types):
-		''    u <length-of-id> <id>
-		select case( dtype )
-		case FB_DATATYPE_INTEGER : add_abbrev = TRUE : return @"u7INTEGER"  '' seems like a good choice
-		case FB_DATATYPE_UINT    : add_abbrev = TRUE : return @"u8UINTEGER"
-		end select
+
+		'' check for remapping of dtype mangling
+		if( typeIsMangleDt( dtype ) ) then
+			dtype = typeGetMangleDt( dtype )
+			'' Windows 64bit
+			select case( dtype )
+			case FB_DATATYPE_INTEGER : return @"l"  '' long
+			case FB_DATATYPE_UINT    : return @"m"  '' unsigned long
+			end select
+		else
+			'' Itanium C++ ABI compatible mangling of non-C++ built-in types (vendor extended types):
+			''    u <length-of-id> <id>
+			select case( dtype )
+			case FB_DATATYPE_INTEGER : add_abbrev = TRUE : return @"u7INTEGER"  '' seems like a good choice
+			case FB_DATATYPE_UINT    : add_abbrev = TRUE : return @"u8UINTEGER"
+			end select
+		end if
+
 	else
 		'' 32bit, Unix 64bit
 		select case( dtype )
@@ -480,7 +497,7 @@ sub symbMangleType _
 	''
 	'' Plain type without reference/pointer/const bits
 	''
-	assert( dtype = typeGetDtOnly( dtype ) )
+	assert( dtype = (typeGetDtOnly( dtype ) or (dtype and FB_DT_MANGLEMASK)) )
 
 	select case( dtype )
 	case FB_DATATYPE_STRUCT, FB_DATATYPE_ENUM

src/compiler/symb.bi

@@ -57,13 +57,16 @@ const FB_DT_TYPEMASK 		= &b00000000000000000000000000011111 '' max 32 built-in d
 const FB_DT_PTRMASK  		= &b00000000000000000000000111100000 '' level of pointer indirection
 const FB_DT_CONSTMASK		= &b00000000000000111111111000000000 '' PTRLEVELS + 1 bit-masks
 const FB_DATATYPE_REFERENCE	= &b00000000000010000000000000000000 '' used for mangling BYREF parameters
+const FB_DT_MANGLEMASK      = &b00000001111100000000000000000000 '' used to modify mangling for builtin types
 const FB_DATATYPE_INVALID	= &b10000000000000000000000000000000
 
 const FB_DT_PTRLEVELS		= 8					'' max levels of pointer indirection
 
 const FB_DT_PTRPOS			= 5
 const FB_DT_CONSTPOS		= FB_DT_PTRPOS + 4
 
+const FB_DT_MANGLEPOS       = 20
+
 enum FB_OVLPROC_MATCH_SCORE
 	FB_OVLPROC_NO_MATCH = 0
 	FB_OVLPROC_LOWEST_MATCH = 1
@@ -2492,6 +2495,10 @@ declare sub symbProcRecalcRealType( byval proc as FBSYMBOL ptr )
 #define	typeSetIsRef( dt ) (dt or FB_DATATYPE_REFERENCE)
 #define	typeUnsetIsRef( dt ) (dt and not FB_DATATYPE_REFERENCE)
 
+#define	typeIsMangleDt( dt ) (((dt and FB_DT_MANGLEMASK) <> 0))
+#define typeGetMangleDt( dt ) ((dt and FB_DT_MANGLEMASK) shr FB_DT_MANGLEPOS)
+#define typeSetMangleDt( dt, mangle_dt ) ((dt and not FB_DT_MANGLEMASK) or ((mangle_dt shl FB_DT_MANGLEPOS) and FB_DT_MANGLEMASK ))
+
 declare sub symbForEachGlobal _
 	( _
 		byval symclass as integer, _

tests/cpp/fbc-mangle.bas

@@ -3,16 +3,23 @@
 '' test mapping of basic data types between fbc and g++
 '' with c++ name mangling
 
-type cxxint as long
-type cxxlongint as integer
-	/' !!!
-		cxxlongint will currently fail on win64, fbc custom mangles INTEGER and there is 
-		no other data type that will return the "m" and "l" suffixes for c's long int.
-		The specific test that fails is skipped over using and and #ifdef.  To have a basic
-		datatype on win64 that can map to g++ long int, one possible solution would be
-		change the overloading allowed for the c++ mangled names onlym what would have to
-		be added to fbc.
-	'/
+'' by default, fbc's Long/ULong data type maps to c's int type, and since 
+'' Integer/Uinteger are meant to be (consistently) 64bits in fbc-64bit,
+''  there is no other type that (by default) that can map to c's long int, 
+'' which is 32bit even on Win64.
+
+'' So, in Win64, to allow calling an external library that needs a 'long int' 
+'' parameter there is the following, non-portable mangling modifier.  It is 
+'' ignored for all targets except for Win64
+
+#if defined(__FB_64BIT__) and not defined(__FB_UNIX__)
+	'' map fbc's 32bit 'LONG' type to Win64's 32bit 'long' type
+	type cxxlongint as long alias "long"
+#else
+	'' otherwise, integer is used on 32bit and Unix-64bit consistently to map
+	'' fbc's 32/64bit 'INTEGER' type to the target 32/64bit 'long int' type
+	type cxxlongint as integer
+#endif 
 
 extern "c++"
 
@@ -37,10 +44,10 @@ namespace cpp_mangle
 	declare function cpp_byref_ushort( byref a as unsigned short ) as unsigned short
 	declare function cpp_byref_sshort( byref a as short ) as short
 
-   	declare function cpp_byval_uint( byval a as unsigned cxxint ) as unsigned cxxint
-	declare function cpp_byval_sint( byval a as cxxint ) as cxxint
-	declare function cpp_byref_uint( byref a as unsigned cxxint ) as unsigned cxxint
-	declare function cpp_byref_sint( byref a as cxxint ) as cxxint
+   	declare function cpp_byval_uint( byval a as unsigned long ) as unsigned long
+	declare function cpp_byval_sint( byval a as long ) as long
+	declare function cpp_byref_uint( byref a as unsigned long ) as unsigned long
+	declare function cpp_byref_sint( byref a as long ) as long
 
    	declare function cpp_byval_ulongint( byval a as unsigned cxxlongint ) as unsigned cxxlongint
 	declare function cpp_byval_slongint( byval a as cxxlongint ) as cxxlongint
@@ -149,8 +156,8 @@ scope
 	ASSERT( cpp_byval_uint(&h7fffffff) = &h7fffffff )
 	ASSERT( cpp_byval_sint(&h7fffffff) = &h7fffffff )
 
-	dim ui as unsigned cxxint = 0
-	dim si as cxxint = 0
+	dim ui as unsigned long = 0
+	dim si as long = 0
 	ASSERT( cpp_byref_uint(ui) = 0 )
 	ASSERT( cpp_byref_sint(si) = 0 )
 	ui = &h7fffffff
@@ -160,24 +167,10 @@ scope
 
 end scope
 
-#ifndef ENABLE_CHECK_BUGS
-#define ENABLE_CHECK_BUGS 0
-#endif
-#if (not defined(__FB_64BIT__)) or defined(__FB_UNIX__) or (ENABLE_CHECK_BUGS=1)
-
-	#print see fbc/src/compiler/symb-mangling.bas:hMangleBuiltInType()
-	#print possibly related: https://sourceforge.net/p/fbc/bugs/828/
-
-/' !!! there is no name mangling on win64 that can
-       map to g++ long int, only allow the test on
-	   32-bit or unix or if we explicitly enable
-	   bug checks
-'/
-
 scope
 
 	'' c = signed|unsigned long int
-	'' fb = [unsigned] long|integer
+	'' fb = [unsigned] long alias "long"
 
 	ASSERT( cpp_byval_ulongint(0) = 0 )
 	ASSERT( cpp_byval_slongint(0) = 0 )
@@ -195,8 +188,6 @@ scope
 
 end scope
 
-#endif
-
 scope
 
 	''  c = signed|unsigned long long int