Specifying multiple files when compiling from C++ to LLVM IR using clang - c++

I compile my C++ program to LLVM IR using the following command.
clang++ -O4 -emit-llvm program.cpp -c -o program.ll -S -pthread
However, now I want to do the same for multiple files. How can I do that? I want to produce one IR file after the compilation (not separate IR files for each file). In other words I want to have the linked code (code from all files linked together) in my IR file.

You're probably looking for the llvm-link command, which links bitcode files together.

Related

Run C++ executable on Linux

I am trying to compile an execute a C++ program in Linux using OpenCV.
When I type
g++ -c facedetection.cpp -std=c++11 -o facedetection
The facedetection file is correctly generated. Please note that I use -std=c++11 because I had an error advising to do so.
After doing chmod o+x facedetection I try to execute it with ./facedetection but I get error:
bash: ./facedetection: cannot execute binary file: Exec format error
What is wrong?
When you compile with -c, it generates an object (.o) file, not an executable. You need to compile it without -c in order to make an executable file.
Larger C++ programs will have more than one .cpp file; for each .cpp file, you would compile using -c to generate their respective .o file. Then you would link these .o files (running g++ without -c) to generate the final executable.

Build ASM code using libtool and autoconf

I am using libtool and automake to build our project. Project has CPP and ASM code.
CPP code is built properly and .o files are created.
To build ASM code below given instructions are given in config
AM_PROG_AS, CCASFLAGS
ASM code seems to be not building. In compilation summery I see that ASM code with .s extension is built but object file are missing. When I run below command separately(Which I have taken from the verbose of compilation) it runs but not generating the object file.
libtool: compile: gcc -S -DARCH_X86_64=1 -g -O2 -c file.s -fPIC -DPIC -o .libs/file.o
What could be the reason ?? Any additional configuration is required.
Is there any option where I can force libtool to use yasm for ASM code building??
-S option instructs gcc to generate an assembly file, not assemble. It only makes sense for C files, if you want to examine generated assembly code. Remove that. Next time consult the manual for the meaning of the options.

How to link a library with clang and llvm-link

I am compiling my program like this,
clang++ -O4 -emit-llvm file1.cpp -c -o file1.bc -pthread
clang++ -O4 -emit-llvm file2.cpp -c -o file2.bc -pthread
llvm-link file1.bc file2.bc -o main.ll -S
How do I specify linking with -ldl
llvm-link is a program which "links" together LLVM IR files into a single IR file; you can read more about it here. It does not have any relation to ld or to linking object files together.
If you do want to generate object code and/or executables, see these related questions:
How to generate machine code with llvm
llvm-link with external libraries
In short, you should be using native tools for assembling and linking (as and ld, for instance), though there is currently some experimental support for generating object files and for linking in LLVM.
In any case, Clang itself can invoke a platform linker - that is actually the default, but of course you have overridden by providing -c.

Reason for having to compile files to different extension types

Recently I had to use this command in a makefile I had for an sqlite program I'm working on:
gcc -g -c sqlite3.c -o sqlite3.o
g++ -g -c main.cpp -o main.o
g++ sqlite3.o main.o -o sqliteex
I had to directly compile the sqlite3.c file into my program in order to use the sqlite3.h interface (included in the main.cpp file with #include SQL/sqlite3.h). But why did I need to use gcc to do this and create sqlite3.o, then compile both files as .o files into my executable?
Edit: My guess would be that .o files are compilable by both gcc and g++, if this is the case, is it a good practice to just always compile things as .o files?
But why did I need to use gcc to do this and create sqlite3.o, then compile both files as .o files into my executable?
You did not need to do that. The reason you did do that was to specify that sqlite.c was C code and not C++ code. You could have done this instead:
g++ main.cpp -x c sqlite3.c -o sqliteex
Additionally, it is possible (but not at all certain) that the sqlite code could have compiled as C++, like this:
g++ main.cpp sqlite3.c -o sqliteex
Quote from Wikipedia:
Single Compilation Unit is a technique of computer programming for the C/C++ languages, which reduces compilation time and aids the compiler to perform program optimization even when the compiler itself is lacking support for whole program optimization or precompiled headers.
http://en.wikipedia.org/wiki/Single_Compilation_Unit
Development is mostly edit->compile until success cycle. When you have separately compiled files you can just recompile only file which was modified, which makes rebuild much faster. Last line is not compilation but linking of compiled object files into target executable.
Also as Mysticial noted, you have mixture of C and C++

g++ compiling option

What are options for compile .cpp file into .s and .o without linking it.
I used g++ -s -c but it only produced .o file.
g++ -s with create undefined reference to main (because it a class implementation not a main)
The option to generate asm files is -S, capital S on gcc (you were using -s).