Standalone ST Source Compilation & Linking Error

[PBaswat]

Hi,
i am working on project in which i need to call program from c++ main function, and inside program i am calling function block which will internally calling one function. and i am printing result inside program.
Here i want to compile individual ST file separately and then link together with c++ main program, but i am getting some linker error.
------------------------------------------------------------File : main.cpp------------------------------------------------------------

#include <iostream>
using namespace std;

extern "C" {
	// Declare a struct for the function block
	typedef struct {
		bool ci;
		int printer;
		char in[50];
	} print_string;
	// Declare a struct for the program
	typedef struct {
		print_string printstr;
	} myprogram_struct; 

	// Declare the instance of the program as external
	extern myprogram_struct myprogram_instance;

	// Declare imported global variables as external
	extern unsigned int gnExternalIf;

	// Declare the external "public" method by using the program call signature
	void myprogram(myprogram_struct*);

}


int main(int argc, char * argv[]){
	gnExternalIf = 2;
	myprogram(&myprogram_instance);
	//std::cout << "Number is " << std::to_string(gnExternalIf) << std::endl;
	return 0;
}

------------------------------------------------------------File : myprogram.st------------------------------------------------------------

program myprogram
   var_temp
      asign1 : dint ;
      asign2 : dint ;
      asign3 : dint ;
   end_var   
   
   
   var
      printstr : print_string;
	  myfb : myfunctionblock;
   end_var
   
   
   if gnExternalIf = 0 then
   	asign1 := gnExternalIf + 10;
   	asign2 := gnExternalIf + 20;
   elsif gnExternalIf = 1 then
   	asign1 := gnExternalIf + 50;
   	asign2 := gnExternalIf + 60;
   else
   	asign1 := gnExternalIf + 100;
   	asign2 := gnExternalIf + 110;
   end_if;
   
   myfb(inVariable1 := asign1, inVariable2 := asign2);
   asign3 = myfb.outResult;	 
   printstr( CI := TRUE, 
			 PRINTER := asign3, 
			 IN := ' : result');
end_program

------------------------------------------------------------File : myfunctionblock.st--------------------------------------------------------

FUNCTION_BLOCK myfunctionblock

(* External Interface *)
	VAR_INPUT
		(* Put your input variable declarations here *)
		inVariable1 : dint ;
		inVariable2 : dint ;
	END_VAR

	VAR_OUTPUT
		(* Put your output variable declarations here *)
		outResult : dint := 0;
	END_VAR
	
(* Local Variables *)
	VAR
		(* Put your local variable declarations here *)
		iTemp1 : dint ;
		iTemp2 : dint ;
	END_VAR
	
(* Function Block Body *)
	iTemp1 := inVariable1 ;
	iTemp2 := inVariable2 ;
	outResult := myfunction(iTemp1, iTemp2);
	gnExternalIf := 10;
END_FUNCTION_BLOCK

------------------------------------------------------------File : myfunction.st--------------------------------------------------------

FUNCTION myfunction : DINT
	VAR_INPUT
		iParam1 : DINT;
		iParam2 : DINT;
	END_VAR

	VAR_TEMP
		iResult : DINT := 0;
	END_VAR
	iResult := iParam1 * iParam2;
	myfunction := iResult;
END_FUNCTION

------------------------------------------------------------File : print_string.st--------------------------------------------------------

{external} 
FUNCTION puts : DINT
VAR_INPUT {ref}
    text : STRING;
END_VAR
END_FUNCTION


{external}
FUNCTION printf : DINT
VAR_INPUT {ref}
    format : STRING;
END_VAR
VAR_INPUT
    args: ...;
END_VAR
END_FUNCTION


FUNCTION_BLOCK print_string
VAR_INPUT
    CI :            BOOL := TRUE ;      (* Control in. *)
    PRINTER :       DINT := 1 ;         (* Printer number *)
    IN :            STRING ;            (* The value to print. *)
END_VAR

VAR_OUTPUT
    CO :            BOOL ;              (* Control out. *)
END_VAR
  printf('CI : %d, PRINTER : %d, IN : ', CI, PRINTER);
  puts(IN);
END_FUNCTION_BLOCK

List of commands To Build Individual ST sources are mentioned below,
plc -c print_string.st -o print_string.o
plc -c myfunction.st -o myfunction.o
plc -i myfunction.st -i myglobalvars.st -c myfunctionblock.st -o myfunctionblock.o
plc -i print_string.st -i myglobalvars.st -i myfunctionblock.st -c myprogram.st -o myprogram.o
clang++ -c main.cpp -o main.o
clang++ main.o myprogram.o myfunctionblock.o print_string.o -o Test

Error Received During Compilation Are:

/usr/bin/ld: myfunctionblock.o:(.rodata+0x0): multiple definition of `__myfunctionblock__init'; myprogram.o:(.rodata+0x60): first defined here
/usr/bin/ld: print_string.o:(.rodata+0x0): multiple definition of `__print_string__init'; myprogram.o:(.rodata+0x0): first defined here
/usr/bin/ld: print_string.o: relocation R_X86_64_32 against `.rodata.str1.16' can not be used when making a PIE object; recompile with -fPIE
/usr/bin/ld: failed to set dynamic section sizes: bad value

[ghaith]

Hi @PBaswat
I updated the formatting of the code files for easier readability.
I'll check the issue later when I get the chance.

[PBaswat]

Thank you very much for formatting; and we will wait for reply.

[ghaith]

When I run the code, I don't get the issue with the PIC

❯ clang++ *.o
/usr/bin/ld: myprogram.o:(.rodata+0x60): multiple definition of `__myfunctionblock__init'; functionblock.o:(.rodata+0x0): first defined here
/usr/bin/ld: print_string.o:(.rodata+0x0): multiple definition of `__print_string__init'; myprogram.o:(.rodata+0x0): first defined here
clang-14: error: linker command failed with exit code 1 (use -v to see invocation)

But that is still an issue if because it makes using the compiler harder. We usually default to PIC (or at least we started to default to pic when we implemented the parallel compilation). Maybe you had an older .o file that was compiled with the previous version?
Regarding the multiple symbols issue, it's a problem and i'll open an issue for it. However, you can work around it if you just include it in the compilation line of the program:
plc print_string.st -i myglobalvars.st -i myfunctionblock.st -c myprogram.st -o myprogram.o
Notice that I removed the -i and you would then skip the following line: plc -c print_string.st -o print_string.o
I understand this is not always easy since you might use this function in other programs.
Another method is to use the builtin build system to generate the object files.
To do so, create a file called plc.json with the following content:

{
    "name": "Test",
    "files" : [
        "*.st"
    ],
    "compile_type" : "Object"
}

Run the compilation with : plc build and you will get a folder called build with the object files including your full program file (test).
You can now compile it with clang++ as before:
clang++ main.cpp build/Test.o -o Test

rusty/target/test on  master [$?]
❯ clang++ main.cpp build/Test.o -o Test

rusty/target/test on  master [$?]
❯ ./Test
CI : 1, PRINTER : 0, IN :  : result

[PBaswat]

thanks for reply,
but our requirement is to compile individual ST file separately and finally link all ST objects and C++ objects together to create a final executable.
We cannot go with wildcard(*) based ST file population for compilation. so please suggest way to do that.

Regard,
Prashant

[ghaith]

You can specify single files in the plc.json just list the files separated by comma. But I opened an issue for the other case anyway.