Static Linking - Revision history

Molly: /* Linking and Free Pascal */ add information about objectpath and librarypath

2016-10-02T18:19:35Z

Linking and Free Pascal: add information about objectpath and librarypath

Molly: /* Linking Method 2 */ update link

2016-10-02T17:23:19Z

Linking Method 2: update link

Molly: /* Linking Method 2 */ Add link to project

2016-10-02T17:14:54Z

Linking Method 2: Add link to project

Molly: /* Linking Method 1 */ Add link to project

2016-10-02T17:14:09Z

Linking Method 1: Add link to project

Molly: /* Linking Method 2 */ Add link to startup.c

2016-10-02T17:12:03Z

Linking Method 2: Add link to startup.c

Molly: /* Linking and Free Pascal */ small correction about linker

2016-10-02T17:08:57Z

Linking and Free Pascal: small correction about linker

Molly: /* Linking Method 2 */ Step 7

2016-09-25T13:54:22Z

Linking Method 2: Step 7

Molly: /* Linking Method 2 */ Step 6

2016-09-25T13:48:43Z

Linking Method 2: Step 6

Molly: /* Linking Method 2 */ Additional content for step 5

2016-09-25T13:46:24Z

Linking Method 2: Additional content for step 5

Molly: /* Linking Method 2 */ New Step 5 plus initial content. not finished yet.

2016-09-25T11:40:48Z

Linking Method 2: New Step 5 plus initial content. not finished yet.

@@ Line 28: / Line 28: @@
 Free Pascal is just like any other compiler out there in that it is able to use an external linker such as from binutils provided linker (ld, or in the specific case of AROS it calls ld indirectly using the collect-aros binutil) in order to link against (static) objects in order to incorporate the linked code into the final produced executable.
-An important thing to realize before any attempt is made to link against object files, is that the compiler is to be told where exactly it is able to locate those objects (in case you do not have them lined up side by side to your source-code).
+An important thing to realize before any attempt is made to link against object files, is that the compiler is to be told where exactly it is able to locate those objects(-libraries) (in case you do not have them lined up side by side to your source-code).
 Some keywords with regards to linking and Free Pascal

@@ Line 108: / Line 108: @@
 :That is also reason it is easier to link against the library of your choice in an existing header file that is already available for your library. In worse case scenario such header file does not exist and in which case you would have to convert from original sdk of that library.
+:
-:It is a bit out of scope to make here a full example, therefor please see [https://github.com/magorium/fpc-aros-wiki/blob/master/Topics/Static_MikMod/mikmod3.pas here]. (TODO: change link)
+:It is a bit out of scope to make here a full example, therefor please see [https://github.com/magorium/fpc-aros-wiki/blob/master/Topics/Static_MikMod_Method2/mikmod3.pas here for an example for libmikmod].
+:
 : Be sure to at least read the chapter [http://www.freepascal.org/docs-html/3.0.0/prog/progch7.html "Linking Issues"] of the Free Pascal manual. There you are able to read about keywords/modifiers such as "external", "cvar" and "name" which more or less are used to import and export variables and procedures/functions.

@@ Line 60: / Line 60: @@
 === Linking Method 2 ===
-For a practical example see ...
+For a practical example see [https://github.com/magorium/fpc-aros-wiki/tree/master/Topics/Static_MikMod_Method2 static MikMod - method 2]
 * '''Step 1: Link in basic required objects'''

@@ Line 56: / Line 56: @@
 === Linking Method 1 ===
-For a practical example see ...
+For a practical example see [https://github.com/magorium/fpc-aros-wiki/tree/master/Topics/Static_MikMod_Method1 static MikMod - method 1]
 === Linking Method 2 ===

@@ Line 118: / Line 118: @@
 :In order to get the initialization process used by AROS working for use with Free Pascal we are obligated to mimic some of that behaviour, otherwise we would be linking but none of the linked in objects would then be properly initialized (and so things would crash on usage).
+:
-:The code we need to mimic originates from the file startup.c (it is indeed the original source-file that created the startup.o object that we linked against). (TODO: Add link to original startup.c file).
+:The code we need to mimic originates from the file [https://trac.aros.org/trac/browser/AROS/branches/ABI_V0-on-trunk-20141231/AROS/compiler/startup/startup.c startup.c] (it is indeed the original source-file that created the startup.o object that we linked against).
+:
 :The two functions that we need to call are:

@@ Line 26: / Line 26: @@
 === Linking and Free Pascal ===
-Free Pascal is just like any other compiler out there in that it uses the binutils provided linker (ld, or in the specific case of AROS it calls ld indirectly using the collect-aros binutil) in order to link against (static) objects in order to incorporate the linked code into the final produced executable.
+Free Pascal is just like any other compiler out there in that it is able to use an external linker such as from binutils provided linker (ld, or in the specific case of AROS it calls ld indirectly using the collect-aros binutil) in order to link against (static) objects in order to incorporate the linked code into the final produced executable.
 An important thing to realize before any attempt is made to link against object files, is that the compiler is to be told where exactly it is able to locate those objects (in case you do not have them lined up side by side to your source-code).

← Older revision		Revision as of 13:54, 25 September 2016
Line 276:		Line 276:
	:		:
	:Just note though. we are not 100% home safe yet (albeit we are almost) and, some things can be improved. Head on to the next step please.		:Just note though. we are not 100% home safe yet (albeit we are almost) and, some things can be improved. Head on to the next step please.
		+	:
		+	:
		+	* '''Step 7: Loose Ends'''
		+	:
		+	:
		+	:First let's start with the bad news. As soon as you halt your Pascal code somewhere, things can go from bad to worse in a very rapid pace.
		+	:
		+	:Normally inside your pascal code you would allocate memory, initialize objects/classes and more of suchs things. Alas, the moment you halt your program all allocated memory is not freed up in a neatly manner. This is because halt bypasses the normal exit flow. Whatever you do inside your pascal code, you would need to take care of having a graceful exit flow that takes care of things as they are suppose to be.
		+	:
		+	:So in case you think you _must_ make a call to halt then make sure you have added an proper exit procedure using AddExitProc() before actually making a call to the halt function.
		+	:
		+	:In a similar way, using code from the linked c-library simply can't happen when things are not initialized yet, and for sure can't happen when we've already went through the normal exit flow. This means that using c link libraries from unit initialization and/or unit finalization is not possible. If you would do so, the code would simply crash.
		+	:
		+	:
		+	: ToDo: more to write about caveats and further optimizing things. check-in sources for individual steps as well as mikmod library example using described method.
		+	:

← Older revision		Revision as of 13:48, 25 September 2016
Line 251:		Line 251:
	:		:
	:Unfortunately, running this code shows there is still an issue somewhere. The code crashes on program exit. But please test and see that whatever you place inside (or call from inside) function AROSC_Startup_Entry is being executed as intended.		:Unfortunately, running this code shows there is still an issue somewhere. The code crashes on program exit. But please test and see that whatever you place inside (or call from inside) function AROSC_Startup_Entry is being executed as intended.
		+	:
		+	:
		+	* '''Step 6: Fine-tuning Options'''
		+	:
		+	:
		+	:If you've taken a look at the original startup.c source-code you might have noticed some odd symbols being declared. They are even described in the source-code itself.
		+	:
		+	:Well, as it is the case, the c startup code is still performing some task that a) Pascal does not need and b) would require us to do additional initialization.
		+	:
		+	:In order to 'disable' some of that task that the startup code is performing we need to export some symbols to turn this off.
		+	:
		+	:Add the following lines to your code:
		+	:
		+	:<source lang="pascal">
		+	var
		+	__nocommandline : Integer; cvar; export;
		+	__nostdiowin : integer; cvar; export;
		+	__nowbsupport : Integer; cvar; export;
		+	</source>
		+	:
		+	:For the exact explanation and workings of these symbols please see the file startup.c
		+	:
		+	:Can we now then finally execute our code without issues ? Well, try and see for yourself ;-)
		+	:
		+	:Just note though. we are not 100% home safe yet (albeit we are almost) and, some things can be improved. Head on to the next step please.

@@ Line 175: / Line 175: @@
 </source>
+:
-:Under no cirumstances run this code yet, or at least, not with calling the function __startup_entries_next() yet (you can comment it out to see the results sofar if you like).
+:Under no circumstances run this code yet, or at least, not with calling the function __startup_entries_next() yet (you can comment it out to see the results sofar if you like).
+:
 :Now, proceed to the following step
@@ Line 184: / Line 184: @@
+:
 : In case you didn't listen and did call __startup_entries_next from the previous step, then you might have seen that there is some looping going on, and for sure no additional Pascal code is fired (except for the looping parts). That is because the startup code we call from c does not have a clue yet about which code to call after it's done initializing. So let's take care of that here.

← Older revision		Revision as of 11:40, 25 September 2016
Line 178:		Line 178:
	:		:
	:Now, proceed to the following step		:Now, proceed to the following step
		+	:
		+	:
		+	* '''Step 5: Let's say hello to Pascal'''
		+	:
		+	:
		+	: In case you didn't listen and did call __startup_entries_next from the previous step, then you might have seen that there is some looping going on, and for sure no additional Pascal code is fired (except for the looping parts). That is because the startup code we call from c does not have a clue yet about which code to call after it's done initializing. So let's take care of that here.