FPC New Features 3.2.0: what changed

Revision 0 to 1. Removed lines have a minus sign; added lines have a plus sign.

Title: FPC New Features 3.2.0

New		Line
1	+	## About this page
2	+
3	+	FPC 3.2.0 has been released on June 19th, 2020.
4	+
5	+	Below you can find a list of new features introduced since the [[FPC New Features 3.0\|previous release]], along with some background information and examples.
6	+
7	+	A list of changes that may break existing code can be found at [[User Changes 3.2]].
8	+
9	+	## All systems
10	+
11	+	### Compiler options
12	+
13	+	#### Default unit scopes
14	+
15	+	- Overview: Support has been added for unit scopes (aka namespaces aka dotted units) that can be supplied by command line argument using -FN\<x\>.
16	+	- Notes:
17	+	- When the compiler needs to search a unit it first searches for the unit as is (first a compiled unit, then the source), then it prepends each supplied unit scope (in the supplied order) to the unit name (separated by a .) and again searches for first for a compiled unit, then the source for each unit scope.
18	+	- The feature is compatible with the -Un option
19	+	- If unit scopes are provided they can also be left out when resolving identifiers that are part of that scope.
20	+	- More information: See also the announcement mail [here](https://lists.freepascal.org/pipermail/fpc-announce/2018-May/000605.html)
21	+	- svn: r38911 - r38921, r38922
22	+
23	+	### Language
24	+
25	+	#### Support for interfacing with C blocks functionality
26	+
27	+	- Overview: Support has been added for interfacing with [Apple's blocks C-extension](http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/Blocks/Articles/00_Introduction.html).
28	+	- Notes:
29	+	- As C blocks are very similar to anonymous methods in Delphi, we use a similar syntax to declare block types (with an added cblock and either the calling convention cdecl or mwpascal to indicate the C nature). Note that the syntax to define the code executed in a block (inline, like with anonymous methods in Delphi, or in a separately defined function/method) and the functionality of a block (the ability to capture context and code to execute it at an arbitrary point in the future) are two separate things. At this time (r29594), only the code from a global function/procedure or from an Object Pascal instance/class method can be executed within the context of a block. In the future, support will be added for nested functions and later probably also for code that is defined inline, like in Delphi.
30	+	- This functionality is currently only supported by FPC on Mac OS X 10.7 (Lion) and later, and on iOS 4.0 and later. The reason it doesn't work on Mac OS X 10.6 (Snow Leopard) and earlier, is that we require functionality that was added to the blocks runtime in later versions.
31	+	- The blocks functionality can be activated on supported platforms via {\$modeswitch cblocks}
32	+	- More information:
33	+	- Example with a global procedure: <https://gitlab.com/freepascal.org/fpc/source/-/blob/main/tests/test/tblock1.pp>
34	+	- Example with an Object Pascal instance method: <https://gitlab.com/freepascal.org/fpc/source/-/blob/main/tests/test/tblock2.pp>
35	+	- svn: r29517, r29594
36	+
37	+	#### Support for Default Namespaces
38	+
39	+	- Overview: Namespaces can be supplied to the compiler to be prefixed to units that would otherwise not be found
40	+	- Description:
41	+	- Use the new -FN\<x\> parameter to add a default namespace \<x\> to the list of default namespaces. If a unit name can not be found as-is then it will be searched for using all provided default namespaces as prefix (separated by a ".") until it is found or the list of namespaces is exhausted.
42	+	- The default namespaces can also be used as prefixes for identifiers outside the uses section.
43	+	- More information: announcement mail at <https://lists.freepascal.org/pipermail/fpc-pascal/2018-May/053769.html>
44	+	- svn: r38911 - r38922
45	+
46	+	#### Dynamic Arrays supported by Insert()
47	+
48	+	- Overview: The Insert() intrinsic can be used to insert arrays and elements into an existing dynamic array.
49	+	- Notes:
50	+	- The element to be inserted can be either of the following:
51	+	- dynamic array of the same type
52	+	- static array of the same type
53	+	- a single element of the array's element type
54	+	- The insertion index is zero based
55	+	- If the dynamic array to be modified is empty it will simply contain the new data afterwards
56	+	- If the index is larger than the current highest index of the array then the new data is appended at the end
57	+	- If the index is negative then the new data will be appended at the start of the array
58	+	- This feature is Delphi compatible with the exception of inserting static arrays which is not supported by Delphi
59	+	- More information: announcement mail at <https://lists.freepascal.org/pipermail/fpc-pascal/2018-May/053892.html>
60	+
61	+	#### Dynamic Arrays supported by Delete()
62	+
63	+	- Overview: The Delete() intrinsic can be used to remove a sub range from an existing dynamic array.
64	+	- Notes:
65	+	- The start index is zero based
66	+	- The resulting range of Index and Count will be capped at the dynamic array's boundaries (namely 0 and the highest element); this may mean that in an extreme case no element is removed as the range is outside of the array's
67	+	- This feature is Delphi compatible
68	+	- More information: announcement mail at <https://lists.freepascal.org/pipermail/fpc-pascal/2018-May/053892.html>
69	+
70	+	#### Dynamic Arrays supported by Concat()
71	+
72	+	- Overview: The Concat() intrinsic can be used to concatenate two or more dynamic arrays together.
73	+	- Notes:
74	+	- The resulting array will look as if all array elements had been added manually to the new array in order
75	+	- Empty arrays don't contribute to the new array
76	+	- This feature is Delphi compatible
77	+	- More information: announcement mail at <https://lists.freepascal.org/pipermail/fpc-pascal/2018-May/053892.html>
78	+
79	+	#### Dynamic Arrays have built in + operator support
80	+
81	+	- Overview: The + operator can be used to concatenate two or more dynamic arrays together.
82	+	- Notes:
83	+	- Requires new modeswitch ArrayOperators (enabled by default in Delphi modes)
84	+	- The resulting array will look as if all array elements had been added manually to the new array in order
85	+	- Empty arrays don't contribute to the new array
86	+	- This feature is Delphi compatible
87	+	- More information: announcement mail at <https://lists.freepascal.org/pipermail/fpc-pascal/2018-May/053892.html>
88	+
89	+	#### Dynamic Array constants and variable initialization
90	+
91	+	- Overview: Dynamic arrays constants are now possible just as well as initializing dynamic array variables during their declaration. In both cases the same syntax as for static arrays is used.
92	+	- Notes:
93	+	- Adheres to the \$J switch regarding writable constants, both for the variable itself as well as its content
94	+	- Static and dynamic array constants can be nested
95	+	- Delphi compatibility:
96	+	- In Delphi modes the syntax is \[…\] instead of (…)
97	+	- Static array constants can not be used inside dynamic array constants
98	+	- Delphi does not adhere to the \$J switch for the array's contents
99	+	- More information: announcement mail at <https://lists.freepascal.org/pipermail/fpc-pascal/2018-May/053892.html>
100	+
101	+	#### Dynamic Arrays constructors
102	+
103	+	- Overview: The \[…\] syntax can be used to initialize dynamic array variables in code or to pass them to dynamic arrays parameters.
104	+	- Notes:
105	+	- This feature is Delphi compatible
106	+	- More information: announcement mail at <https://lists.freepascal.org/pipermail/fpc-pascal/2018-May/053892.html>
107	+
108	+	#### More settings supported by \$Push/\$Pop
109	+
110	+	- Overview: The directives \$Push and \$Pop now also handle the directives \$MinEnumSize, \$PackSet and \$PackRecords.
111	+
112	+	#### Support for threadvar sections inside class and record types
113	+
114	+	- Overview: Class and record types can now contain a class threadvar section that allows for the addition of scoped threadvar variables.
115	+	- Notes:
116	+	- This feature is Delphi compatible
117	+	- Not including the class specifier is considered an error
118	+	- svn: 39285 - 39289
119	+
120	+	#### Support for Generic Routines
121	+
122	+	- Overview: FPC has supported the declaration of generic types and also allowed member methods to access any generic parameters their "parent" type may have for many years. Building on this, it is now possible to declare uniquely generic routines (functions, procedures, methods) either as part of structured types or globally. In the non-Delphi syntax compatibility modes they are declared with the generic keyword preceding the procedure or function keyword and specialized with the specialize keyword preceding the identifier of the generic routine when issuing a call. In mode Delphi the syntax follows that of Delphi.
123	+	- Notes:
124	+	- This feature is Delphi-compatible, with the exception that Delphi itself does not support global (aka flat or free-standing) generic functions or procedures, only generic member methods. FPC does support them in all syntax modes (including {\$mode Delphi}), however.
125	+	- It's currently not possible to declare a uniquely generic method inside of an already-generic structured type. This will be changed in a future version.
126	+	- It's currently not possible to take a pointer to the specialization of a generic routine.
127	+	- In {\$mode Delphi}, some particularly complex expressions involving multiple specializations are not yet possible.
128	+	- Inlining is fully supported as long as the body of the generic routine has already been parsed.
129	+	- Examples:
130	+
131	+	``` pascal
132	+	unit UTestObjFPCSyntax;
133	+
134	+	{$mode ObjFPC}
135	+
136	+	interface
137	+
138	+	generic function Add<T>(const Arg1, Arg2: T): T;
139	+
140	+	implementation
141	+
142	+	generic function Add<T>(const Arg1, Arg2: T): T;
143	+	begin
144	+	Result := Arg1 + Arg2;
145	+	end;
146	+
147	+	end.
148	+	```
149	+
150	+	``` pascal
151	+	program TestObjFPCSyntax;
152	+
153	+	{$mode ObjFPC}{$H+}
154	+
155	+	uses
156	+	UTestObjFPCSyntax;
157	+
158	+	begin
159	+	Writeln(specialize Add<String>('Hello', 'World'));
160	+	Writeln(specialize Add<LongInt>(23, 19));
161	+	end.
162	+	```
163	+
164	+	``` pascal
165	+	unit UTestDelphiSyntax;
166	+
167	+	{$mode Delphi}
168	+
169	+	interface
170	+
171	+	function Add<T>(const Arg1, Arg2: T): T;
172	+
173	+	implementation
174	+
175	+	function Add<T>(const Arg1, Arg2: T): T;
176	+	begin
177	+	Result := Arg1 + Arg2;
178	+	end;
179	+
180	+	end.
181	+	```
182	+
183	+	``` pascal
184	+	program TestDelphiSyntax;
185	+
186	+	{$mode Delphi}
187	+
188	+	uses
189	+	UTestDelphiSyntax;
190	+
191	+	begin
192	+	Writeln(Add<String>('Hello', 'World'));
193	+	Writeln(Add<LongInt>(23, 19));
194	+	end.
195	+	```
196	+
197	+	#### Management operators for record types
198	+
199	+	- Overview: It is now possible to declare "management" operators inside record types which allow their built-in initialization, finalization and copying functionality to be extended. The new operators are Initialize, Finalize, Copy and AddRef. Initialize, Finalize and AddRef take the record as a var-parameter while the Copy operator takes the source record as first parameter and the destination record as second parameter whereby that one is a var-parameter. The Initialize and Finalize operators are called when such a record enters the scope or leaves it respectively. Copy is called when a record variable is assigned to another. AddRef is called when a new reference to an existing record is required which for example is the case when by-value-parameters are passed.
200	+	- Example: See the [[management operators]] wiki page for several code examples, as well as for more in-depth information on the feature.
201	+
202	+	#### Method RTTI for interfaces
203	+
204	+	- Overview: Is the \$M directive enabled when parsing an interface detailed RTTI for each method contained in the interface is generated. This information is detailed enough to not only enumerate the parameter declaration, but also to call interface functions with the help of the Rtti.Invoke() function.
205	+	- Notes:
206	+	- The idea of the feature is Delphi compatible, however the RTTI binary data is not.
207	+	- It's recommended to either use the records provided by unit TypInfo or the types provided by unit Rtti for access to avoid any problems with parsing the data.
208	+	- The generation of method RTTI data is currently restricted to COM-interfaces.
209	+	- Example: See <https://gitlab.com/freepascal.org/fpc/source/-/blob/main/tests/test/trtti15.pp>
210	+
211	+	#### Support for helper types extending interface types
212	+
213	+	- Overview: A type helper can now also extend interface types. The implementations are not provided by the interface implementer, but by the helper itself.
214	+	- Notes: This allows to add functionality to an interface that does not depend on the implementer, but merely on the interface.
215	+	- svn: 37023
216	+
217	+	#### Support for "IsManagedType" intrinsic
218	+
219	+	- Overview: An IsManagedType intrinsic has been added to check whether a provided type or variable/field is a managed type (currently AnsiString, UnicodeString, COM interface, dynamic array and record with management operators).
220	+	- Notes: This function returns a constant Boolean value and is Delphi compatible.
221	+	- Examples:
222	+	- <https://gitlab.com/freepascal.org/fpc/source/-/blob/main/tests/test/tismngd1.pp>
223	+	- <https://gitlab.com/freepascal.org/fpc/source/-/blob/main/tests/test/tismngd2.pp>
224	+	- svn: 43409
225	+
226	+	#### Support for PE/COFF metadata directives
227	+
228	+	- Overview: The directives SetPEOSVersion, SetPESubSysVersion and SetPEUserVersion can be used to set the corresponding fields of the PE/COFF header of the resulting binary. The format is \<MAJOR\>.\<MINOR\>.
229	+	- Notes:
230	+	- Take care with the versions as that may lead to binaries not starting on older versions of Windows.
231	+	- This is Delphi compatible.
232	+	- Example:
233	+	- <https://gitlab.com/freepascal.org/fpc/source/-/blob/main/tests/tbs/tb0633.pp>
234	+	- svn: 37364
235	+
236	+	#### Support for WinAPI directive
237	+
238	+	- Overview: The directive WinAPI can be used as a calling convention for routines to use the default calling convention off the target platform. This is equivalent to using StdCall on the Windows platforms (though StdCall only has any effect on i386) and CDecl on all other platforms.
239	+	- Notes:
240	+	- Delphi compatible
241	+	- Despite it's name it's not restricted to the Windows platform.
242	+	- svn: 29500
243	+
244	+	#### Support for a distinct Boolean8 type
245	+
246	+	- Overview: boolean8 is a Pascal-style boolean variable (can only hold only true = 1 and false = 0 values) that is always handled the same as a byte in terms of parameter passing conventions (as opposed to plain boolean, which follows the parameter passing convention for the C/C++ "bool" type).
247	+	- Notes: In practice, this currently only makes a difference for the x86-64 SYSV ABI, where bool/boolean is passed in the lower 8 bits of a register (rest of the bits are undefined), while boolean8 is zero-extended to 32 bits (like byte and other unsigned ordinal types \< 32 bits).
248	+
249	+	### Units
250	+
251	+	#### rtl-generics units
252	+
253	+	- Overview: A new package named "rtl-generics" was added.
254	+	- Notes: This package contains Delphi compatible units generics.defaults, generics.collections and others, implementing, amongst others, TDictionary\<\>.
255	+
256	+	#### Rtti unit
257	+
258	+	- Overview: A new unit named Rtti has been added which provides a high-level, object oriented access to the type information stored in the binary.
259	+	- Notes:
260	+	- This unit is intended to be Delphi-compatible
261	+	- This unit is currently experimental and not all features provided by the Delphi equivalent are yet available. Either types/methods are missing and thus compilation will fail or calling unsupported methods will trigger an exception.
262	+	- The Invoke() function as well as the callback functionality for TMethodImplementation is provided by a manager which is by default not set (an EInvocationError will be raised in that case). Currently an implementation using the [libffi](http://sourceware.org/libffi/) library is provided for selected platforms for which the unit ffi.manager needs to be used in the main project file, as well as a native implementation for x86_64 Windows which does not rely on the ffi.manager unit.
263	+
264	+	#### ProcessUnicode unit
265	+
266	+	- Overview: A new unit named ProcessUnicode has been added which provides an unicodestring version of TProcess. This allows unicodesupport on Windows without setting the default type to UTF-8.
267	+	- Notes:
268	+	- Both the old and the new TProcess units were reworked. Parts of the Runcommand support are now accessible in the class and parametrized with events. This makes custom versions easier.
269	+
270	+	#### Registry unit
271	+
272	+	- Overview: The TRegistry class was made to be fully Unicode capable.
273	+	- Notes:
274	+	- All public and protected methods (the public API) that used string parameters now default to use UnicodeString parameters.
275	+	- For all these methods overloads exist using String parameters (these call their UnicodeString counterparts).
276	+	- Methods using TStrings have counterparts using TUnicodeStringArray, and ReadStringList/WriteStringList let you specify if the TStrings should be treated as UTF8 encoded.
277	+	- The public API of TXMLRegistry was changed to use UnicodeString everywhere, without having String overloads. TXMLRegistry interfaces with a TXMLDocument structure internally, which uses DOMString (which in turn is an alias to WideString).
278	+	- TRegIniFile and TRegistryIniFile have been deprecated on non-Windows platforms.
279	+	- The public API of TRegIniFile has not been changed.
280	+	- More information: <https://lists.freepascal.org/pipermail/fpc-devel/2019-February/040446.html>
281	+	- svn: r41784
282	+
283	+	#### CHM package
284	+
285	+	- Overview: The Index writing of the CHM generator was completely rewritten.
286	+	- Notes: The result should now be more in line with what the MS CHM compiler does. Most notably the old binary index generation sometimes seemed to drop lemmas from the helpfile, this has been resolved, and even quite large helpfiles like AGS' only have a handful of differences with the MS generated index, mostly due to changes in order/sorting.
287	+	- More Information: The main bugreport for the issues <https://bugs.freepascal.org/view.php?id=34206> A pre 3.2.0 test snapshot is at <http://www.stack.nl/~marcov/doc-chmbeta.zip> containing both FPC and LCL chms.
288	+
289	+	### Text-mode IDE
290	+
291	+	#### GDB/MI support
292	+
293	+	- Overview: GDB/MI support has been added to the text mode IDE.
294	+	- Notes:
295	+	- It is enabled default, but can be disabled by building FPC with make NOGDBMI=1
296	+	- The old and deprecated libgdb.a support is still there for platforms that do not have a modern GDB port (or e.g. don't support true multitasking, like go32v2).
297	+	- When debugging a console application in Windows in GDB/MI mode, the debugged program is always run in a separate console. This is due to a limitation of the Windows GDB port.
298	+	- svn: r30573
299	+
300	+	## macOS/iOS
301	+
302	+	### New iosxwstr unit
303	+
304	+	- Overview: The new unit called iosxwstr can be used to install a widestring manager on macOS and iOS.
305	+	- Notes: The cwstring unit fulfils the same purpose, but is no longer able to provide full functionality on iOS 7 and newer due to Apple no longer shipping the locale and codepage information this unit depends on. The iosxwstr unit gets its locale information for upper/lowercase conversions from the System Preferences. Adding both cwstring and iosxwstr to the uses clause will cause the second in line to override the settings from the first one.
306	+	- More information: Adding this unit to the uses clause is enough to use its functionality.
307	+	- svn: r29828
308	+
309	+	### Cocoaint units updated
310	+
311	+	- Overview: The Cocoa Interfaces have been updated from Mac OS X 10.5 to OS X 10.10.
312	+	- Notes:
313	+	- CoreData and QuartzCore are now part of the CocoaAll unit due to dependencies
314	+	- The NSGraphicsContext.saveGraphicsState/RestoreGraphicsState methods previously mapped to the class methods with those names. They now map to the instance methods, while the corresponding class methods are called classSaveGraphicsState/classRestoreGraphicsState.
315	+	- svn: 42500
316	+
317	+	## i8086-msdos
318	+
319	+	### Huge memory model
320	+
321	+	- Overview: Support has been added for the i8086 huge memory model.
322	+	- Notes: The huge memory model (compared to the large memory model) removes the 64kb limitation of static data for the whole program. However, there's still a 64kb limit for the static data of a single unit.
323	+	- More information: [[DOS\|Huge memory model]]
324	+	- svn: r31518
325	+
326	+	### Internal assembler (object writer)
327	+
328	+	- Overview: There's an internal assembler/object writer implemented for the i8086-msdos platform. It replaces NASM and the WLIB tool.
329	+	- Notes: NASM is still required for building an i8086-msdos snapshot, because of the msdos startup code in the rtl. However, WLIB (from Open Watcom) is no longer required, so you can now build a fully functional smartlinked i8086-msdos snapshot from a platform that doesn't have the Open Watcom tools (such as DJGPP or macOS).
330	+	- svn: r30809
331	+
332	+	### Internal linker
333	+
334	+	- Overview: There's an internal linker implemented for the i8086-msdos platform. It replaces WLINK from Open Watcom.
335	+	- Notes: Together with the internal assembler, the internal linker removes the dependency on Open Watcom tools. NASM is still required for building an i8086-msdos snapshot, because of the msdos startup code in the rtl.
336	+	- svn: r31425
337	+
338	+	### FarAddr internal function
339	+
340	+	- Overview: There's a new i8086-specific internal function, similar to Addr(), called FarAddr(), which always returns a far pointer to the address of its argument.
341	+	- Notes: The built-in Addr() function and the @ operator return a pointer type (near or far), that depends on the memory model. When interfacing with DOS, BIOS and other 16-bit APIs, it is sometimes useful to be able to obtain a far pointer to a pascal variable or procedure/function, regardless of the selected memory model. Previously, you would have to use ifdefs, or do something like Ptr(Seg(x), Ofs(x)). Now, this can be replaced with the much nicer FarAddr(x).
342	+	- svn: r37629
343	+
344	+	### Near and far procedure variables
345	+
346	+	- Overview: Support has been added for procedure variables with an explicitly specified near or far call model.
347	+	- Notes: By default, procedure variables follow the default call model of the current memory model - near in the tiny, small and compact memory models; far in the medium, large and huge models. However, now you can specify an explicit near or far call model, regardless of the default for the current memory model. Note that near and far procedure variables are not compatible with each other. Syntax is really simple:
348	+
349	+	`type`\
350	+	` TFarProc = procedure(a, b: Integer); far;`\
351	+	` TNearProc = procedure(a, b: Integer); near;`
352	+
353	+	Near procedure variables are 2 bytes long, so they contain only an offset. They are invoked with a near call instruction. Far procedure variables are 4 bytes long (16-bit offset + 16-bit offset) and are invoked with a far call. Note that you cannot simply convert a near procedure to a far procedure, by just filling in the segment part, because the call model is also different between near and far procedures. A far call instruction pushes a 4-byte far (segment:offset) return address and the function must terminate with a far return instruction - retf. A near call instruction pushes only a 2-byte offset on the stack and the function must terminate with a near return instruction - retn.
354	+
355	+	- svn: r38691
356	+
357	+	## i386-go32v2
358	+
359	+	### A new archive was added that contains alternative builds of the textmode IDE.
360	+
361	+	- Overview: A new archive was added that contains alternative builds of the textmode IDE.
362	+	- Notes: Various compilation options like various GDB options and without VESA support (VESA builds have problems with some windows drivers, but having VESA support is beneficial for debugging Graph applications under pure dos). The archive is available via FTP: [IDE alternative builds](ftp://ftp.freepascal.org/fpc/dist/3.2.0/i386-go32v2/separate/idedos_alternative_builds.zip)(60MB) containing:
363	+	- svn: - (release building only)
364	+	- Contents:
365	+
366	+	- - 73878497 fpgdb771novesa.exe
367	+	- 74100535 fpgdb771vesa.exe
368	+	- 7921184 fpgdbnovesa.exe
369	+	- 22462112 fpnogdb.exe
370	+	- 22378419 fpnogdbnovesa.exe
371	+	- 4178288 fpnovesa.exe
372	+	- 3900928 fp-ori.exe
373	+	- 4240912 fpvesa.exe
374	+
375	+	## i386-win32
376	+
377	+	### The i386-win32 target now defaults to using SEH compatible exceptions
378	+
379	+	- Overview: The i386-win32 target now defaults to using SEH compatible exceptions.
380	+	- Notes: This improves compatibility with MSVC++ exception handling.
381	+	- svn: 43978
382	+
383	+	## x86_64-win64
384	+
385	+	### Support for Microsoft's vectorcall calling convention
386	+
387	+	- Overview: Under x86_64 (not i386), support for the "vectorcall" calling convention is now possible on Windows targets by specifying the vectorcall modifier.
388	+	- Notes: Utilises the XMM registers better than the default Microsoft ABI, allowing aligned arrays of Singles and Doubles to be passed in a single register akin to the System V ABI as used by Linux and other OS's. Also allows projects to interface with external libraries that use the convention. "vectorcall" is silently ignored if the target is not x86_64-win64.
389	+	- svn: 38206
390	+
391	+	## New compiler targets
392	+
393	+	### Support for the AArch64 target
394	+
395	+	- Overview: Support has been added for the AArch64 architecture, with Darwin iOS (but not Darwin macOS), Linux, and Android as available operating system targets.
396	+	- Notes: Apple's A7 CPU (and potentially other AArch64 CPUs too) does not support raising a signal when a floating point exception occurs.
397	+	- More information: <https://lists.freepascal.org/pipermail/fpc-devel/2015-February/035524.html>
398	+	- svn: r29986 (Darwin/iOS), r30897 (Linux), r39862 ([[Android]])
399	+
400	+	### Support for the Linux/ppc64le target
401	+
402	+	- Overview: Support has been added for the Linux/ppc64le target. This is a PowerPC64 little endian platform that uses a new ABI termed ELFv2.
403	+	- Notes: It is not easy to build this target on a big endian Linux/ppc64 target, due to the fact that the build system does not yet contain support to deal with different ABIs/endianess.
404	+	- More information: To cross-compile a ppc64le compiler, use CROSSOPT="-Cb- -Caelfv2". Those options don't have to be specified when compiling on a ppc64le system using a native ppcppc64, as they will be set by default for that compiler.
405	+	- svn: r30228
406	+
407	+	### Support for the Android/x86_64 target
408	+
409	+	- Overview: Support has been added for the Android/x86_64 target.
410	+	- More information: [[Android]].
411	+	- svn: r39956
412	+
413	+	### Support for the i8086-win16 (16-bit Windows) target
414	+
415	+	- Overview: Experimental support has been added for the 16-bit Windows target. It is a cross compiler only target (cross compilation is possible from e.g. Win32, Win64 or Linux).
416	+	- Notes: Windows 3.0 or later is supported.
417	+	- More information: [[Win16]]
418	+
419	+	## New Features from other versions
420	+
421	+	---
422	+	From the Free Pascal wiki, page "FPC New Features 3.2.0", as it stood on 2022-02-07 after a change by Marcov, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).
423	+	Category: FPC 3.0+ stuff
424	+	Category: FPC New Features by release
425	+	Category: Release Notes

Back to history