Source-Based Coverage does not report uninstantiated templates as "untested"

[carlosgalvezp]

Hi!

I find that Clang's Source-Based Coverage does not report templates as "untested", leading to fake high coverage numbers.
I understand that templates are templates, and that they don't generate code until they are instantiated. That would make sense on coverage tools that depend on code being generated, like GCOV. But Clang is different, it operates on the AST - and the templates (even though not instantiated) definitely exist in the AST.

So I wonder why can't Clang report that template as untested? Is there anything I can do to achieve the desired behavior?

Example output:

    1|       |int foo()
    2|      0|{
    3|      0|  return 0;
    4|      0|}
    5|       |
    6|       |template <typename T>
    7|       |T bar()
    8|       |{
    9|       |  return T{};
   10|       |}
   11|       |
   12|       |int main()
   13|      1|{}
   14|       |
   15|       |

The regular function clearly shows as untested (0 times executed), whereas the template function is not counted towards coverage.

Thanks!

[chapuni]

Clang's covmap is based on function instrumentation in codegen. We have to enhance covmap (in object files) for uninstantiated templates.

[bartlettroscoe]

Yea, this is an interesting problem for implicitly instantiated template code. If a template function is never instantiated, then how could you instrument the counts in the binary, because there is no binary code for the function at all. (As far as the binaries are concerned, the function does not even exist.)

For templated classes, you might solve the problem by explicitly instantiating all of your template cases for some arbitrary data-types and make sure those get put into the binaries? I tried that and it did not seem to work. (Many need to look into that more.)

You might be able to add a new Clang compiler coverage option to tell it to generate instantiations for any functions that don't have them. But that would be very complex and might add a lot of cost to the object file builds and/or links. But even if you did add such an option, how would the compiler know a set of valid types to instantiate the non-instantiated functions that satisfy the type requirements? That just seems completely unworkable.

So it seems you would need to implement a special coverage infrastructure just for non-instantiated template functions. Is that worth all of the effort?

This is another good reason to explicitly instantiate as much C++ template code as you can 👍

[carlosgalvezp]

then how could you instrument the counts in the binary

My hope was that with Source-Based Coverage, you don't need any code generation in the binary, instead you compute coverage only based on info from the AST (where the uninstantiated template exists). Am I misunderstanding the docs?

It’s called “source-based” because it operates on AST and preprocessor information directly.

[bartlettroscoe]

For my part, for starters, I just want to the LLVM Clang source-based coverage support to not have any regressions w.r.t. to the GCov-compatible support. And since GCov-compatible coverage can't do anything with non-instantiated template functions, I am far less concerned about this than the other issues like #134927 and #119299.