Compiling C++-code without a file

Question

I'm trying to compile some C++ code using your standard g++ compiler. However, rather than compiling from a file:

main.cpp:

#include <iostream>

int main(){
    std::cout << "Hello World!\n";
    return 0;
}

I would prefer to do something like

g++ ... "#include <iostream>\n int main(){ std::cout << \"Hello World!\n\"; return 0;}"

A previous post from stackoverflow showed that

echo "int main(){}" | gcc -Wall -o testbinary -xc++ -

works but I would like to know how it works and better yet, if there is a way to do this without the need to pipe the contents.

EDIT:

I'm doing run-time code generation where I need to generate a shared library and load the functions created.

I thought there would be a flag to tell the compiler "hey, I'm giving you the source code and not the file".

Thanks again for the help!

Answer 1

echo "int main(){}" | gcc -Wall -o testbinary -xc++ -

works but I would like to know how it works and better yet, if there is a way to do this without the need to pipe the contents.

Alternatively you can say (e.g. in a shell-script):

gcc -Wall -o testbinary -xc++ - << EOF
int main(){}
EOF

Answer 2

The compiler reads from an input source - either the stdin or a file supplied. You need a pipe to supply something from elsewhere to the compiler. There is no other choice (and of course, some compilers may not have an option to read from stdin either)

Answer 3

You mention generating C (or C++) code on the fly and then compiling it and dlopen-ing it.

I'm doing the same in MELT (a domain specific language to extend GCC).

I don't see any valid reason to avoid putting the code in some (temporary) file. Writing even a million line of generated C or C++ lines is quite quick (in MELT, less than a few seconds, and most of that time is not the I/O!). Compiling that is much much slower (a few dozens of seconds at least), and the interest of generating C or C++ code is notably to take advantage of the optimizations provided by GCC (or some other compiler). Avoiding generating a file would win you just some milliseconds (you won't even be able to significantly measure the difference).

So just generate your file in some temporary *.c file (you could use hash or timestamp techniques to generate a unique file name), then have GCC compile it into some *.so (perhaps by fork-ing some make process, like I do in MELT), then remove that temporary file (perhaps using atexit).

^{BTW, this technique is practically compatible with human interaction on current PCs. MELT has a read-eval-print-loop which generates a new C++ file of a few hundred lines, compiles and dlopen-s it, on each interaction, and it is quite usable!}

Avoiding the generation of the file is painful, and the gain is absolutely negligible. You might generate it in some tmpfs filesystem on Linux (e.g. in /tmp/). Most of the time would be spent by GCC compiling that file (especially if you compile with some optimization e.g. gcc -O -fPIC -shared somefile.c -o someplugin.so). The time to write it on disk (by your program) and to read it (and even parse it, for C) by GCC is negligible. Use the -ftime-report option of GCC to understand where GCC is spending its time, it is not in parsing as soon as your pass -O to GCC.

^{Some versions of GCC or of other C compilers might reject stdin as input; some C compilers might want to mmap the C source file (e.g. by using "rm" as mode for fopen on Glibc). In general, compiling something which is not a *.c file as C is non-standard, etc... So better avoid doing that, since the gain is negligible.}

If you don't care at all about optimization and want quick compilation of C (not C++) into very slow machine code, consider using instead tinycc (at least on 32 bits machines, on 64 bits it could be buggy) which has a library able to compile some C code inside a string. tcc and its libtcc.a is able to compile very fast (more than 10x times GCC) some C code but the performance of the produced machine code is very bad (very slow, unoptimized code).

Once GCC has compiled your generated C code, you can of course remove the generated source code file. (and you could even also remove the .so after having dlopen-ed it).

BTW, you could use clang++ to compile the generated C++ file. And you might use LLVM (and generate internal LLVM representation, without using any file) instead.

See also this answer.

I'm doing run-time code generation where I need to generate a shared library and load the functions created.

Consider also using JIT-compiling libraries such as libgccjit, LLVM or asmjit. Look also into SBCL (which generates machine code at almost every REPL interaction). Of course, you need to understand the relevant calling conventions and ABI on your system. So read also this, elf(5) and Drepper's paper How To Write Shared Libraries

Answer 4

How about popen("gcc -o -xc++ -", "w");? Gives you aFILE*` but the output goes straight into GCC.

BTW, there is no point in using the -Wall flag. That's for human consumption. In fact, -w -Wfatal-errors makes sense. Either it compiles or it doesn't.

Answer 5

-x is needed to specific the language you will compile.

here is an example:

gcc -x c - <<eof
#include <stdio.h>

void foo()
{
    int a = 10;
    static int sa = 10;

    a += 5;
    sa += 5;

    printf("a = %d, sa = %d\n", a, sa);
}


int main()
{
    int i;

    for (i = 0; i < 10; ++i)
        foo();
}
eof

Answer 6

On Unix you can automate all process creating C/C++ programs by usage shell.

1.Create file (example run_c.sh)

2.Paste code to this file

#!/bin/bash

# Generate random filename
RANDOM_FILENAME=`cat /dev/urandom | tr -dc 'A-Za-z0-9' | fold -w 20 | head -n 1`
RANDOM_FILENAME=_$RANDOM_FILENAME
readonly RANDOM_FILENAME

# random filename for a C file
RANDOM_FILENAME_C=$RANDOM_FILENAME.c
readonly RANDOM_FILENAME

# catch stdin as code
CODE=$1

# names headers of the C standart language
declare -a C_STANDART_LIBRARY=('stdio' 'errno' 'assert' 'math' 'stdarg' 'stdbool' 'stdlib' 'string' 'time')

# create the C file
touch $RANDOM_FILENAME_C

# write a first line to the file
printf '// Compile C code from stdin\n\n' >> $RANDOM_FILENAME_C

# make include all headers to the file
for header in "${C_STANDART_LIBRARY[@]}"
do
    printf '#include <%s.h>\n' $header >> $RANDOM_FILENAME_C
done

# make include all headers to the file
printf "\nint main(int argc, char *argv[]) {\n" >> $RANDOM_FILENAME_C

# split the code from stdin by ';' to an array lines
IFS=';' read -r -a LINES_CODE <<< "$CODE"

# write line by line the code
for line in "${LINES_CODE[@]}"
do
    printf '%s;\n' "$line" | sed -e 's/^[[:space:]]//' | sed -e 's/^/\t/' >> $RANDOM_FILENAME_C
done

# write ending the function 'main'
printf "\treturn 0;\n}\n" >> $RANDOM_FILENAME_C

# uncomment for display the C code
# cat $RANDOM_FILENAME_C

# compile the file
gcc -Wall -std=c11 -o $RANDOM_FILENAME $RANDOM_FILENAME_C

# run programm if no errors
if [ -f "$RANDOM_FILENAME" ];
    then
    ./$RANDOM_FILENAME
fi

# rm the file with source code
rm $RANDOM_FILENAME_C
# rm the compliled file

if [ -f "$RANDOM_FILENAME" ];
    then
        rm $RANDOM_FILENAME
fi

3.Make this file as executable

$ chmod +x run_c.sh 
$ ls -l | grep run_c.sh 
-rwxr-xr-x 1 setivolkylany setivolkylany 1589 Dec 26 11:19 run_c.sh

Usage:

$ ./run_c.sh 'int a = 4; int b = 6; int c = a + b; printf("%d + %d = %d\n", a, b, c)'
4 + 6 = 10

$ ./run_c.sh 'puts("Worked");'
Worked

Testing environment

$ lsb_release -a
No LSB modules are available.
Distributor ID: Debian
Description:    Debian GNU/Linux 8.6 (jessie)
Release:    8.6
Codename:   jessie
$ uname -a
Linux localhost 3.16.0-4-amd64 #1 SMP Debian 3.16.36-1+deb8u2 (2016-10-19) x86_64 GNU/Linux

Inspired from http://django-notes.blogspot.com/2013/01/compiling-c-from-stdin.html and https://github.com/vgvassilev/cling