如何使clang -E省略预编译头

Question

PrecompiledHeader.h:

#include "stdio.h"

main.cpp:

#include "PrecompiledHeader.h"
#include "stdio.h"

int main()
{
   return 123;
}

Creating precompiled header:

clang -x c++-header PrecompiledHeader.h -o PrecompiledHeader.pch

Running clang preprocessor on main.cpp:

clang main.cpp -include-pch PrecompiledHeader.pch -E 

This currently outputs many many many pages of output (stdio.h). However, what I would like to get is only the main function, and have the contents of PrecompiledHeader.h be omitted from the output.

Is there any way to make clang do this? (if someone knows the answer to the same question for visualstudio's cl.exe I'd love to know about it too :)

Answer 1

Hardly such a way exists or will be built into clang (or any other C++ compiler) in the future. The problem is that precompiled headers are used to speed up the compilation step which is usually significantly more expensive than the preprocessing step. As a result, if you are going to just preprocess your source, the precompiled header will simply not be used. One way that has a negligibly small chance of producing what you want is to use the -include option instead of the -include-pch option (note that you must specify the *.h rather than the *.pch file to it):

clang main.cpp -include PrecompiledHeader.h -E

The guaranteed way of solving your problem is to pipe the preprocessed output through a simple filter program that looks at the # line "file" directives and removes text coming from #include ed files:

clang main.cpp -E|remove_included_code

remove_included_code can be easily implemented in python, bash, C/C++, etc. Here is a C++ implementation (C++ was chosen so that it can be most easily used under Windows):

remove_included_code.cpp

#include <iostream>
#include <cstdlib>

using namespace std;
typedef std::string Str;

bool isLineDirective(const Str& line)
{
    return line.size() >= 3
        && line[0] == '#'
        && line[1] == ' '
        && isdigit(line[2]);
}

Str getFile(const Str& line)
{
    const Str::size_type start = line.find_first_of('"') + 1;
    const Str::size_type end = line.find_first_of('"', start);
    return line.substr(start, end - start);
}

int main()
{
    Str line;
    getline(cin, line);
    if ( !isLineDirective(line) ) {
        cerr << "Error: Input must start with a '# line \"file\"' directive\n";
        exit(1);
    }

    const Str startFile = getFile(line);
    Str currentFile = startFile;
    while ( getline(cin, line) ) {
        if ( isLineDirective(line) )
            currentFile = getFile(line);
        else if (currentFile == startFile )
            cout << line << endl;
    }

    return 0;
}

The advantage of this solution is that it will work with all compilers.

Answer 2

edit: I don't see anything special about precompiled headers in this case - any means of conditionally preventing the expansion of an #include will do.

I achieve this for standard header includes by wrapping in an ifdef, such that the preprocessed output contains #include "foo" but not the contents. For example,

#ifdef PRECOMPILE
#define TMP #include <stdio.h>
TMP
#undef TMP
#else
#include <stdio.h>
#endif

Then pass -DPRECOMPILE along with -E.

The preprocessed output then contains the unexpanded #include. I find this more useful than the simpler alternative of wrapping the #include in #ifdef when reading the preprocessed output.

Primarily though, this means I can run macro-heavy code through the preprocessor then clang-format before compiling as normal, for a far improved debugging experience.