[Coverage] Add comment to skipped regions

[zequanwu]

Summary

Bug filled here: https://bugs.llvm.org/show_bug.cgi?id=45757.
Add comment to skipped regions so we don't track execution count for lines containing only comments.

[hans]

Not sure if this is good idea to untrack comments, it breaks many tests under CoverageMapping.

I didn't look, but I'm surprised there are many coverage tests that have comments in them. If the comments are not important for those tests, maybe they could be removed? As long as we keep one that tracks the intended behavior of coverage on comments.

clang/lib/Parse/Parser.cpp

37 ↗

(On Diff #277157)

I don't think this is the right way to do it. It seems this callback is intended for #if macros that exclude part of the file from preprocessing.

[zequanwu]

Classfiying comments as SkippedRegion, https://github.com/llvm/llvm-project/blob/master/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L217
This will result overlapping SkippedRegion for comments and macro. Maybe, we shuold merge the overlapped SkippedRegion at the end.
Example:

File 0, 1:12 -> 6:2 = #0
 Skipped,File 0, 2:3 -> 4:9 = 0
 Skipped,File 0, 2:15 -> 2:25 = 0
   1|      1|int main() {
   2|       |  #ifdef TEST // comment
   3|       |  int x = 1;
   4|       |  #endif
   5|      1|  return 0;
   6|      1|}

[zequanwu]

clang/lib/Parse/Parser.cpp

37 ↗

(On Diff #277157)

I believe we want to classify comments as SkippedRegion, https://github.com/llvm/llvm-project/blob/master/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L217.
Added a new method CommentSkipped to add comment range to skipped ranges.

[zequanwu]

In D83592#2147881, @hans wrote:

Not sure if this is good idea to untrack comments, it breaks many tests under CoverageMapping.

I didn't look, but I'm surprised there are many coverage tests that have comments in them. If the comments are not important for those tests, maybe they could be removed? As long as we keep one that tracks the intended behavior of coverage on comments.

The comments in those coverage tests are used for FileCheck, like //CHECK:. So, we can't remove those ones.

[zequanwu]

Merge overlapped SkippedRegion.

[vsk]

@zequanwu thanks for working on this. Instead of threading CommentSkipped through PPCallbacks, wdyt of taking advantage of the existing CommentHandler interface? To simplify things, we can add a static method like 'CoverageMappingGen::setupPreprocessorCallbacks(Preprocessor &)' and call that from CodeGenAction::CreateASTConsumer.

llvm/lib/ProfileData/Coverage/CoverageMappingWriter.cpp

152 ↗

(On Diff #277538)

This seems like a lot of complexity to add to handle a narrow case. Is it necessary to merge skipped regions early in the process? Note that llvm's SegmentBuilder takes care of merging regions at the very end.

183 ↗

(On Diff #277538)

This is stack use after free, right? This needs to release ownership of the 'MergedRegions' container.

[zequanwu]

In D83592#2148376, @vsk wrote:

taking advantage of the existing CommentHandler interface? To simplify things, we can add a static method like 'CoverageMappingGen::setupPreprocessorCallbacks(Preprocessor &)' and call that from CodeGenAction::CreateASTConsumer.

Sorry, I don't quite understand this. I am already using ActionCommentHandler to handle this one inside HandleComment.

llvm/lib/ProfileData/Coverage/CoverageMappingWriter.cpp

152 ↗

(On Diff #277538)

Merging at here is to avoid duplicate output for option -dump-coverage-mapping. Like the following example to avoid Skipped,File 0, 2:3 -> 4:9 = 0 and Skipped,File 0, 2:15 -> 2:25 = 0 to be outputted at the same time. They should be merged into 1 region Skipped,File 0, 2:3 -> 4:9 = 0

File 0, 1:12 -> 6:2 = #0
 Skipped,File 0, 2:3 -> 4:9 = 0
 Skipped,File 0, 2:15 -> 2:25 = 0
   1|      1|int main() {
   2|       |  #ifdef TEST // comment
   3|       |  int x = 1;
   4|       |  #endif
   5|      1|  return 0;
   6|      1|}

So, we need to do it early.

[vsk]

In D83592#2148638, @zequanwu wrote:

In D83592#2148376, @vsk wrote:

taking advantage of the existing CommentHandler interface? To simplify things, we can add a static method like 'CoverageMappingGen::setupPreprocessorCallbacks(Preprocessor &)' and call that from CodeGenAction::CreateASTConsumer.

Sorry, I don't quite understand this. I am already using ActionCommentHandler to handle this one inside HandleComment.

ActionCommentHandler seems a bit specific to Sema. This is what I had in mind: https://github.com/vedantk/llvm-project/commit/5101dd5dcd92742805069dba6b3d6d6846ef3755.

llvm/lib/ProfileData/Coverage/CoverageMappingWriter.cpp

152 ↗

(On Diff #277538)

I see that there are duplicate 'Skipped' regions emitted in this case, but I'm not sure what problems this causes. For testing, we could check that both skipped regions are emitted, or perhaps only check that the outermost skipped region is emitted and ignore others. Is there some other kind of hard error (like an assert) caused by having nested skipped regions? If not, perhaps it's not worth it to merge them.

[zequanwu]

Vedant, thanks for your suggestions.

• Remove merging function.
• Address comments.

[zequanwu]

llvm/lib/ProfileData/Coverage/CoverageMappingWriter.cpp

152 ↗

(On Diff #277538)

No, it doesn't cause any error.

[zequanwu]

Remove old code.

[zequanwu]

Accidentally uploaded binary.. removed now.

[vsk]

Before updating any tests, maybe it's worth doing a quick experiment with comments placed in different contexts, to see whether adding these skipped regions is really sufficient. For example, given:

1|  for (auto x : collection) {
2|    // Explain the loop.
3|  }

The loop region covers lines 1-3. If we skip the comment range on line 2, does an execution count from the loop region still get picked up? I'd expect it to. It's possible that we need more information from the preprocessor about whether the line is fully comment/whitespace-only.

[zequanwu]

In D83592#2148833, @vsk wrote:

Before updating any tests, maybe it's worth doing a quick experiment with comments placed in different contexts, to see whether adding these skipped regions is really sufficient. For example, given:

1|  for (auto x : collection) {
2|    // Explain the loop.
3|  }

The loop region covers lines 1-3. If we skip the comment range on line 2, does an execution count from the loop region still get picked up? I'd expect it to. It's possible that we need more information from the preprocessor about whether the line is fully comment/whitespace-only.

Here is what I got:

$ clang -fcoverage-mapping -fprofile-instr-generate /tmp/a.c -Xclang -dump-coverage-mapping && ./a.out && llvm-profdata merge -sparse default.profraw -o a.profdata && llvm-cov show ./a.out -instr-profile=a.profdata
main:
  File 0, 1:12 -> 6:2 = #0
  File 0, 2:19 -> 2:25 = (#0 + #1)
  File 0, 2:27 -> 2:30 = #1
  Gap,File 0, 2:31 -> 2:32 = #1
  File 0, 2:32 -> 4:4 = #1
  Skipped,File 0, 3:5 -> 3:15 = 0
    1|      1|int main() {
    2|     11|  for (int i = 0; i < 10; i++) {
    3|       |    // comment
    4|     10|  }
    5|      1|  return 0;
    6|      1|}

For those failed test cases, they are caused by extra Skipped, File ... lines which invalidate some CHECK-NEXT.
I could either change CHECK-NEXT to CHECK or moving those checks inside function to above the function, since comments outside functions will not be tracked.

[hans]

The comments in those coverage tests are used for FileCheck, like //CHECK:. So, we can't remove those ones.

Oh, I didn't think about that :-)

It's a bit unusual and annoying that the test expectations end up affecting the test output. For the comments that are not really part of the test, maybe we could do something to exclude them, like running 'sed' before compiling, or wrapping them in #if 0 blocks or something.

But figuring that out seems less important than figuring out how to implement the feature, and I think the current approach looks promising.

[zequanwu]

Fix failed test cases with sed to remove comments.

[vsk]

Could you add an end-to-end llvm-cov test (see e.g. compiler-rt/test/profile/Linux/coverage_ctors.cpp)? Here are some important cases I think we should check:

• /* comment at the start of a line */ expr;
• expr; /* comment at the end of a line */
• expr; // comment at the end of a line
• // comment spanning entire line

In all but the last case, llvm-cov should report an execution count for the line. Testing multi-line variations of those cases would also be helpful.

clang/test/CoverageMapping/break.c

1–2

Could you introduce a lit substitution in clang/test/lit.cfg.py for this (say, '%strip_comments'?), so that there's just one copy of the sed command?

[zequanwu]

Add lit substitution %strip_comments -> sed 's/\/\/.*//' %s > %T/%basename_t.

[zequanwu]

%strip_comments -> sed 's/[ \t]*\/\/.*//' %s > %T/%basename_t.

[zequanwu]

In D83592#2151217, @vsk wrote:

Could you add an end-to-end llvm-cov test (see e.g. compiler-rt/test/profile/Linux/coverage_ctors.cpp)? Here are some important cases I think we should check:

• /* comment at the start of a line */ expr;
• expr; /* comment at the end of a line */
• expr; // comment at the end of a line
• // comment spanning entire line

In all but the last case, llvm-cov should report an execution count for the line. Testing multi-line variations of those cases would also be helpful.

llvm-cov doesn't report the execution count for the first 3 liens... I will try to fix that.

[zequanwu]

In D83592#2151773, @zequanwu wrote:

In D83592#2151217, @vsk wrote:

Could you add an end-to-end llvm-cov test (see e.g. compiler-rt/test/profile/Linux/coverage_ctors.cpp)? Here are some important cases I think we should check:

• /* comment at the start of a line */ expr;
• expr; /* comment at the end of a line */
• expr; // comment at the end of a line
• // comment spanning entire line

In all but the last case, llvm-cov should report an execution count for the line. Testing multi-line variations of those cases would also be helpful.

llvm-cov doesn't report the execution count for the first 3 liens... I will try to fix that.

The problem is that simply marking comment regions as SkippedRegion doesn't give enough information for llvm-cov about if there is code area before or after comments in the same line.

$ clang++ -fcoverage-mapping -fprofile-instr-generate /tmp/a.cpp -Xclang -dump-coverage-mapping && ./a.out && llvm-profdata merge -sparse default.profraw -o a.profdata && llvm-cov show ./a.out -instr-profile=a.profdata -debug-only="coverage-mapping"
main:
  File 0, 1:12 -> 7:2 = #0
  Skipped,File 0, 2:3 -> 2:39 = 0
  Skipped,File 0, 3:15 -> 3:49 = 0
  Skipped,File 0, 4:15 -> 4:46 = 0
  Skipped,File 0, 5:3 -> 5:34 = 0
Counter in file 0 1:12 -> 7:2, #0
Counter in file 0 2:3 -> 2:39, 0
Counter in file 0 3:15 -> 3:49, 0
Counter in file 0 4:15 -> 4:46, 0
Counter in file 0 5:3 -> 5:34, 0
Emitting segments for file: /tmp/a.cpp
Combined regions:
  1:12 -> 7:2 (count=1)
  2:3 -> 2:39 (count=0)
  3:15 -> 3:49 (count=0)
  4:15 -> 4:46 (count=0)
  5:3 -> 5:34 (count=0)
Segment at 1:12 (count = 1), RegionEntry
Segment at 2:3 (count = 0), RegionEntry, Skipped
Segment at 2:39 (count = 1)
Segment at 3:15 (count = 0), RegionEntry, Skipped
Segment at 3:49 (count = 1)
Segment at 4:15 (count = 0), RegionEntry, Skipped
Segment at 4:46 (count = 1)
Segment at 5:3 (count = 0), RegionEntry, Skipped
Segment at 5:34 (count = 1)
Segment at 7:2 (count = 0), Skipped
    1|      1|int main() {
    2|       |  /* comment at the start of a line */ int x = 0;
    3|       |  int y = 0;  /* comment at the end of a line */
    4|       |  int z = 0;  // comment at the end of a line
    5|       |  // comment spanning entire line
    6|      1|  return 0;
    7|      1|}
    8|       |

One way I could think is probably when we visit decl in CounterCoverageMappingBuilder, check for if there is SkippedRegion in the same line and then mark the decl range as CodeRegion. For the example, we will have 3 more CodeRegion which covers the ranges of int x = 0, int y = 0 and int z = 0.

[vsk]

! In D83592#2156758, @zequanwu wrote:
One way I could think is probably when we visit decl in CounterCoverageMappingBuilder, check for if there is SkippedRegion in the same line and then mark the decl range as CodeRegion. For the example, we will have 3 more CodeRegion which covers the ranges of int x = 0, int y = 0 and int z = 0.

I don't think that will work well, because a decl can span multiple lines (which in turn can include comments).

The key issue seems to be that -- even having SourceRanges for all comments -- we don't know whether a line has non-whitespace, non-comment tokens. If it does, the line should have an execution count (and we don't even need to bother with emitting a skipped region covering the line). It sounds like we need a different hook in the preprocessor that reports SourceRanges for lines with no non-comment, non-whitespace tokens. Practically, I think this can be wired up just like a CommentHandler (maybe it could be called WhitespaceHandler?). One side-benefit of introducing a new hook like this is that coverage will handle whitespace-only lines the same way as comment-only lines.

There's probably more than one way to approach this. One thing to be aware of: llvm's LineCoverageStats class is the one responsible for determining whether a line is "mapped" (i.e. whether it has an execution count). It assumes that when a line begins with a skipped region, the subsequent portion of the line must also be skipped. If we only emit skipped regions for fully whitespace-like lines, that's fine. If not, depending on how C-style comments are handled, that may need updating.

[zequanwu]

In D83592#2157130, @vsk wrote:

! In D83592#2156758, @zequanwu wrote:
One way I could think is probably when we visit decl in CounterCoverageMappingBuilder, check for if there is SkippedRegion in the same line and then mark the decl range as CodeRegion. For the example, we will have 3 more CodeRegion which covers the ranges of int x = 0, int y = 0 and int z = 0.

I don't think that will work well, because a decl can span multiple lines (which in turn can include comments).

The key issue seems to be that -- even having SourceRanges for all comments -- we don't know whether a line has non-whitespace, non-comment tokens. If it does, the line should have an execution count (and we don't even need to bother with emitting a skipped region covering the line). It sounds like we need a different hook in the preprocessor that reports SourceRanges for lines with no non-comment, non-whitespace tokens. Practically, I think this can be wired up just like a CommentHandler (maybe it could be called WhitespaceHandler?). One side-benefit of introducing a new hook like this is that coverage will handle whitespace-only lines the same way as comment-only lines.

There's probably more than one way to approach this. One thing to be aware of: llvm's LineCoverageStats class is the one responsible for determining whether a line is "mapped" (i.e. whether it has an execution count). It assumes that when a line begins with a skipped region, the subsequent portion of the line must also be skipped. If we only emit skipped regions for fully whitespace-like lines, that's fine. If not, depending on how C-style comments are handled, that may need updating.

Thanks for the reply. I will work on that.

[zequanwu]

Rebase and address comments.

• Keep track of token locations before and after comment regions by onToken in Preprocessor so when emitting SkippedRegion we can determine if the region should be emitted or not.
• Add an end-to-end llvm-cov test case.

[zequanwu]

arc diff --update automatically formatted test case. Reverted.

[vsk]

@zequanwu at a high level, I think this is the right approach and it looks nice overall. I do have some feedback (inline). Thanks!

clang/lib/CodeGen/CoverageMappingGen.cpp

305

Could you restructure this to avoid mutating a SpellingRegion? This can aid debugging (the unmodified struct remains available for inspection). One way to do this might be to call the function "adjustSkippedRange" and have it return an Optional<SpellingRegion>.

306

What exactly is 'Range' in updateSkippedRange? It seems like it's the {prev,next}TokLoc pair from SkippedRegion, but it's not obvious based on a cursory read. It would help to rename 'Range' to something more specific ('InnermostNonCommentRange'? 'OverlappingExecutedTokenRange'?).

clang/lib/CodeGen/CoverageMappingGen.h

50

It'd be more self-descriptive to replace the pair with some struct SkippedRange { SourceRange SkippedRange; SourceLocation PrevTokLoc, NextTokLoc; }.

51

Optional<unsigned> LastCommentIndex would be slightly more idiomatic.

54–60

Please leave short inline comments explaining the respective roles of PrevTokLoc and BeforeCommentLoc.

clang/test/lit.cfg.py

96

Bit of a nitpick, but I don't think it'll necessarily end up being more convenient to have "%T/%basename_t" hardcoded in this substitution (strawman, but: you can imagine a test that needs to strip comments from two different files). It'd be nice to be more explicit and write the run lines like:

RUN: %strip_comments %s > %t.stripped.c
RUN: clang ... %t.stripped.c

compiler-rt/test/profile/Linux/coverage_comments.cpp

1 ↗

(On Diff #279331)

I don't think there's anything Linux or gold-specific about this test. Could you move the test up one directory, so we can run it on Darwin/Windows/etc.?

[zequanwu]

Address comments.

[zequanwu]

Missed something. Updated

[vsk]

The testing looks really good. Just a few more requests for documentation (inline).

clang/lib/CodeGen/CoverageMappingGen.cpp

304

This could use some description of what adjustment is done, e.g. "This shrinks the skipped range if it spans a line that contains a non-comment token. If shrinking the skipped range would make it empty, this returns None."

clang/lib/CodeGen/CoverageMappingGen.h

36

It'd be helpful to leave inline documentation for these fields as well. It's clear from context that 'Range' is the skipped source range, but it's not as clear what {Prev,Next}TokLoc are.

49

Please end sentences with a '.'

54–60

How does "Location of the token parsed before HandleComment is called. This is updated every time Preprocessor::Lex lexes a new token." sound?

[zequanwu]

• Address comments
• Update summary.

[MaskRay]

New tests should use [[#@LINE]] instead of [[@LINE]]

https://llvm.org/docs/CommandGuide/FileCheck.html

To support legacy uses of @LINE as a special string variable, FileCheck also accepts the following uses of @LINE with string substitution block syntax: [[@LINE]], [[@LINE+<offset>]] and [[@LINE-<offset>]] without any spaces inside the brackets and where offset is an integer.

[zequanwu]

Change @LINE to # @LINE.

[zequanwu]

remove unnecessary header.

[vsk]

Thanks, lgtm.

[MaskRay]

compiler-rt/test/profile/coverage_comments.cpp

10

I think you can just use CHECK-NEXT: for each line and remove duplicated code on the right side. See some recent gcov-* tests I added.

[zequanwu]

Landed here, https://reviews.llvm.org/rGabd45154bdb6b76c5b480455eacc8c75b08242aa
I put the wrong diff ID..

[zequanwu]

compiler-rt/test/profile/coverage_comments.cpp

10

Thanks, I removed the duplicated code when fixed a coverage test failure.

[thakis]

Looks like this breaks tests on Windows: http://45.33.8.238/win/20315/step_7.txt

Please take a look, and if it takes a while to investigate please revert while you look.

[zequanwu]

In D83592#2165818, @thakis wrote:

Looks like this breaks tests on Windows: http://45.33.8.238/win/20315/step_7.txt

Please take a look, and if it takes a while to investigate please revert while you look.

Fixed

[hans]

This caused asserts in Chromium's coverage builds: https://bugs.chromium.org/p/chromium/issues/detail?id=1108352
I've reverted it in the meantime (238bbd48c5a5f84deca36e5df980241578f7c1df).

It also looks like the commit landed with the wrong Phabricator review number.

[MaskRay]

(This was committed within 10 minutes after it was approved. As a large change with updates to some sensitive places like clang/Lex/Preprocessor.h, this probably should have been waited a bit longer.)

[vsk]

@zequanwu I'm not sure whether this is something you've already tried, but for frontend changes, it can be helpful to verify that a stage2 clang self-host with assertions enabled completes successfully. For coverage specifically, it's possible to do that by setting '-DLLVM_BUILD_INSTRUMENTED_COVERAGE=On' during the stage2 cmake step.

[zequanwu]

In D83592#2167926, @vsk wrote:

@zequanwu I'm not sure whether this is something you've already tried, but for frontend changes, it can be helpful to verify that a stage2 clang self-host with assertions enabled completes successfully. For coverage specifically, it's possible to do that by setting '-DLLVM_BUILD_INSTRUMENTED_COVERAGE=On' during the stage2 cmake step.

I didn't know that before. I will try.

When including some standard libraries, the assertion assert(SM.isWrittenInSameFile(LocStart, LocEnd) && "region spans multiple files"); fails, like <stdlib.h> or <cmath> etc, still investigating.

[zequanwu]

I found the problem is that I was trying to merge two skipped regions when they are adjacent.
So, the following code will fail at assertion, because the skipped regions are in different files, but are merged.

$ cat a.h
// comment
$ cat a.c
#include "a.h"
// comment
int main() {}

[zequanwu]

Fix the bug about merging skipped regions. Simple don't merge, because adjustSkippedRange will handle those cases if NextTokLoc is invalid, which will just skip the second if condition.

[zequanwu]

Just tried the cmake option -DLLVM_BUILD_INSTRUMENTED_COVERAGE=On, the result still shows count for comments... but it pass the coverage_comments.cpp test case, need more investigation.

[zequanwu]

In Preprocessor.cpp, don't increment TokenCount if LexLevel == 0.

I tested this with chromium crypto_unittests. It doesn't track comments regions.

I don't why when using the cmake option -DLLVM_BUILD_INSTRUMENTED_COVERAGE=On to test coverage for clang itself, it does tracking comments.
Also, with that option on, llvm-cov crashes at assertion:llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp:578: virtual Expected<const char *> (anonymous namespace)::VersionedCovMapFuncRecordReader<llvm::coverage::Version4, unsigned long, llvm::support::little>::readCoverageHeader(const char *, const char *, BinaryCoverageReader::DecompressedData &) [Version = llvm::coverage::Version4, IntPtrT = unsigned long, Endian = llvm::support::little]: Assertion (CovMapVersion)CovHeader->getVersion<Endian>() == Version' failed.`

[zequanwu]

clang/lib/Lex/Preprocessor.cpp

973

@hans , can you take a look on this part? I saw TokenCount was introduced for a warning -Wmax-tokens.

[hans]

clang/lib/Lex/Preprocessor.cpp

973

Can you explain why things are changing here?

The idea of TokenCount is to simply count the preprocessor tokens. At this point I think you have more knowledge here than I did when I added it :)

[zequanwu]

clang/lib/Lex/Preprocessor.cpp

973

In CodeGen::CoverageMappingModuleGen::setUpCoverageCallbacks, I set OnToken to a lambda to update PrevTokLoc after lexing a new token. But, the original condition if (LexLevel == 0 && !Result.getFlag(Token::IsReinjected)) will not call OnToken if it's lexing a directive, like #if, #define etc, because the LexLevel is greater than 0. In order to update PrevTokLoc even when lexing directive, I add PreprocessToken which will be set to true in CodeGen::CoverageMappingModuleGen::setUpCoverageCallbacks just to invoke OnToken without increment TokenCount when lexing directives.

[zequanwu]

Change newSR.ColumnEnd = 1 to newSR.ColumnEnd = SR.ColumnStart + 1 to ensure ColumnEnd >= ColumnStart.

[hans]

clang/lib/Lex/Preprocessor.cpp

973

Ah, I see. That sounds okay to me.

[vsk]

In D83592#2170912, @zequanwu wrote:

I don't why when using the cmake option -DLLVM_BUILD_INSTRUMENTED_COVERAGE=On to test coverage for clang itself, it does tracking comments.
Also, with that option on, llvm-cov crashes at assertion:llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp:578: virtual Expected<const char *> (anonymous namespace)::VersionedCovMapFuncRecordReader<llvm::coverage::Version4, unsigned long, llvm::support::little>::readCoverageHeader(const char *, const char *, BinaryCoverageReader::DecompressedData &) [Version = llvm::coverage::Version4, IntPtrT = unsigned long, Endian = llvm::support::little]: Assertion (CovMapVersion)CovHeader->getVersion<Endian>() == Version' failed.`

Just to double-check: are you using llvm-{cov,profdata} binaries from the stage1 llvm build to produce reports for stage2 (coverage-instrumented) binaries?

[zequanwu]

In D83592#2174600, @vsk wrote:

In D83592#2170912, @zequanwu wrote:

I don't why when using the cmake option -DLLVM_BUILD_INSTRUMENTED_COVERAGE=On to test coverage for clang itself, it does tracking comments.
Also, with that option on, llvm-cov crashes at assertion:llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp:578: virtual Expected<const char *> (anonymous namespace)::VersionedCovMapFuncRecordReader<llvm::coverage::Version4, unsigned long, llvm::support::little>::readCoverageHeader(const char *, const char *, BinaryCoverageReader::DecompressedData &) [Version = llvm::coverage::Version4, IntPtrT = unsigned long, Endian = llvm::support::little]: Assertion (CovMapVersion)CovHeader->getVersion<Endian>() == Version' failed.`

Just to double-check: are you using llvm-{cov,profdata} binaries from the stage1 llvm build to produce reports for stage2 (coverage-instrumented) binaries?

I didn't config correctly before. I just tried. It works correctly now, not tracking comments.

[zequanwu]

@vsk Do you think it's ok to reland this commit?

[vsk]

@zequanwu the change that dropped merging of adjacent comments looks good. If no further issues cropped up during stage2 testing, please feel free to re-land. Thanks!

clang/include/clang/Lex/Preprocessor.h

class Preprocessor {
   /// require asking for multiple additional tokens. This counter makes it
   /// possible for Lex to detect whether it's producing a token for the end
   /// of phase 4 of translation or for some other situation.
   unsigned LexLevel = 0;
 
   /// The number of (LexLevel 0) preprocessor tokens.
   unsigned TokenCount = 0;
 
+  /// Preprocess every token regardless of LexLevel.
+  bool PreprocessToken = false;
+
   /// The maximum number of (LexLevel 0) tokens before issuing a -Wmax-tokens
   /// warning, or zero for unlimited.
   unsigned MaxTokens = 0;
   SourceLocation MaxTokensOverrideLoc;
 
 public:
   struct PreambleSkipInfo {
     SourceLocation HashTokenLoc;
public:
 
   /// Register a function that would be called on each token in the final
   /// expanded token stream.
   /// This also reports annotation tokens produced by the parser.
   void setTokenWatcher(llvm::unique_function<void(const clang::Token &)> F) {
     OnToken = std::move(F);
   }
 
+  void setPreprocessToken(bool Preprocess) { PreprocessToken = Preprocess; }
+
   bool isMacroDefined(StringRef Id) {
     return isMacroDefined(&Identifiers.get(Id));
   }
   bool isMacroDefined(const IdentifierInfo *II) {
     return II->hasMacroDefinition() &&
            (!getLangOpts().Modules || (bool)getMacroDefinition(II));
   }
 

clang/lib/CodeGen/CodeGenAction.cpp

for (const CodeGenOptions::BitcodeFileToLink &F :
         return nullptr;
       }
       LinkModules.push_back({std::move(ModuleOrErr.get()), F.PropagateAttrs,
                              F.Internalize, F.LinkFlags});
     }
 
   CoverageSourceInfo *CoverageInfo = nullptr;
   // Add the preprocessor callback only when the coverage mapping is generated.
-  if (CI.getCodeGenOpts().CoverageMapping) {
-    CoverageInfo = new CoverageSourceInfo;
-    CI.getPreprocessor().addPPCallbacks(
-                                    std::unique_ptr<PPCallbacks>(CoverageInfo));
-  }
+  if (CI.getCodeGenOpts().CoverageMapping)
+    CoverageInfo = CodeGen::CoverageMappingModuleGen::setUpCoverageCallbacks(
+        CI.getPreprocessor());
 
   std::unique_ptr<BackendConsumer> Result(new BackendConsumer(
       BA, CI.getDiagnostics(), CI.getHeaderSearchOpts(),
       CI.getPreprocessorOpts(), CI.getCodeGenOpts(), CI.getTargetOpts(),
       CI.getLangOpts(), CI.getFrontendOpts().ShowTimers, std::string(InFile),
       std::move(LinkModules), std::move(OS), *VMContext, CoverageInfo));
   BEConsumer = Result.get();
 

clang/lib/CodeGen/CoverageMappingGen.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_CODEGEN_COVERAGEMAPPINGGEN_H
 #define LLVM_CLANG_LIB_CODEGEN_COVERAGEMAPPINGGEN_H
 
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Lex/PPCallbacks.h"
+#include "clang/Lex/Preprocessor.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace clang {
 
 class LangOptions;
 class SourceManager;
 class FileEntry;
 class Preprocessor;
 class Decl;
 class Stmt;
 
+struct SkippedRange {
+  SourceRange Range;
+  // The location of token before the skipped source range.
+  SourceLocation PrevTokLoc;
+  // The location of token after the skipped source range.
+  SourceLocation NextTokLoc;
+
+  SkippedRange(SourceRange Range, SourceLocation PrevTokLoc = SourceLocation(),
+               SourceLocation NextTokLoc = SourceLocation())
+      : Range(Range), PrevTokLoc(PrevTokLoc), NextTokLoc(NextTokLoc) {}
+};
+
 /// Stores additional source code information like skipped ranges which
 /// is required by the coverage mapping generator and is obtained from
 /// the preprocessor.
-class CoverageSourceInfo : public PPCallbacks {
-  std::vector<SourceRange> SkippedRanges;
+class CoverageSourceInfo : public PPCallbacks, public CommentHandler {
+  // A vector of skipped source ranges and PrevTokLoc with NextTokLoc.
+  std::vector<SkippedRange> SkippedRanges;
+  bool AfterComment = false;
+
 public:
-  ArrayRef<SourceRange> getSkippedRanges() const { return SkippedRanges; }
+  // Location of the token parsed before HandleComment is called. This is
+  // updated every time Preprocessor::Lex lexes a new token.
+  SourceLocation PrevTokLoc;
+  // The location of token before comment.
+  SourceLocation BeforeCommentLoc;
+
+  std::vector<SkippedRange> &getSkippedRanges() { return SkippedRanges; }
 
   void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) override;
+
+  bool HandleComment(Preprocessor &PP, SourceRange Range) override;
+
+  void updateNextTokLoc(SourceLocation Loc);
 };
 
 namespace CodeGen {
 
 class CodeGenModule;
 
 /// Organizes the cross-function state that is used while generating
 /// code coverage mapping data.
class CoverageMappingModuleGen {
   std::vector<llvm::Constant *> FunctionNames;
   std::vector<FunctionInfo> FunctionRecords;
 
   /// Emit a function record.
   void emitFunctionMappingRecord(const FunctionInfo &Info,
                                  uint64_t FilenamesRef);
 
 public:
+  static CoverageSourceInfo *setUpCoverageCallbacks(Preprocessor &PP);
+
   CoverageMappingModuleGen(CodeGenModule &CGM, CoverageSourceInfo &SourceInfo)
       : CGM(CGM), SourceInfo(SourceInfo) {}
 
   CoverageSourceInfo &getSourceInfo() const {
     return SourceInfo;
   }
 
   /// Add a function's coverage mapping record to the collection of the

clang/lib/CodeGen/CoverageMappingGen.cpp

 // This selects the coverage mapping format defined when `InstrProfData.inc`
 // is textually included.
 #define COVMAP_V3
 
 using namespace clang;
 using namespace CodeGen;
 using namespace llvm::coverage;
 
+CoverageSourceInfo *
+CoverageMappingModuleGen::setUpCoverageCallbacks(Preprocessor &PP) {
+  CoverageSourceInfo *CoverageInfo = new CoverageSourceInfo();
+  PP.addPPCallbacks(std::unique_ptr<PPCallbacks>(CoverageInfo));
+  PP.addCommentHandler(CoverageInfo);
+  PP.setPreprocessToken(true);
+  PP.setTokenWatcher([CoverageInfo](clang::Token Tok) {
+    // Update previous token location.
+    CoverageInfo->PrevTokLoc = Tok.getLocation();
+    CoverageInfo->updateNextTokLoc(Tok.getLocation());
+  });
+  return CoverageInfo;
+}
+
 void CoverageSourceInfo::SourceRangeSkipped(SourceRange Range, SourceLocation) {
-  SkippedRanges.push_back(Range);
+  SkippedRanges.push_back({Range});
+}
+
+bool CoverageSourceInfo::HandleComment(Preprocessor &PP, SourceRange Range) {
+  SkippedRanges.push_back({Range, PrevTokLoc});
+  AfterComment = true;
+  return false;
+}
+
+void CoverageSourceInfo::updateNextTokLoc(SourceLocation Loc) {
+  if (AfterComment) {
+    SkippedRanges.back().NextTokLoc = Loc;
+    AfterComment = false;
+  }
 }
 
 namespace {
 
 /// A region of source code that can be mapped to a counter.
 class SourceMappingRegion {
   Counter Count;
 
public:
   /// If such file id doesn't exist, return None.
   Optional<unsigned> getCoverageFileID(SourceLocation Loc) {
     auto Mapping = FileIDMapping.find(SM.getFileID(Loc));
     if (Mapping != FileIDMapping.end())
       return Mapping->second.first;
     return None;
   }
 
+  /// This shrinks the skipped range if it spans a line that contains a
+  /// non-comment token. If shrinking the skipped range would make it empty,
+  /// this returns None.
+  Optional<SpellingRegion> adjustSkippedRange(SourceManager &SM,
+                                              SpellingRegion SR,
+                                              SourceLocation PrevTokLoc,
+                                              SourceLocation NextTokLoc) {
+    // If Range begin location is invalid, it's not a comment region.
+    if (PrevTokLoc.isInvalid())
+      return SR;
+    unsigned PrevTokLine = SM.getSpellingLineNumber(PrevTokLoc);
+    unsigned NextTokLine = SM.getSpellingLineNumber(NextTokLoc);
+    SpellingRegion newSR(SR);
+    if (SR.LineStart == PrevTokLine) {
+      newSR.LineStart = SR.LineStart + 1;
+      newSR.ColumnStart = 1;
+    }
+    if (SR.LineEnd == NextTokLine) {
+      newSR.LineEnd = SR.LineEnd - 1;
+      newSR.ColumnEnd = SR.ColumnStart + 1;
+    }
+    if (newSR.isInSourceOrder())
+      return newSR;
+    return None;
+  }
+
   /// Gather all the regions that were skipped by the preprocessor
-  /// using the constructs like #if.
+  /// using the constructs like #if or comments.
   void gatherSkippedRegions() {
     /// An array of the minimum lineStarts and the maximum lineEnds
     /// for mapping regions from the appropriate source files.
     llvm::SmallVector<std::pair<unsigned, unsigned>, 8> FileLineRanges;
     FileLineRanges.resize(
         FileIDMapping.size(),
         std::make_pair(std::numeric_limits<unsigned>::max(), 0));
     for (const auto &R : MappingRegions) {
       FileLineRanges[R.FileID].first =
           std::min(FileLineRanges[R.FileID].first, R.LineStart);
       FileLineRanges[R.FileID].second =
           std::max(FileLineRanges[R.FileID].second, R.LineEnd);
     }
 
     auto SkippedRanges = CVM.getSourceInfo().getSkippedRanges();
-    for (const auto &I : SkippedRanges) {
-      auto LocStart = I.getBegin();
-      auto LocEnd = I.getEnd();
+    for (auto &I : SkippedRanges) {
+      SourceRange Range = I.Range;
+      auto LocStart = Range.getBegin();
+      auto LocEnd = Range.getEnd();
       assert(SM.isWrittenInSameFile(LocStart, LocEnd) &&
              "region spans multiple files");
 
       auto CovFileID = getCoverageFileID(LocStart);
       if (!CovFileID)
         continue;
       SpellingRegion SR{SM, LocStart, LocEnd};
+      if (Optional<SpellingRegion> res =
+              adjustSkippedRange(SM, SR, I.PrevTokLoc, I.NextTokLoc))
+        SR = res.getValue();
+      else
+        continue;
       auto Region = CounterMappingRegion::makeSkipped(
           *CovFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd);
       // Make sure that we only collect the regions that are inside
       // the source code of this function.
       if (Region.LineStart >= FileLineRanges[*CovFileID].first &&
           Region.LineEnd <= FileLineRanges[*CovFileID].second)
         MappingRegions.push_back(Region);
     }

clang/lib/Lex/Preprocessor.cpp

default:
       ImportSeqState.handleMisc();
       break;
     }
   }
 
   LastTokenWasAt = Result.is(tok::at);
   --LexLevel;
 
-  if (LexLevel == 0 && !Result.getFlag(Token::IsReinjected)) {
+  if ((LexLevel == 0 || PreprocessToken) &&
+      !Result.getFlag(Token::IsReinjected)) {
+    if (LexLevel == 0)
       ++TokenCount;
     if (OnToken)
       OnToken(Result);
   }
 }
 
 /// Lex a header-name token (including one formed from header-name-tokens if
 /// \p AllowConcatenation is \c true).
 ///

clang/test/CoverageMapping/break.c

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name break.c %s | FileCheck %s
+// RUN: %strip_comments > %t.stripped.c
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name break.c %t.stripped.c | FileCheck %s
 
 int main() {         // CHECK: File 0, [[@LINE]]:12 -> {{[0-9]+}}:2 = #0
   int cnt = 0;       // CHECK-NEXT: File 0, [[@LINE+1]]:9 -> [[@LINE+1]]:18 = #0
   while(cnt < 100) { // CHECK: File 0, [[@LINE]]:20 -> [[@LINE+3]]:4 = #1
     break;
     ++cnt;           // CHECK-NEXT: File 0, [[@LINE]]:5 -> [[@LINE+1]]:4 = 0
   }                  // CHECK-NEXT: File 0, [[@LINE+1]]:9 -> [[@LINE+1]]:18 = #0
   while(cnt < 100) { // CHECK: File 0, [[@LINE]]:20 -> [[@LINE+6]]:4 = #2

clang/test/CoverageMapping/builtinmacro.c

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name builtinmacro.c %s | FileCheck %s
+// RUN: %strip_comments > %t.stripped.c
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name builtinmacro.c %t.stripped.c | FileCheck %s
 
 // Test the coverage mapping generation for built-in macroes.
 
 // CHECK: filename
 const char *filename (const char *name) { // CHECK-NEXT: File 0, [[@LINE]]:41 -> [[@LINE+3]]:2 = #0
   static const char this_file[] = __FILE__;
   return this_file;
 }
 
 int main() { // CHECK-NEXT: main
   filename(__FILE__ "test.c");
   return 0;
 }

clang/test/CoverageMapping/classtemplate.cpp

-// RUN: %clang_cc1 -triple %itanium_abi_triple -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name classtemplate.cpp %s > %tmapping
+// RUN: %strip_comments > %t.stripped.cpp
+// RUN: %clang_cc1 -triple %itanium_abi_triple -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name classtemplate.cpp %t.stripped.cpp > %tmapping
 // RUN: FileCheck -input-file %tmapping %s --check-prefix=CHECK-CONSTRUCTOR
 // RUN: FileCheck -input-file %tmapping %s --check-prefix=CHECK-GETTER
 // RUN: FileCheck -input-file %tmapping %s --check-prefix=CHECK-SETTER
 // RUN: FileCheck -input-file %tmapping %s --check-prefix=CHECK-INIT-LIST
 
 template<class TT>
 class Test {
 public:

clang/test/CoverageMapping/comment-in-macro.c

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only %s | FileCheck %s
+// RUN: %strip_comments > %t.stripped.c
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only %t.stripped.c | FileCheck %s
 
 #define x1 "" // ...
 #define x2 return 0
 // CHECK: main
 int main() { // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+3]]:2 = #0
   x1;        // CHECK-NEXT: Expansion,File 0, [[@LINE]]:3 -> [[@LINE]]:5 = #0
   x2;        // CHECK-NEXT: Expansion,File 0, [[@LINE]]:3 -> [[@LINE]]:5 = #0
 }
-// CHECK-NEXT: File 1, 3:12 -> 3:14 = #0
-// CHECK-NEXT: File 2, 4:12 -> 4:20 = #0
+// CHECK-NEXT: File 1, 4:12 -> 4:14 = #0
+// CHECK-NEXT: File 2, 5:12 -> 5:20 = #0

clang/test/CoverageMapping/continue.c

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name continue.c %s | FileCheck %s
+// RUN: %strip_comments > %t.stripped.c
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name continue.c %t.stripped.c | FileCheck %s
 
 int main() {                    // CHECK: File 0, [[@LINE]]:12 -> [[@LINE+21]]:2 = #0
   int j = 0;                    // CHECK-NEXT: File 0, [[@LINE+2]]:18 -> [[@LINE+2]]:24 = (#0 + #1)
                                 // CHECK-NEXT: File 0, [[@LINE+1]]:26 -> [[@LINE+1]]:29 = #1
   for(int i = 0; i < 20; ++i) { // CHECK: File 0, [[@LINE]]:31 -> [[@LINE+17]]:4 = #1
     if(i < 10) {                // CHECK: File 0, [[@LINE]]:16 -> [[@LINE+13]]:6 = #2
       if(i < 5) {               // CHECK: File 0, [[@LINE]]:17 -> [[@LINE+3]]:8 = #3
         continue;

clang/test/CoverageMapping/coroutine.cpp

 // fixme: the following line is added to cleanup bots, will be removed in weeks.
 // RUN: rm -f %S/coroutine.ll
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 -emit-llvm -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping %s -o - | FileCheck %s
+// RUN: %strip_comments > %t.stripped.cpp
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcoroutines-ts -std=c++14 -emit-llvm -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping %t.stripped.cpp -o - | FileCheck %s
 
 namespace std::experimental {
 template <typename... T>
 struct coroutine_traits;
 
 template <class Promise = void>
 struct coroutine_handle {
   coroutine_handle() = default;

clang/test/CoverageMapping/deferred-region.cpp

-// RUN: %clang_cc1 -std=c++11 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -fexceptions -fcxx-exceptions -emit-llvm-only -triple %itanium_abi_triple -main-file-name deferred-region.cpp -I %S/Inputs %s | FileCheck %s
+// RUN: %strip_comments > %t.stripped.cpp
+// RUN: %clang_cc1 -std=c++11 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -fexceptions -fcxx-exceptions -emit-llvm-only -triple %itanium_abi_triple -main-file-name deferred-region.cpp -I %S/Inputs %t.stripped.cpp | FileCheck %s
 
 #define IF if
 #define STMT(S) S
 
 // CHECK-LABEL: _Z3fooi:
 void foo(int x) {
   if (x == 0) {
     return;

clang/test/CoverageMapping/if.cpp

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -std=c++1z -triple %itanium_abi_triple -main-file-name if.cpp %s | FileCheck %s
+// RUN: %strip_comments > %t.stripped.cpp
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -std=c++1z -triple %itanium_abi_triple -main-file-name if.cpp %t.stripped.cpp | FileCheck %s
 
 int nop() { return 0; }
 
 // CHECK-LABEL: _Z3foov:
                                 // CHECK-NEXT: [[@LINE+1]]:12 -> [[@LINE+6]]:2 = #0
 void foo() {                    // CHECK-NEXT: Gap,File 0, [[@LINE+1]]:20 -> [[@LINE+1]]:22 = #2
   if (int j = true ? nop()      // CHECK-NEXT: [[@LINE]]:22 -> [[@LINE]]:27 = #2
                    : nop();     // CHECK-NEXT: [[@LINE]]:22 -> [[@LINE]]:27 = (#0 - #2)

clang/test/CoverageMapping/includehell.cpp

 // CHECK-START: File [[START2]], 4:24 -> 4:27 = #5
 // CHECK-START: File [[START2]], 4:29 -> 5:1 = #5
 // CHECK-START: File [[START3:[0-9]]], 1:1 -> 5:1 = #0
 // CHECK-START: File [[START3]], 4:17 -> 4:22 = (#0 + #9)
 // CHECK-START: File [[START3]], 4:24 -> 4:27 = #9
 // CHECK-START: File [[START3]], 4:29 -> 5:1 = #9
 
 // CHECK-CODE:      File [[CODE1:[0-9]]], 1:1 -> 14:1 = #1
+// CHECK-CODE:      Skipped,File [[CODE1]], 1:1 -> 1:41 = 0
 // CHECK-CODE-NEXT: File [[CODE1]], 4:5 -> 4:11 = #1
 // CHECK-CODE: File [[CODE1]], 4:13 -> 6:2 = #2
 // CHECK-CODE: File [[CODE1]], 6:8 -> 8:2 = (#1 - #2)
 // CHECK-CODE-NEXT: File [[CODE1]], 9:5 -> 9:9 = #1
 // CHECK-CODE: File [[CODE1]], 9:11 -> 11:2 = #3
 // CHECK-CODE: File [[CODE1]], 11:8 -> 13:2 = (#1 - #3)
 // CHECK-CODE:      File [[CODE2:[0-9]]], 1:1 -> 14:1 = #5
+// CHECK-CODE:      Skipped,File [[CODE2]], 1:1 -> 1:41 = 0
 // CHECK-CODE-NEXT: File [[CODE2]], 4:5 -> 4:11 = #5
 // CHECK-CODE: File [[CODE2]], 4:13 -> 6:2 = #6
 // CHECK-CODE: File [[CODE2]], 6:8 -> 8:2 = (#5 - #6)
 // CHECK-CODE-NEXT: File [[CODE2]], 9:5 -> 9:9 = #5
 // CHECK-CODE: File [[CODE2]], 9:11 -> 11:2 = #7
 // CHECK-CODE: File [[CODE2]], 11:8 -> 13:2 = (#5 - #7)
 
 // CHECK-END: File [[END1:[0-9]]], 1:1 -> 3:2 = #1

clang/test/CoverageMapping/label.cpp

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name label.cpp %s | FileCheck %s
+// RUN: %strip_comments > %t.stripped.cpp
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name label.cpp %t.stripped.cpp | FileCheck %s
 
-                             // CHECK: func
 void func() {                // CHECK-NEXT: File 0, [[@LINE]]:13 -> {{[0-9]+}}:2 = #0
   int i = 0;                 // CHECK-NEXT: File 0, [[@LINE+2]]:14 -> [[@LINE+2]]:20 = (#0 + #3)
                              // CHECK-NEXT: File 0, [[@LINE+1]]:22 -> [[@LINE+1]]:25 = #3
   for(i = 0; i < 10; ++i) {  // CHECK: File 0, [[@LINE]]:27 -> [[@LINE+11]]:4 = #1
                              // CHECK-NEXT: File 0, [[@LINE+1]]:8 -> [[@LINE+1]]:13 = #1
     if(i < 5) {              // CHECK: File 0, [[@LINE]]:15 -> [[@LINE+6]]:6 = #2
       {
         x:                   // CHECK-NEXT: File 0, [[@LINE]]:9 -> [[@LINE+4]]:6 = #3

clang/test/CoverageMapping/logical.cpp

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name logical.cpp %s | FileCheck %s
+// RUN: %strip_comments > %t.stripped.cpp
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name logical.cpp %t.stripped.cpp | FileCheck %s
 
 int main() {                        // CHECK: File 0, [[@LINE]]:12 -> [[@LINE+15]]:2 = #0
   bool bt = true;
   bool bf = false;
   bool a = bt && bf;                // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE]]:14 = #0
                                     // CHECK-NEXT: File 0, [[@LINE-1]]:18 -> [[@LINE-1]]:20 = #1
 
   a = bt &&                         // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:9 = #0

clang/test/CoverageMapping/loops.cpp

-// RUN: %clang_cc1 -std=c++11 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name loops.cpp %s | FileCheck %s
+// RUN: %strip_comments > %t.stripped.cpp
+// RUN: %clang_cc1 -std=c++11 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name loops.cpp %t.stripped.cpp | FileCheck %s
 
-                                    // CHECK: rangedFor
 void rangedFor() {                  // CHECK-NEXT: File 0, [[@LINE]]:18 -> {{[0-9]+}}:2 = #0
   int arr[] = { 1, 2, 3, 4, 5 };
   int sum = 0;                      // CHECK: Gap,File 0, [[@LINE+1]]:20 -> [[@LINE+1]]:21 = #1
   for(auto i : arr) {               // CHECK: File 0, [[@LINE]]:21 -> [[@LINE+6]]:4 = #1
     if (i == 3)
       continue;                     // CHECK: File 0, [[@LINE]]:7 -> [[@LINE]]:15 = #2
     sum += i;                       // CHECK: File 0, [[@LINE]]:5 -> {{[0-9]+}}:4 = (#1 - #2)
     if (sum >= 7)

clang/test/CoverageMapping/macro-expressions.cpp

-// RUN: %clang_cc1 -std=c++11 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name macro-expressions.cpp -w %s | FileCheck %s
-
+// RUN: %strip_comments > %t.stripped.cpp
+// RUN: %clang_cc1 -std=c++11 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name macro-expressions.cpp -w %t.stripped.cpp | FileCheck %s
 #define EXPR(x) (x)
 #define NEXPR(x) (!x)
 #define DECL(T, x) T x
 #define ASSIGN(x, y) x = y
 #define LT(x, y) x < y
 #define INC(x) ++x
 #define ARR(T, x, y, z) (T[3]){x, y, z}
 

clang/test/CoverageMapping/macroparams2.c

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name macroparams2.c %s | FileCheck %s
-
+// RUN: %strip_comments > %t.stripped.c
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name macroparams2.c %t.stripped.c | FileCheck %s
 #define MACRO(REFS, CALLS)  (4 * (CALLS) < (REFS))
 
 struct S {
   int i, j;
 };
 
 // CHECK: File 0, [[@LINE+1]]:12 -> [[@LINE+10]]:2 = #0
 int main() {

clang/test/CoverageMapping/macros.c

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name macros.c %s | FileCheck %s
-
+// RUN: %strip_comments > %t.stripped.c
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name macros.c %t.stripped.c | FileCheck %s
 #define MACRO return; bar()
 #define MACRO_2 bar()
 #define MACRO_1 return; MACRO_2
 #define MACRO_3 MACRO_2
 #define GOTO goto
 
 void bar() {}
 

clang/test/CoverageMapping/macroscopes.cpp

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name macroscopes.cpp %s | FileCheck %s
-
+// RUN: %strip_comments > %t.stripped.cpp
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name macroscopes.cpp %t.stripped.cpp | FileCheck %s
 #define starts_a_scope for (int i = 0; i < 2; ++i) {
 
 #define ends_a_scope \
   x = x;             \
   }
 
 #define some_code \
   x = x;          \

clang/test/CoverageMapping/moremacros.c

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name macro-expansion.c %s | FileCheck %s
-
+// RUN: %strip_comments > %t.stripped.c
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name macro-expansion.c %t.stripped.c | FileCheck %s
 #define LBRAC {
 #define RBRAC }
 
 // CHECK: main:
 // CHECK-NEXT: File 0, [[@LINE+1]]:40 -> {{[0-9]+}}:2 = #0
 int main(int argc, const char *argv[]) {
   // CHECK-NEXT: File 0, [[@LINE+1]]:7 -> [[@LINE+1]]:12 = #0
   if (!argc) {} // CHECK: File 0, [[@LINE]]:14 -> [[@LINE]]:16 = #1

clang/test/CoverageMapping/objc.m

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name objc.m -triple x86_64-apple-darwin -fobjc-runtime=macosx-fragile-10.5 -w %s | FileCheck %s
+// RUN: %strip_comments > %t.stripped.m
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name objc.m -triple x86_64-apple-darwin -fobjc-runtime=macosx-fragile-10.5 -w %t.stripped.m | FileCheck %s
 
 @interface A
 - (void)bork:(int)msg;
 @end
 
                       // CHECK: func
 void func(A *a) {     // CHECK-NEXT: File 0, [[@LINE]]:17 -> [[@LINE+3]]:2 = #0
   if (a)              // CHECK-NEXT: File 0, [[@LINE]]:7 -> [[@LINE]]:8 = #0

clang/test/CoverageMapping/pr32679.cpp

-// RUN: %clang_cc1 -cc1 -triple i686-pc-windows-msvc19.0.0 -emit-obj -fprofile-instrument=clang -std=c++14 -fdelayed-template-parsing -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name pr32679.cpp -o - %s | FileCheck %s -check-prefix=MSABI -implicit-check-not=f2
-// RUN: %clang_cc1 -cc1 -triple %itanium_abi_triple -emit-obj -fprofile-instrument=clang -std=c++14 -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name pr32679.cpp -o - %s | FileCheck %s -check-prefix=ITANIUM -implicit-check-not=f2
+// RUN: %strip_comments > %t.stripped.cpp
+// RUN: %clang_cc1 -cc1 -triple i686-pc-windows-msvc19.0.0 -emit-obj -fprofile-instrument=clang -std=c++14 -fdelayed-template-parsing -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name pr32679.cpp -o - %t.stripped.cpp | FileCheck %s -check-prefix=MSABI -implicit-check-not=f2
+// RUN: %clang_cc1 -cc1 -triple %itanium_abi_triple -emit-obj -fprofile-instrument=clang -std=c++14 -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name pr32679.cpp -o - %t.stripped.cpp | FileCheck %s -check-prefix=ITANIUM -implicit-check-not=f2
 
 template <typename T, int S1>
 struct CreateSpecialization;
 
 template <typename T>
 struct CreateSpecialization<T, 0> {
   static constexpr T f1() { return 0; }
   static constexpr T f2() { return 0; }

clang/test/CoverageMapping/preprocessor.c

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name preprocessor.c %s | FileCheck %s
+// RUN: %strip_comments > %t.stripped.c
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name preprocessor.c %t.stripped.c | FileCheck %s
 
-                 // CHECK: func
 void func() {    // CHECK: File 0, [[@LINE]]:13 -> [[@LINE+5]]:2 = #0
   int i = 0;
 #ifdef MACRO     // CHECK-NEXT: Skipped,File 0, [[@LINE]]:1 -> [[@LINE+2]]:7 = 0
   int x = i;
 #endif
 }
 
                  // CHECK: main
 int main() {     // CHECK-NEXT: File 0, [[@LINE]]:12 -> {{[0-9]+}}:2 = #0
   int i = 0;
-#  if 0            // CHECK-NEXT: Skipped,File 0, [[@LINE]]:1 -> [[@LINE+4]]:29 = 0
+#if 0 // CHECK-NEXT: Skipped,File 0, [[@LINE]]:1 -> [[@LINE+4]]:9 = 0
   if(i == 0) {
     i = 1;
   }
 #  endif // Mark me skipped!
 
 #if 1
                  // CHECK-NEXT: File 0, [[@LINE+1]]:6 -> [[@LINE+1]]:12 = #0
   if(i == 0) {   // CHECK: File 0, [[@LINE]]:14 -> [[@LINE+2]]:4 = #1
     i = 1;
   }
 #else            // CHECK-NEXT: Skipped,File 0, [[@LINE]]:1 -> [[@LINE+5]]:7 = 0
   if(i == 1) {
     i = 0;
   }
 }
 #endif
 
-  // CHECK-NEXT: Skipped,File 0, [[@LINE+1]]:1 -> [[@LINE+4]]:24
+  // CHECK-NEXT: Skipped,File 0, [[@LINE+1]]:1 -> [[@LINE+4]]:8
 #\
   if 0
 #\
   endif // also skipped
 
 #if 1
   // CHECK-NEXT: Skipped,File 0, [[@LINE+1]]:1 -> [[@LINE+3]]:7
 #\
#\
   endif
 
   // CHECK-NEXT: Skipped,File 0, [[@LINE+1]]:1 -> [[@LINE+4]]:8
 #\
   ifndef __FILE__
 #\
   endif
 
-  // CHECK-NEXT: Skipped,File 0, [[@LINE+1]]:1 -> [[@LINE+6]]:26
+  // CHECK-NEXT: Skipped,File 0, [[@LINE+1]]:1 -> [[@LINE+6]]:10
 #\
   ifdef NOT_DEFINED
 #\
   \
    \
     endif // also skipped
 
   return 0;
 }

clang/test/CoverageMapping/return.c

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name return.c %s | FileCheck %s
+// RUN: %strip_comments > %t.stripped.c
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name return.c %t.stripped.c | FileCheck %s
 
                                 // CHECK: func
 void func() {                   // CHECK: File 0, [[@LINE]]:13 -> [[@LINE+3]]:2 = #0
   return;
   int i = 0;                    // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:2 = 0
 }
 
                                 // CHECK-NEXT: func2

clang/test/CoverageMapping/switch.cpp

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -std=c++1z -triple %itanium_abi_triple -main-file-name switch.cpp %s | FileCheck %s
+// RUN: %strip_comments > %t.stripped.cpp
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -std=c++1z -triple %itanium_abi_triple -main-file-name switch.cpp %t.stripped.cpp | FileCheck %s
 
-                    // CHECK: foo
 void foo(int i) {   // CHECK-NEXT: File 0, [[@LINE]]:17 -> [[@LINE+8]]:2 = #0
   switch(i) {       // CHECK-NEXT: Gap,File 0, [[@LINE]]:13 -> [[@LINE+4]]:10 = 0
   case 1:           // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:11 = #2
     return;
   case 2:           // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:10 = #3
     break;          // CHECK-NEXT: Gap,File 0, [[@LINE]]:10 -> [[@LINE+2]]:3 = #1
   }
   int x = 0;        // CHECK-NEXT: File 0, [[@LINE]]:3 -> [[@LINE+1]]:2 = #1

clang/test/CoverageMapping/switchmacro.c

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name switchmacro.c %s | FileCheck %s
+// RUN: %strip_comments > %t.stripped.c
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name switchmacro.c %t.stripped.c | FileCheck %s
 
 #define FOO(x) (void)x
 
 // CHECK: foo
 int foo(int i) { // CHECK-NEXT: File 0, [[@LINE]]:16 -> {{[0-9]+}}:2 = #0
   switch (i) {   // CHECK-NEXT: Gap,File 0, [[@LINE]]:14 -> {{[0-9]+}}:11 = 0
   default:       // CHECK-NEXT: File 0, [[@LINE]]:3 -> {{[0-9]+}}:11 = #2
     if (i == 1)  // CHECK-NEXT: File 0, [[@LINE]]:9 -> [[@LINE]]:15 = #2

clang/test/CoverageMapping/test.c

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name test.c %s | FileCheck %s
+// RUN: %strip_comments > %t.stripped.c
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name test.c %t.stripped.c | FileCheck %s
 
 void bar();
 static void static_func();
 
                                  // CHECK: main
 int main() {                     // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+7]]:2 = #0
                                  // CHECK-NEXT: File 0, [[@LINE+1]]:18 -> [[@LINE+1]]:24 = (#0 + #1)
   for(int i = 0; i < 10; ++i) {  // CHECK-NEXT: File 0, [[@LINE]]:26 -> [[@LINE]]:29 = #1

clang/test/CoverageMapping/trycatch.cpp

-// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 -fexceptions -fcxx-exceptions -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name trycatch.cpp %s | FileCheck %s
+// RUN: %strip_comments > %t.stripped.cpp
+// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 -fexceptions -fcxx-exceptions -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name trycatch.cpp %t.stripped.cpp | FileCheck %s
 
 class Error {
 };
 
 class ImportantError {
 };
 
 class Warning {

clang/test/CoverageMapping/unreachable-macro.c

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only %s | FileCheck %s
-
+// RUN: %strip_comments > %t.stripped.c
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only %t.stripped.c | FileCheck %s
 #define WHILE while (0) {}
 
 // CHECK: counters_in_macro_following_unreachable
 void counters_in_macro_following_unreachable() {
   // CHECK-NEXT: File 0, [[@LINE-1]]:48 -> {{[0-9]+}}:2 = #0
   return;
   // CHECK-NEXT: Expansion,File 0, [[@LINE+2]]:3 -> [[@LINE+2]]:8 = 0
   // CHECK-NEXT: File 0, [[@LINE+1]]:8 -> [[@LINE+2]]:2 = 0
   WHILE
 }
 // CHECK-NEXT: File 1, 3:15 -> 3:27 = 0
 // CHECK-NEXT: File 1, 3:22 -> 3:23 = #1
 // CHECK-NEXT: File 1, 3:25 -> 3:27 = #1

clang/test/CoverageMapping/while.c

-// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name loops.cpp %s | FileCheck %s
+// RUN: %strip_comments > %t.stripped.c
+// RUN: %clang_cc1 -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -main-file-name loops.cpp %t.stripped.c | FileCheck %s
 
-                                    // CHECK: main
 int main() {                        // CHECK-NEXT: File 0, [[@LINE]]:12 -> [[@LINE+8]]:2 = #0
   int j = 0;                        // CHECK-NEXT: File 0, [[@LINE+1]]:9 -> [[@LINE+1]]:14 = (#0 + #1)
   while(j < 5) ++j;                 // CHECK-NEXT: File 0, [[@LINE]]:15 -> [[@LINE]]:16 = #1
   j = 0;                            // CHECK-NEXT: File 0, [[@LINE-1]]:16 -> [[@LINE-1]]:19 = #1
   while                             // CHECK-NEXT: File 0, [[@LINE+1]]:5 -> [[@LINE+1]]:10 = (#0 + #2)
    (j < 5)                          // CHECK-NEXT: Gap,File 0, [[@LINE]]:11 -> [[@LINE+1]]:6 = #2
      ++j;                           // CHECK-NEXT: File 0, [[@LINE]]:6 -> [[@LINE]]:9 = #2
   return 0;
 }

clang/test/lit.cfg.py

config.substitutions.append(
          '"%s" %s' % (config.python_executable, check_analyzer_fixit_path)))
 
 llvm_config.add_tool_substitutions(tools, tool_dirs)
 
 config.substitutions.append(
     ('%hmaptool', "'%s' %s" % (config.python_executable,
                              os.path.join(config.clang_tools_dir, 'hmaptool'))))
 
+# Strip C++ comments "//"" from tests
+config.substitutions.append(
+    ('%strip_comments', "sed 's/[ \t]*\/\/.*//' %s")
+)
+
 # Plugins (loadable modules)
 if config.has_plugins and config.llvm_plugin_ext:
     config.available_features.add('plugins')
 
 # Set available features we allow tests to conditionalize on.
 #
 if config.clang_default_cxx_stdlib != '':
     config.available_features.add('default-cxx-stdlib-set')

compiler-rt/test/profile/Inputs/instrprof-comdat.h

 };
 
 template <class T> T FOO<T>::DoIt(T ti) { // HEADER: [[@LINE]]|  2|template
   for (T I = 0; I < ti; I++) {            // HEADER: [[@LINE]]| 22|  for (T
     t += I;                               // HEADER: [[@LINE]]| 20|    t += I;
     if (I > ti / 2)                       // HEADER: [[@LINE]]| 20|    if (I > ti
       t -= 1;                             // HEADER: [[@LINE]]|  8|      t -= 1;
   }                                       // HEADER: [[@LINE]]| 10|  }
-                                          // HEADER: [[@LINE]]|  1|
+                                          // HEADER: [[@LINE]]|   |
   return t;                               // HEADER: [[@LINE]]|  1|  return t;
 }

compiler-rt/test/profile/coverage_comments.cpp

+// RUN: %clangxx_profgen -fcoverage-mapping -Wno-comment -o %t %s
+// RUN: env LLVM_PROFILE_FILE=%t.profraw %run %t
+// RUN: llvm-profdata merge -o %t.profdata %t.profraw
+// RUN: llvm-cov show %t -instr-profile %t.profdata -path-equivalence=/tmp,%S 2>&1 | FileCheck %s
+
+int main() {                           // CHECK:       [[# @LINE]]| 1|int main() {
+    /* comment */ int x = 0;           // CHECK-NEXT:  [[# @LINE]]| 1|
+    int y = 0; /* comment */           // CHECK-NEXT:  [[# @LINE]]| 1|
+    int z = 0; // comment              // CHECK-NEXT:  [[# @LINE]]| 1|
+    // comment                         // CHECK-NEXT:  [[# @LINE]]|  |
+                                       // CHECK-NEXT:  [[# @LINE]]|  |
+    x = 0; /*                          // CHECK-NEXT:  [[# @LINE]]| 1|
+    comment                            // CHECK-NEXT:  [[# @LINE]]|  |
+    */                                 // CHECK-NEXT:  [[# @LINE]]|  |
+                                       // CHECK-NEXT:  [[# @LINE]]|  |
+    /*                                 // CHECK-NEXT:  [[# @LINE]]|  |
+    comment                            // CHECK-NEXT:  [[# @LINE]]|  |
+    */ x = 0;                          // CHECK-NEXT:  [[# @LINE]]| 1|
+                                       // CHECK-NEXT:  [[# @LINE]]|  |
+    /* comment */                      // CHECK-NEXT:  [[# @LINE]]|  |
+    // comment                         // CHECK-NEXT:  [[# @LINE]]|  |
+    /* comment */                      // CHECK-NEXT:  [[# @LINE]]|  |
+    z =                                // CHECK-NEXT:  [[# @LINE]]| 1|
+    x // comment                       // CHECK-NEXT:  [[# @LINE]]| 1|
+    // comment                         // CHECK-NEXT:  [[# @LINE]]|  |
+    + /*                               // CHECK-NEXT:  [[# @LINE]]| 1|
+    comment                            // CHECK-NEXT:  [[# @LINE]]|  |
+    */                                 // CHECK-NEXT:  [[# @LINE]]|  |
+    /*                                 // CHECK-NEXT:  [[# @LINE]]|  |
+    comment                            // CHECK-NEXT:  [[# @LINE]]|  |
+    */y;                               // CHECK-NEXT:  [[# @LINE]]| 1|
+                                       // CHECK-NEXT:  [[# @LINE]]|  |
+    // Comments inside directives.     // CHECK-NEXT:  [[# @LINE]]|  |
+    #if 0 //comment                    // CHECK-NEXT:  [[# @LINE]]|  |
+    /* comment */ x = 0;               // CHECK-NEXT:  [[# @LINE]]|  |
+    y = 0; /* comment */               // CHECK-NEXT:  [[# @LINE]]|  |
+    z = 0; // comment                  // CHECK-NEXT:  [[# @LINE]]|  |
+    // comment                         // CHECK-NEXT:  [[# @LINE]]|  |
+                                       // CHECK-NEXT:  [[# @LINE]]|  |
+    x = 0; /*                          // CHECK-NEXT:  [[# @LINE]]|  |
+    comment                            // CHECK-NEXT:  [[# @LINE]]|  |
+    */                                 // CHECK-NEXT:  [[# @LINE]]|  |
+                                       // CHECK-NEXT:  [[# @LINE]]|  | 
+    /*                                 // CHECK-NEXT:  [[# @LINE]]|  |
+    comment                            // CHECK-NEXT:  [[# @LINE]]|  |
+    */ x = 0;                          // CHECK-NEXT:  [[# @LINE]]|  |
+                                       // CHECK-NEXT:  [[# @LINE]]|  |
+    /* comment */                      // CHECK-NEXT:  [[# @LINE]]|  |
+    // comment                         // CHECK-NEXT:  [[# @LINE]]|  |
+    /* comment */                      // CHECK-NEXT:  [[# @LINE]]|  |
+    #endif // comment                  // CHECK-NEXT:  [[# @LINE]]|  |
+    #if 1 // comment                   // CHECK-NEXT:  [[# @LINE]]| 1|
+    /* comment */ x = 0;               // CHECK-NEXT:  [[# @LINE]]| 1|
+    y = 0; /* comment */               // CHECK-NEXT:  [[# @LINE]]| 1|
+    z = 0; // comment                  // CHECK-NEXT:  [[# @LINE]]| 1|
+    // comment                         // CHECK-NEXT:  [[# @LINE]]|  |
+                                       // CHECK-NEXT:  [[# @LINE]]|  |
+    x = 0; /*                          // CHECK-NEXT:  [[# @LINE]]| 1|
+    comment                            // CHECK-NEXT:  [[# @LINE]]|  |
+    */                                 // CHECK-NEXT:  [[# @LINE]]|  |
+                                       // CHECK-NEXT:  [[# @LINE]]|  |
+    /*                                 // CHECK-NEXT:  [[# @LINE]]|  |
+    comment                            // CHECK-NEXT:  [[# @LINE]]|  |
+    */ x = 0;                          // CHECK-NEXT:  [[# @LINE]]| 1|
+                                       // CHECK-NEXT:  [[# @LINE]]|  |
+    /* comment */                      // CHECK-NEXT:  [[# @LINE]]|  |
+    // comment                         // CHECK-NEXT:  [[# @LINE]]|  |
+    /* comment */                      // CHECK-NEXT:  [[# @LINE]]|  |
+    #endif //comment                   // CHECK-NEXT:  [[# @LINE]]| 1|
+    return 0;                          // CHECK-NEXT:  [[# @LINE]]| 1|
+}                                      // CHECK-NEXT:  [[# @LINE]]| 1|

compiler-rt/test/profile/instrprof-set-file-object-merging.c

 // CHECK:   12|       |extern void __llvm_profile_set_file_object(FILE *, int);
 // CHECK:   13|       |
 // CHECK:   14|      2|int main(int argc, const char *argv[]) {
 // CHECK:   15|      2|  if (argc < 2)
 // CHECK:   16|      0|    return 1;
 // CHECK:   17|      2|
 // CHECK:   18|      2|  FILE *F = fopen(argv[1], "r+b");
 // CHECK:   19|      2|  if (!F) {
-// CHECK:   20|      1|    // File might not exist, try opening with truncation
+// CHECK:   20|       |    // File might not exist, try opening with truncation
 // CHECK:   21|      1|    F = fopen(argv[1], "w+b");
 // CHECK:   22|      1|  }
 // CHECK:   23|      2|  __llvm_profile_set_file_object(F, 1);
 // CHECK:   24|      2|
 // CHECK:   25|      2|  return 0;
 // CHECK:   26|      2|}