[Preprocessor] Implement -fminimize-whitespace.

[Meinersbur]

Summary

This patch adds the -fminimize-whitespace with the following effects:

• If combined with -E, remove as much non-line-breaking whitespace as possible
• If combined with -E -P, removes as much whitespace as possible, including line-breaks.

The motivation is to reduce the amount of insignificant changes in the preprocessed output with source files where only whitespace has been changes (add/remove comments, clang-format, etc.) which is in particular useful with ccache.

A patch for ccache for using this flag has been proposed to ccache as well: https://github.com/ccache/ccache/pull/815, which will use -fnormalize-whitespace when clang-13 has been detected (assuming this will be merged before the release fork), and additionally uses -P in "unify_mode". ccache already had a unify_mode in an older version which was removed because of problems that using the preprocessor itself does not have (such that the custom tokenizer did not recognize C++11 raw strings).

This patch slightly reorganizes which part is responsible for adding newlines that are required for semantics. It is now either startNewLineIfNeeded() or MoveToLine() but never both; this avoids the ShouldUpdateCurrentLine workaround and avoids redundant lines being inserted in some cases. It also fixes a mandatory newline not inserted after a _Pragma("...") that is expanded into a #pragma.

[Meinersbur]

• Undo "typechange" changes

[dblaikie]

This is probably more @aaron.ballman 's wheelhouse, but for my money this seems pretty problematic - will make quoted text in compiler diagnostics weird/difficult to read, etc.

Do you have a particular use case that has exceptionally frequent whitespace-only changes?
Or is this something you think would be generally applicable? How applicable, do you think? Do you have some data showing a % of rebuilds that would be avoided in practice/based on real code bases, etc?

[Meinersbur]

In D104601#2831746, @dblaikie wrote:

This is probably more @aaron.ballman 's wheelhouse, but for my money this seems pretty problematic - will make quoted text in compiler diagnostics weird/difficult to read, etc.

It is not meant for human readability but automatic processing. The linked ccache patch either re-runs the compiler with on the original source file if there is any diagnostic output (run_second_cpp=false) or(inclusive) uses the preprocessor output only to determine whether there was a significant change in the first place (run_second_cpp=true, default).

To discourage use by humans, we could make the flag available only behind -Xclang, but I'd expect people to only use the flag if they have a need for it anyway. Compiler diagnostics invoked on -E -P output is already not very useful; -fnormalize-whitespace would potentially cause the entire source be on a single line. If this is a show-stopper, I could try making the diagnostic's quoted text print only an excerpt of a line if it becomes too long.

Do you have a particular use case that has exceptionally frequent whitespace-only changes?

Every edit of a (multi-line) comment and running of clang-format. The former makes me hesitant to improve comments in central header files because I know it means that I have to rebuild the entire code base; it should not be a reason to not improve documentation. The latter is best-practice before any commit. Again, if it includes a central header file, it means rebuilding significant portions.

ccache uses preprocessor mode by default while it also supports strict binary comparison ("direct mode") and I assume there is a reason for this. However, every non-intra-line change causes the preprocessor output to change due to the line number in the #line directive changing, making the preprocessor mode much less effective than it could be. Very few NF changes take place within a single line only.

Unlike gcc, clang's -E -P output still includes empty lines (unless there are more than 8 consecutive empty lines). That is, there is hardly a benefit to use -P output in ccache with clang.

Or is this something you think would be generally applicable? How applicable, do you think? Do you have some data showing a % of rebuilds that would be avoided in practice/based on real code bases, etc?

If it supports my case, I can work with builds using ccache for a while: one configured using -fnormalize-whitespace, the other without, and compare ccache statistics. I have used it already, but never comparatively over the same time frame. However, I think the above argument is already pretty good.

[Meinersbur]

Some bikeshedding: Calls to AvoidConcat could be avoided by always inserting a space between tokens at the cost of making the output larger. In the current form, the flag could also be named -fminimize-whitespace.

[dblaikie]

One of the concerns I'd have, for instance (have you done some broad testing of these patches on sizable code bases?) is that it wouldn't surprise me if clang had some scalability bugs/issues with very long source lines - so it might be necessary to introduce some (arbitrary?) newlines to break up the code. Though I'm not sure - no need to do that pre-emptively, but might be good to have some data that indicates whether this might be a problem or not.

[Meinersbur]

During a trial phase while compiling everything twice with ccache I got the following results.

Only unify_mode::

$ ccache -d . -s
cache directory                     .
primary config                      ./ccache.conf
secondary config (readonly)         /home/meinersbur/install/ccache/release/etc/ccache.conf
stats updated                       Fri Jun 25 02:00:22 2021
stats zeroed                        Wed Jun 23 03:22:36 2021
cache hit (direct)                  1001
cache hit (preprocessed)            5904
cache miss                         10717
cache hit rate                     39.18 %
compile failed                         5
cleanups performed                     0
files in cache                     38182
cache size                           1.9 GB
max cache size                       5.5 GB

unify_mode with -fnormalize-whitespace:

$ ccache -d . -s
cache directory                     .
primary config                      ./ccache.conf
secondary config (readonly)         /home/meinersbur/install/ccache/release/etc/ccache.conf
stats updated                       Fri Jun 25 02:04:19 2021
stats zeroed                        Wed Jun 23 03:22:31 2021
cache hit (direct)                  1001
cache hit (preprocessed)            2663
cache miss                         13957
cache hit rate                     20.79 %
compile failed                         5
cleanups performed                     0
files in cache                     44661
cache size                           2.4 GB
max cache size                       5.5 GB

Admittedly, I focused on changes (of Clang and Polly) like refactoring, improving comments, minimize difference to upstream (clang-)formatting etc. during the testing.

The difference is most pronounced with changes such as rG3e8d1e8b12ba9017b861fff94afdd4a29b39de17:

cache hit (direct)                     0
cache hit (preprocessed)               0
cache miss                          2245
cache hit rate                      0.00 %

vs

cache hit (direct)                     0
cache hit (preprocessed)            2235
cache miss                            10
cache hit rate                     99.55 %

(the misses come from compilations with warning diagnostics)

In D104601#2831951, @dblaikie wrote:

One of the concerns I'd have, for instance (have you done some broad testing of these patches on sizable code bases?) is that it wouldn't surprise me if clang had some scalability bugs/issues with very long source lines - so it might be necessary to introduce some (arbitrary?) newlines to break up the code. Though I'm not sure - no need to do that pre-emptively, but might be good to have some data that indicates whether this might be a problem or not.

I found no such issues during my trials. However, I think the request is understandable an I would implement it on request. It introduces a new problem having to determine where no newlines mat be introduced (e.g. within a #pragma).

[dblaikie]

Admittedly, I focused on changes (of Clang and Polly) like refactoring, improving comments, minimize difference to upstream (clang-)formatting etc. during the testing.

Yeah, I was more curious about general purpose/average changes, but anyway.

In D104601#2831951, @dblaikie wrote:

One of the concerns I'd have, for instance (have you done some broad testing of these patches on sizable code bases?) is that it wouldn't surprise me if clang had some scalability bugs/issues with very long source lines - so it might be necessary to introduce some (arbitrary?) newlines to break up the code. Though I'm not sure - no need to do that pre-emptively, but might be good to have some data that indicates whether this might be a problem or not.

I found no such issues during my trials. However, I think the request is understandable an I would implement it on request. It introduces a new problem having to determine where no newlines mat be introduced (e.g. within a #pragma).

Yeah, no need to get ahead of that - just something to be aware of/on the look out if this feature ends up in use.

One other thing: This wouldn't be usable when using debug info, presumably, because it'd refer to the wrong lines, etc.

[Meinersbur]

In D104601#2842686, @dblaikie wrote:

One other thing: This wouldn't be usable when using debug info, presumably, because it'd refer to the wrong lines, etc.

This is considered in the ccache patch. By default (unless a corresponding "sloppiness" option is used), only direct hits (by binary file comparison) are used if: There is compiler output, debug info is generated, or .incbin assembly instruction is used.

However, this is orthogonal to -fnormalize-whitespace. It is a mitigation of using -E -P as preprocessor intermediate.

[aaron.ballman]

I'm still mulling over the feature, but I have some nits with the patch while I was exploring it. I share the concerns raised by @dblaikie and would add that it's very common for implementers to ask developers to run their code through -E mode to submit preprocessed output in order to reproduce a customer issue with the compiler, and I worry that uses of this flag will have unintended consequences in that scenario. However, I don't yet have a concrete "this code demonstrates the problem I'm worried about" example to discuss, so this worry may be unfounded. The "very long line" example mentioned by @dblaikie is sort of along these lines (sorry for the bad pun).

clang/docs/ClangCommandLineReference.rst

2480

You might want to wrap this to 80-col limits.

[aaron.ballman]

clang/lib/Frontend/PrintPreprocessedOutput.cpp

135

137

174

Can Tok be const Token & instead?

181

635

[Meinersbur]

• Address review by @aaron.ballman

[Meinersbur]

In D104601#2847400, @aaron.ballman wrote:

... would add that it's very common for implementers to ask developers to run their code through -E mode to submit preprocessed output in order to reproduce a customer issue with the compiler, and I worry that uses of this flag will have unintended consequences in that scenario.

Why would one add -fnormalize-whitespace for this use case?

The "very long line" example mentioned by @dblaikie is sort of along these lines (sorry for the bad pun).

I can add forced line breaks (after/before 80 cols? configurable?) if requested.

clang/lib/Frontend/PrintPreprocessedOutput.cpp

174

Note that this is a renamed bool HandleFirstTokOnLine(Token &Tok). Renamed because it is now called for every token.

[Meinersbur]

ping

[Meinersbur]

ping

It would be nice if we could get this into clang 13 since the ccache part detects support for -fnormalize-whitespace when detecting clang 13+. Probing the compiler for whether it supports -fnormalize-whitespace on every run would be prohibitively expensive.

[aaron.ballman]

In D104601#2848366, @Meinersbur wrote:

In D104601#2847400, @aaron.ballman wrote:

... would add that it's very common for implementers to ask developers to run their code through -E mode to submit preprocessed output in order to reproduce a customer issue with the compiler, and I worry that uses of this flag will have unintended consequences in that scenario.

Why would one add -fnormalize-whitespace for this use case?

I don't think they'd *add* it, I worry it's already used by their build system for reasons unknown and the developer replicates it when reporting the bug because they're not looking at what flags can be removed.

The "very long line" example mentioned by @dblaikie is sort of along these lines (sorry for the bad pun).

I can add forced line breaks (after/before 80 cols? configurable?) if requested.

I don't think that's necessary just yet. If there's an issue in practice, it seems like we could address it once we have the real world use in front of us. However, It'd help my confidence if you were able to run this functionality over a large corpus of code to see if any issues do pop out, if that's plausible for you.

That said, I think I've convinced myself that this functionality is reasonable (if a bit novel), but I'd like to see it diagnosed when used outside of a preprocessor invocation because it really serves no purpose there. I also think we should rename it because "normalize whitespace" can be ambiguous depending on what context you're reading the words in.

clang/docs/ClangCommandLineReference.rst

2484

Should this option be ignored when not performing a preprocessing action (and documented as such)?

clang/include/clang/Driver/Options.td

1789

I think I'd feel most comfortable if this didn't use "normalize" in the name. When I hear that, I think it's going to be doing something like converting all (perhaps funky Unicode) notions of whitespace into ASCII space characters. But this option doesn't actually do that -- it's removing as much whitespace from the preprocessed output as possible. Would it be better named as -felide-unnecessary-whitespace or something along those lines?

[Meinersbur]

In D104601#2877855, @aaron.ballman wrote:

In D104601#2848366, @Meinersbur wrote:

In D104601#2847400, @aaron.ballman wrote:

... would add that it's very common for implementers to ask developers to run their code through -E mode to submit preprocessed output in order to reproduce a customer issue with the compiler, and I worry that uses of this flag will have unintended consequences in that scenario.

Why would one add -fnormalize-whitespace for this use case?

I don't think they'd *add* it, I worry it's already used by their build system for reasons unknown and the developer replicates it when reporting the bug because they're not looking at what flags can be removed.

I made the flag an error if used without -E, so the build system cannot add it.

Flags such as -P, -fuse-line-directives, -frewrite-imports and -frewrite-includes are also silently ignored without -E. This requirement seems exclusive for -felide-unnecessary-whitespace. It also suggests that it is not a problematic scenario.

The "very long line" example mentioned by @dblaikie is sort of along these lines (sorry for the bad pun).

I can add forced line breaks (after/before 80 cols? configurable?) if requested.

I don't think that's necessary just yet. If there's an issue in practice, it seems like we could address it once we have the real world use in front of us. However, It'd help my confidence if you were able to run this functionality over a large corpus of code to see if any issues do pop out, if that's plausible for you.

I ran it (using ccache) over llvm-project and the llvm-test-suite. Is there another large corpus do you have in mind?

I'd like to see it diagnosed when used outside of a preprocessor invocation because it really serves no purpose there.

I made the flag an error if not used without -E.

I also think we should rename it because "normalize whitespace" can be ambiguous depending on what context you're reading the words in.

Changed to your suggested -felide-unnecessary-whitespace, although I think name will not allow use to insert whitespace e.g. for keeping the line length down. If that's not required, I would prefer -fminimize-whitespace over -felide-unnecessary-whitespace`.

clang/docs/ClangCommandLineReference.rst

2484

I changed it to an error if used without -E.

clang/include/clang/Driver/Options.td

1789

I don't think it is ambiguous what whitespace means for the preprocessor. Currently, -E already converts into '\n' and '\n' only.

I don't like the suggested name but still applied it to this patch. I'd prefer -fminimize-whitespace. However, the name would be wrong if we add additional whitespace such as line-breaks to avoid the long line problem, of we unconditionally always emit a space between tokens to not having to call AvoidConcat which would still serve the same goal.

[Meinersbur]

• Rename -fnormalize-whitespace to -felide-unnecessary-whitespace
• error when used without -E
• Reabse

[aaron.ballman]

In D104601#2886412, @Meinersbur wrote:

In D104601#2877855, @aaron.ballman wrote:

I don't think they'd *add* it, I worry it's already used by their build system for reasons unknown and the developer replicates it when reporting the bug because they're not looking at what flags can be removed.

I made the flag an error if used without -E, so the build system cannot add it.

Flags such as -P, -fuse-line-directives, -frewrite-imports and -frewrite-includes are also silently ignored without -E. This requirement seems exclusive for -felide-unnecessary-whitespace. It also suggests that it is not a problematic scenario.

Perhaps it's not a problematic scenario, but I'd consider those cases to also be bugs. Silently ignoring things the user wrote (either in code or on the command line) is typically user-hostile.

The "very long line" example mentioned by @dblaikie is sort of along these lines (sorry for the bad pun).

I can add forced line breaks (after/before 80 cols? configurable?) if requested.

I don't think that's necessary just yet. If there's an issue in practice, it seems like we could address it once we have the real world use in front of us. However, It'd help my confidence if you were able to run this functionality over a large corpus of code to see if any issues do pop out, if that's plausible for you.

I ran it (using ccache) over llvm-project and the llvm-test-suite. Is there another large corpus do you have in mind?

A Linux or BSD distro worth of code would be really nice, but I don't insist. The trouble with llvm-project is that it has a somewhat uniform style for code, and I've found that tools in distro packages tend to exercise more interesting cases sometimes.

I also think we should rename it because "normalize whitespace" can be ambiguous depending on what context you're reading the words in.

Changed to your suggested -felide-unnecessary-whitespace, although I think name will not allow use to insert whitespace e.g. for keeping the line length down. If that's not required, I would prefer -fminimize-whitespace over -felide-unnecessary-whitespace`.

I'd be perfectly happy with -fminimize-whitespace as well if that's your preference.

clang/docs/ClangCommandLineReference.rst

2484

Thanks! Can you add that info to the documentation here?

[Meinersbur]

• Rename -felide-unnecessary-whitespace to -fminimize-whitespace
• Add -fminimize-whitespace only vlid to be used to docs
• Adjust some code comments
• Rebase

[Meinersbur]

In D104601#2831746, @dblaikie wrote:

but for my money this seems pretty problematic - will make quoted text in compiler diagnostics weird/difficult to read, etc.

FWIW, clang has a line length limit of 4096 for printing diagnostics.

[Meinersbur]

• Error if -fminimize-whitespace is applied to asm files
• Join lines with escaped newlines
• Added some FIXMEs for grandfathered bugs

[Meinersbur]

I compiled the Linux kernel (default config, excludes most drivers. Takes ~18mins to compile) and indeed found two problems:

1. Linux contains assembler-with-cpp files. When compiling with clang, it processes it with -E before passing the result to as. There are different rules on whether whitespace can be completely removed (AvoidConcat) in asm files. I changed ccache to not pass -fminimize-whitespace to assembler files and added an error if one tries.

2. Line breaks outside of macros are (more) significant in assembler files. I tried to rely more on Tok.getLocation() than Tok.isAtStartOfLine() (which is pretty unreliable) to determine line breaks, which unfortunately caused differences even without -fminimize-whitespace. The patch is using Tok.isAtStartOfLine() again.

The clang-13 release branch will be created on July 27. Is there any hope to get this merged by then?

[Meinersbur]

• Revert test changes

[aaron.ballman]

In D104601#2895941, @Meinersbur wrote:

I compiled the Linux kernel (default config, excludes most drivers. Takes ~18mins to compile) and indeed found two problems:

Thank you, that's super helpful validation!

The clang-13 release branch will be created on July 27. Is there any hope to get this merged by then?

I think there is, but I'm an eternal optimist. :-) This LGTM, but you should wait a day or two before landing it in case @dblaikie or @rsmith have concerns.

clang/lib/Driver/ToolChains/Clang.cpp

6043–6046

One downside to this approach as opposed to using a switch is that it'll be easy to add new languages and forget to update this. However, we don't do that particularly often and this will loudly tell users about the lack of support, so I think it's fine as-is.

[Meinersbur]

In D104601#2896091, @aaron.ballman wrote:

I think there is, but I'm an eternal optimist. :-) This LGTM, but you should wait a day or two before landing it in case @dblaikie or @rsmith have concerns.

Of course.

clang/lib/Driver/ToolChains/Clang.cpp

6043–6046

I used the types::isABC functions because if a new input type is added, it will either be added to one of the isABC functions. If not, it would be save to not allow whitespace minimization with it until verified.

However, I did not think about the warning for missing enums. I am going to use a switch instead.

[Meinersbur]

• Introduce types::isDerivedFromC
• Print input type in error message

[Meinersbur]

Because of how large the switch construct would have been, I created a new function types::isDerivedFromC together with the other functions. These commonly have default-cases so compilers would not warn when Types.def is amended, but isDerivedFromC can be found between other functions that would need to be updated.

[aaron.ballman]

In D104601#2898095, @Meinersbur wrote:

Because of how large the switch construct would have been, I created a new function types::isDerivedFromC together with the other functions. These commonly have default-cases so compilers would not warn when Types.def is amended, but isDerivedFromC can be found between other functions that would need to be updated.

Thank you, I think that turned out cleanly!

clang/lib/Driver/Types.cpp

173 ↗

(On Diff #360977)

Heh, I had to go look this one up. TIL... :-D

[mstorsjo]

This broke some cases for me, where the output is missing some newlines, breaking the output badly. I’ll try to provide a repro…

[mstorsjo]

In D104601#2906588, @mstorsjo wrote:

This broke some cases for me, where the output is missing some newlines, breaking the output badly. I’ll try to provide a repro…

https://martin.st/temp/repro.tar.xz

clang -target x86_64-windows-gnu -E -P _mkerrcodes.h -Iinclude

The output (at the end) has missing newlines (e.g. around GPG_ERR_ETXTBSY).

[Meinersbur]

Looking into it...

[Meinersbur]

Proposed fix here: D106924

The reproducer had another whitespace difference before and after D104601: typedef __builtin_va_list __gnuc_va_list; instead of typedef __builtin_va_list __gnuc_va_list; (two spaces before "typedef" instead of one). I assume this is not the issue, especially since the source file (include\vadefs.h) actually has two spaces before "typedef".

[romanovvlad]

Hi @Meinersbur,

It seems the patch introduces one more regression. The following test doesn't pass on Windows:

// RUN: %clang -E %s -o %t.ii
// RUN: %clang %t.ii

#include "string.h"

int main() {
  return 0;
}

The following macro from vcruntime.h:

#define _CRT_BEGIN_C_HEADER            \
    __pragma(pack(push, _CRT_PACKING)) \
    extern "C" {

Becomes

#pragma pack(push, 8) extern "C" {

in the preprocessed file.

I'm not an expert in this code, but partially returning old behavior helped with that:

diff --git a/clang/lib/Frontend/PrintPreprocessedOutput.cpp b/clang/lib/Frontend/PrintPreprocessedOutput.cpp
index b725956..b49b247 100644
--- a/clang/lib/Frontend/PrintPreprocessedOutput.cpp
+++ b/clang/lib/Frontend/PrintPreprocessedOutput.cpp
@@ -772,6 +772,7 @@ static void PrintPreprocessedTokens(Preprocessor &PP, Token &Tok,
   bool IsStartOfLine = false;
   char Buffer[256];
   while (1) {
+    Callbacks->MoveToLine(Tok.getLocation(), /*RequireStartOfLine=*/false);
     // Two lines joined with line continuation ('\' as last character on the
     // line) must be emitted as one line even though Tok.getLine() returns two
     // different values. In this situation Tok.isAtStartOfLine() is false even

Could you please take a look?

[alexfh]

This commit changes the behavior of clang -E -P even when no -fminimize-whitespace is used. This breaks certain use cases like using clang to preprocess files for flex, which turns out to be sensitive to the presence of line breaks in places where C++ compilers aren't.

An isolated test case:

$ clang-old -E -x c++ -P - -o /tmp/pp.good
#define I(x, ...) \
 x { return X##x; }



#ifndef A
#define A(op, x) I(op, x)
#endif

A(foo, {







})
A(bar, {})
$ cat /tmp/pp.good
foo { return Xfoo; }
bar { return Xbar; }
$ clang-new -E -x c++ -P - -o /tmp/pp.bad
#define I(x, ...) \
 x { return X##x; }



#ifndef A
#define A(op, x) I(op, x)
#endif

A(foo, {







})
A(bar, {})
$ cat /tmp/pp.bad
foo { return Xfoo; }bar { return Xbar; }

Please fix or revert the commit.

Thanks!

[alexfh]

In D104601#2915102, @alexfh wrote:

This commit changes the behavior of clang -E -P even when no -fminimize-whitespace is used. This breaks certain use cases like using clang to preprocess files for flex, which turns out to be sensitive to the presence of line breaks in places where C++ compilers aren't.

An isolated test case:

$ clang-old -E -x c++ -P - -o /tmp/pp.good
#define I(x, ...) \
 x { return X##x; }



#ifndef A
#define A(op, x) I(op, x)
#endif

A(foo, {







})
A(bar, {})
$ cat /tmp/pp.good
foo { return Xfoo; }
bar { return Xbar; }
$ clang-new -E -x c++ -P - -o /tmp/pp.bad
#define I(x, ...) \
 x { return X##x; }



#ifndef A
#define A(op, x) I(op, x)
#endif

A(foo, {







})
A(bar, {})
$ cat /tmp/pp.bad
foo { return Xfoo; }bar { return Xbar; }

Please fix or revert the commit.

Thanks!

IIUC, c6b0b16c0f55c34f4eaa05184815bbbe97f4b750 was aimed to fix a similar issue, but it doesn't fix this specific case. If providing a proper fix quickly isn't feasible, consider reverting these patches.

[mstorsjo]

@tstellar, FYI there are still issues being reported with this commit (which was made before the branch). One fix is committed and a backport request was made in https://llvm.org/PR51261, but there’s still a couple other outstanding issues here.

[alexfh]

Looking at this once again, I'm pretty sure that reverting this is much safer than trying to fix forward. Unless there's a really trivial fix to the outstanding issues, I'll revert this later today.

[Meinersbur]

I am working on a fix, but I wouldn't mind reverting.

[aaron.ballman]

In D104601#2916887, @Meinersbur wrote:

I am working on a fix, but I wouldn't mind reverting.

I would be comfortable reverting the feature for Clang 13 and fixing forward on trunk (unless there's a need to revert from trunk temporarily, of course). Giving the feature a full release to bake isn't a bad outcome.

[Meinersbur]

@romanovvlad This is due to -fms-extensions. It Expands __Pragma to #pragma instead of keeping it a __Pragma. This is a one-line fix.

@alexfh This was fixed by D106924

I would suggest to not revert. Will upload a patch for -fms-extensions after some cleanup.

[Meinersbur]

In D104601#2916897, @aaron.ballman wrote:

In D104601#2916887, @Meinersbur wrote:

I am working on a fix, but I wouldn't mind reverting.

I would be comfortable reverting the feature for Clang 13 and fixing forward on trunk (unless there's a need to revert from trunk temporarily, of course). Giving the feature a full release to bake isn't a bad outcome.

While this means that ccache can only use this feature when clang-14 is detected, I fully understand.

[aaron.ballman]

In D104601#2916986, @Meinersbur wrote:

In D104601#2916897, @aaron.ballman wrote:

In D104601#2916887, @Meinersbur wrote:

I am working on a fix, but I wouldn't mind reverting.

I would be comfortable reverting the feature for Clang 13 and fixing forward on trunk (unless there's a need to revert from trunk temporarily, of course). Giving the feature a full release to bake isn't a bad outcome.

While this means that ccache can only use this feature when clang-14 is detected, I fully understand.

Correct -- that would be unfortunate as I believe you were hoping for this to be in Clang 13 for ccache support. My fear of having this in Clang 13 is that very early testing has found several breakages so I worry if we've not had enough time to shake all those out. Having a bit more time might build our confidence. (So the result, to me, should be either that we back this out of the Clang 13 branch if we're still worried or we patch the Clang 13 branch if we think we've got all the cases, but I want to make sure we don't leave it somewhere in the middle for the release branch.)

[Meinersbur]

Patch uploaded here: D107183

[Meinersbur]

Correct -- that would be unfortunate as I believe you were hoping for this to be in Clang 13 for ccache support.

Yes, that would have been the ideal outcome.

[alexfh]

In D104601#2916973, @Meinersbur wrote:

@romanovvlad This is due to -fms-extensions. It Expands __Pragma to #pragma instead of keeping it a __Pragma. This is a one-line fix.

@alexfh This was fixed by D106924

You're right. It turns out that my comment https://reviews.llvm.org/D104601#2915122 was a mistake and c6b0b16c0f55c34f4eaa05184815bbbe97f4b750 actually fixes this particular issue.

I would suggest to not revert. Will upload a patch for -fms-extensions after some cleanup.

I'm running more thorough testing of clang with the c6b0b16c0f55c34f4eaa05184815bbbe97f4b750 commit to ensure we're not missing anything else here.

[mstorsjo]

FYI, 13.0.0 rc1 is getting tagged on Monday, so it’d be good to have the branch in a usable state by then, either with all fixes we currently have in main, or reverted.

[Meinersbur]

@mstorsjo I've taken all steps required for the resolution suggested @aaron.ballman. llvm.org/PR51300 suberseedes llvm.org/PR51261 (release-13.x branch is under @tstellard's control). D107183 has been pushed to main to fix the outstanding issue discovered by @romanovvlad (unfortunately without pre-commit review, but given that this might be blocking them, the patch is small and you would like the situation to be resolved by then, I think a post-commit review is acceptable).

@alexfh Happy to fix any additional issues you may find. The -fminimize-whitespace feature unfortunately required some restructuring of the the code since the decision on when to insert newline were done in many different places using different logics.

[romanovvlad]

In D104601#2917065, @Meinersbur wrote:

Patch uploaded here: D107183

The patch resolves the issue. Thanks!

[tstellar]

Do we have all the issues fixed in trunk yet or do we need to revert in the release/13.x branch.

[Meinersbur]

In D104601#2919775, @tstellar wrote:

Do we have all the issues fixed in trunk yet or do we need to revert in the release/13.x branch.

All known issues have been fixed on trunk. However, @alexfh said they are going to do more thorough testing and @aaron.ballman has not changed their suggestion to revert on release/13.x. Since you just reverted on clang-13.x, I'd say the decision has been made.

[RKSimon]

clang/lib/Frontend/PrintPreprocessedOutput.cpp

680

@Meinersbur Static analysis is warning that these are both the same - should one be EmittedDirectiveOnThisLine ?

[manmanren]

This commit seems to cause some regression for "-save-temps" as there is no new line before the pragma. See the below test case, -E will output
int test();#pragma clang assume_nonnull
It will fail the compilation on the preprocessed output with
error: expected unqualified-id
int test();#pragma clang assume_nonnull end

^

Thanks,

Manman

cat test-pragma.mm
// RUN: %clang -E -o - %s | FileCheck %s

#define CF_ASSUME_NONNULL_BEGIN _Pragma("clang assume_nonnull begin")
#define CF_ASSUME_NONNULL_END _Pragma("clang assume_nonnull end")

CF_ASSUME_NONNULL_BEGIN
int test();

CF_ASSUME_NONNULL_END
// CHECK-NOT: test();#pragma clang assume_nonnull

[Meinersbur]

In D104601#3105044, @manmanren wrote:

It will fail the compilation on the preprocessed output with
error: expected unqualified-id
int test();#pragma clang assume_nonnull end

The handler for assume_nonull passes an invalid SourceLocation if embedded in in a _Pragma. Not sure whether this is already a bug, but we should insert semantically relevant newlines even if the line for the #pragma is unknown. Fixed in rG1606022fab2d90ed8ee6d15800ec1c2c293db20e. Thanks for the report.

I looked into why it did work before -fminimize-whitespace introduced since the if (PLoc.isInvalid()) return; bail-out existed as well. There was another function startNewLineIfNeeded(bool ShouldUpdateCurrentLine) that was called regardless of PLoc and I folded the functionality into MoveToLine since having two functions with unclear separation between them (i.e. when should ShouldUpdateCurrentLine be true) made things difficult.

clang/lib/Frontend/PrintPreprocessedOutput.cpp

680

Fixed in rG8f099d17a1bee857ada3c5af032cfcb559252024. Thanks for the report and sorry for not seeing you comment until now.

clang/docs/ClangCommandLineReference.rst

 .. option:: -fuse-init-array, -fno-use-init-array
 
 .. option:: -fuse-ld=<arg>
 
 .. option:: -fuse-line-directives, -fno-use-line-directives
 
 Use #line in preprocessed output
 
+.. option:: -fnormalize-whitespace, -fno-normalize-whitespace
+
+Ignore the whitespace from the input file when emitting preprocessor output. It will only contain whitespace when necessary, e.g. to keep two minus signs from merging into to an increment operator. Useful with the -P option to normlize whitespace such that two files with only formatted changes are equal.
+
+Incompatible with -traditional-cpp.
+
 .. option:: -fvalidate-ast-input-files-content
 
 Compute and store the hash of input files used to build an AST. Files with mismatching mtime's are considered valid if both contents is identical
 
 .. option:: -fveclib=<arg>
 
 Use the given vector functions library
 
 .. option:: -fvectorize, -fno-vectorize, -ftree-vectorize

clang/include/clang/Driver/Options.td

 def frewrite_map_file_EQ : Joined<["-"], "frewrite-map-file=">,
                            Group<f_Group>,
                            Flags<[NoXarchOption, CC1Option]>,
                            MarshallingInfoStringVector<CodeGenOpts<"RewriteMapFiles">>;
 
 defm use_line_directives : BoolFOption<"use-line-directives",
   PreprocessorOutputOpts<"UseLineDirectives">, DefaultFalse,
   PosFlag<SetTrue, [CC1Option], "Use #line in preprocessed output">, NegFlag<SetFalse>>;
+defm normalize_whitespace : BoolFOption<"normalize-whitespace",
+  PreprocessorOutputOpts<"NormalizeWhitespace">, DefaultFalse,
+  PosFlag<SetTrue, [CC1Option], "Ignore whitespace from input when proprocessing">, NegFlag<SetFalse>>;
 
 def ffreestanding : Flag<["-"], "ffreestanding">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Assert that the compilation takes place in a freestanding environment">,
   MarshallingInfoFlag<LangOpts<"Freestanding">>;
 def fgnuc_version_EQ : Joined<["-"], "fgnuc-version=">, Group<f_Group>,
   HelpText<"Sets various macros to claim compatibility with the given GCC version (default is 4.2.1)">,
   Flags<[CC1Option, CoreOption]>;
 // We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension

clang/include/clang/Frontend/PreprocessorOutputOptions.h

public:
   unsigned ShowComments : 1;       ///< Show comments.
   unsigned ShowLineMarkers : 1;    ///< Show \#line markers.
   unsigned UseLineDirectives : 1;   ///< Use \#line instead of GCC-style \# N.
   unsigned ShowMacroComments : 1;  ///< Show comments, even in macros.
   unsigned ShowMacros : 1;         ///< Print macro definitions.
   unsigned ShowIncludeDirectives : 1;  ///< Print includes, imports etc. within preprocessed output.
   unsigned RewriteIncludes : 1;    ///< Preprocess include directives only.
   unsigned RewriteImports  : 1;    ///< Include contents of transitively-imported modules.
+  unsigned NormalizeWhitespace : 1; ///< Ignore whitespace from input.
 
 public:
   PreprocessorOutputOptions() {
     ShowCPP = 0;
     ShowComments = 0;
     ShowLineMarkers = 1;
     UseLineDirectives = 0;
     ShowMacroComments = 0;
     ShowMacros = 0;
     ShowIncludeDirectives = 0;
     RewriteIncludes = 0;
     RewriteImports = 0;
+    NormalizeWhitespace = 0;
   }
 };
 
 }  // end namespace clang
 
 #endif

clang/lib/Driver/ToolChains/Clang.cpp

if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit,
                    options::OPT_fno_register_global_dtors_with_atexit,
                    RawTriple.isOSDarwin() && !KernelOrKext))
     CmdArgs.push_back("-fregister-global-dtors-with-atexit");
 
   // -fno-use-line-directives is default.
   if (Args.hasFlag(options::OPT_fuse_line_directives,
                    options::OPT_fno_use_line_directives, false))
     CmdArgs.push_back("-fuse-line-directives");
+  if (Args.hasFlag(options::OPT_fnormalize_whitespace,
+                   options::OPT_fno_normalize_whitespace, false))
+    CmdArgs.push_back("-fnormalize-whitespace");
 
   // -fms-extensions=0 is default.
   if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
                    IsWindowsMSVC))
     CmdArgs.push_back("-fms-extensions");
 
   // -fms-compatibility=0 is default.
   bool IsMSVCCompat = Args.hasFlag(
       options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility,
       (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions,
                                      options::OPT_fno_ms_extensions, true)));
   if (IsMSVCCompat)
     CmdArgs.push_back("-fms-compatibility");
 
   // Handle -fgcc-version, if present.
   VersionTuple GNUCVer;
   if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
     // Check that the version has 1 to 3 components and the minor and patch
     // versions fit in two decimal digits.

clang/lib/Frontend/PrintPreprocessedOutput.cpp

private:
   SrcMgr::CharacteristicKind FileType;
   SmallString<512> CurFilename;
   bool Initialized;
   bool DisableLineMarkers;
   bool DumpDefines;
   bool DumpIncludeDirectives;
   bool UseLineDirectives;
   bool IsFirstFileEntered;
+  bool NormalizeWhitespace;
+
+  Token PrevTok;
+  Token PrevPrevTok;
+
 public:
   PrintPPOutputPPCallbacks(Preprocessor &pp, raw_ostream &os, bool lineMarkers,
                            bool defines, bool DumpIncludeDirectives,
-                           bool UseLineDirectives)
+                           bool UseLineDirectives, bool NormalizeWhitespace)
       : PP(pp), SM(PP.getSourceManager()), ConcatInfo(PP), OS(os),
         DisableLineMarkers(lineMarkers), DumpDefines(defines),
         DumpIncludeDirectives(DumpIncludeDirectives),
-        UseLineDirectives(UseLineDirectives) {
+        UseLineDirectives(UseLineDirectives),
+        NormalizeWhitespace(NormalizeWhitespace) {
     CurLine = 0;
     CurFilename += "<uninit>";
     EmittedTokensOnThisLine = false;
     EmittedDirectiveOnThisLine = false;
     FileType = SrcMgr::C_User;
     Initialized = false;
     IsFirstFileEntered = false;
+
+    PrevTok.startToken();
+    PrevPrevTok.startToken();
   }
 
+  bool isNormalizingWhitespace() const { return NormalizeWhitespace; }
+
   void setEmittedTokensOnThisLine() { EmittedTokensOnThisLine = true; }
   bool hasEmittedTokensOnThisLine() const { return EmittedTokensOnThisLine; }
 
   void setEmittedDirectiveOnThisLine() { EmittedDirectiveOnThisLine = true; }
   bool hasEmittedDirectiveOnThisLine() const {
     return EmittedDirectiveOnThisLine;
   }
 
-  bool startNewLineIfNeeded(bool ShouldUpdateCurrentLine = true);
+  /// Ensure that the output stream position is at the beginning of a new line
+  /// and inserts one if it does not.It is intended to ensure that directives
+  /// inserted by the directives not from the input source (such as #line) are
+  /// in the first column. To insert newlines the represent the input, use
+  /// MoveToLine(/*...*/, /*RequireStartOfLine=*/true).
+  void startNewLineIfNeeded();
 
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override;
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
                           CharSourceRange FilenameRange, const FileEntry *File,
                           StringRef SearchPath, StringRef RelativePath,
void PragmaWarning(SourceLocation Loc, StringRef WarningSpec,
                      ArrayRef<int> Ids) override;
   void PragmaWarningPush(SourceLocation Loc, int Level) override;
   void PragmaWarningPop(SourceLocation Loc) override;
   void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) override;
   void PragmaExecCharsetPop(SourceLocation Loc) override;
   void PragmaAssumeNonNullBegin(SourceLocation Loc) override;
   void PragmaAssumeNonNullEnd(SourceLocation Loc) override;
 
-  bool HandleFirstTokOnLine(Token &Tok);
+  /// Insert whitespace before emitting the next token.
+  ///
+  /// @param Tok             Next token to be emitted.
+  /// @param RequireSpace    Ensure at least one whitespace is emitted. Useful
+  ///                        if non-tokens have been emitted to the stream.
+  /// @param RequireSameLine Never emit newlines. Useful when semantics depend
+  ///                        on being on the same line, such as directives.
+  void HandleWhitespaceBeforeTok(Token &Tok, bool RequireSpace,
+                                 bool RequireSameLine);
 
   /// Move to the line of the provided source location. This will
-  /// return true if the output stream required adjustment or if
-  /// the requested location is on the first line.
-  bool MoveToLine(SourceLocation Loc) {
+  /// return true if a newline was inserted or if
+  /// the requested location is the first token on the first line.
+  /// In these cases the next output will be the first column on the line and
+  /// make it possible to insert indention. The newline is was inserted
+  /// implicitly when at the beginning of the file.
+  ///
+  /// @param Tok                 Token where to move to.
+  /// @param RequiresStartOfLine Whether the next line depends on being in the
+  ///                            first column, such as a directive.
+  ///
+  /// @return Whether column adjustments are necessary.
+  bool MoveToLine(const Token &Tok, bool RequireStartOfLine) {
+    PresumedLoc PLoc = SM.getPresumedLoc(Tok.getLocation());
+    if (PLoc.isInvalid())
+      return false;
+    bool IsFirstInFile = Tok.isAtStartOfLine() && PLoc.getLine() == 1;
+    return MoveToLine(PLoc.getLine(), RequireStartOfLine) || IsFirstInFile;
+  }
+
+  /// Move to the line of the provided source location. Returns true if a new
+  /// line was inserted.
+  bool MoveToLine(SourceLocation Loc, bool RequireStartOfLine) {
     PresumedLoc PLoc = SM.getPresumedLoc(Loc);
     if (PLoc.isInvalid())
       return false;
-    return MoveToLine(PLoc.getLine()) || (PLoc.getLine() == 1);
+    return MoveToLine(PLoc.getLine(), RequireStartOfLine);
   }
-  bool MoveToLine(unsigned LineNo);
+  bool MoveToLine(unsigned LineNo, bool RequireStartOfLine);
 
   bool AvoidConcat(const Token &PrevPrevTok, const Token &PrevTok,
                    const Token &Tok) {
     return ConcatInfo.AvoidConcat(PrevPrevTok, PrevTok, Tok);
   }
   void WriteLineInfo(unsigned LineNo, const char *Extra=nullptr,
                      unsigned ExtraLen=0);
   bool LineMarkersAreDisabled() const { return DisableLineMarkers; }
public:
   void BeginModule(const Module *M);
   void EndModule(const Module *M);
 };
 }  // end anonymous namespace
 
 void PrintPPOutputPPCallbacks::WriteLineInfo(unsigned LineNo,
                                              const char *Extra,
                                              unsigned ExtraLen) {
-  startNewLineIfNeeded(/*ShouldUpdateCurrentLine=*/false);
+  startNewLineIfNeeded();
 
   // Emit #line directives or GNU line markers depending on what mode we're in.
   if (UseLineDirectives) {
     OS << "#line" << ' ' << LineNo << ' ' << '"';
     OS.write_escaped(CurFilename);
     OS << '"';
   } else {
     OS << '#' << ' ' << LineNo << ' ' << '"';
void PrintPPOutputPPCallbacks::WriteLineInfo(unsigned LineNo,
   }
   OS << '\n';
 }
 
 /// MoveToLine - Move the output to the source line specified by the location
 /// object.  We can do this by emitting some number of \n's, or be emitting a
 /// #line directive.  This returns false if already at the specified line, true
 /// if some newlines were emitted.
-bool PrintPPOutputPPCallbacks::MoveToLine(unsigned LineNo) {
+bool PrintPPOutputPPCallbacks::MoveToLine(unsigned LineNo,
+                                          bool RequireStartOfLine) {
+  // If it is required to start a new line or finish the current, insert
+  // vertical whitespace now and take it into account when moving to the
+  // expected line.
+  bool StartedNewLine = false;
+  if ((RequireStartOfLine && EmittedTokensOnThisLine) ||
+      EmittedDirectiveOnThisLine) {
+    OS << '\n';
+    StartedNewLine = true;
+    CurLine += 1;
+    EmittedTokensOnThisLine = false;
+    EmittedDirectiveOnThisLine = false;
+  }
+
   // If this line is "close enough" to the original line, just print newlines,
   // otherwise print a #line directive.
-  if (LineNo-CurLine <= 8) {
-    if (LineNo-CurLine == 1)
-      OS << '\n';
-    else if (LineNo == CurLine)
-      return false;    // Spelling line moved, but expansion line didn't.
-    else {
-      const char *NewLines = "\n\n\n\n\n\n\n\n";
-      OS.write(NewLines, LineNo-CurLine);
-    }
+  if (CurLine == LineNo) {
+    // Nothing to do if we are already on the correct line.
+  } else if (!StartedNewLine && (!NormalizeWhitespace || !DisableLineMarkers) &&
+             LineNo - CurLine == 1) {
+    // Printing a single line has priority over printing a #line directive, even
+    // when normalizing whitespace which otherwise would print #line directives
+    // for every single line.
+    StartedNewLine = true;
+  } else if (!NormalizeWhitespace && LineNo - CurLine <= 8) {
+    OS.write(NewLines, LineNo - CurLine);
+    StartedNewLine = true;
   } else if (!DisableLineMarkers) {
     // Emit a #line or line marker.
     WriteLineInfo(LineNo, nullptr, 0);
-  } else {
-    // Okay, we're in -P mode, which turns off line markers.  However, we still
-    // need to emit a newline between tokens on different lines.
-    startNewLineIfNeeded(/*ShouldUpdateCurrentLine=*/false);
+    StartedNewLine = true;
+  }
+
+  if (StartedNewLine) {
+    EmittedTokensOnThisLine = false;
+    EmittedDirectiveOnThisLine = false;
   }
 
   CurLine = LineNo;
-  return true;
+  return StartedNewLine;
 }
 
-bool
-PrintPPOutputPPCallbacks::startNewLineIfNeeded(bool ShouldUpdateCurrentLine) {
+void PrintPPOutputPPCallbacks::startNewLineIfNeeded() {
   if (EmittedTokensOnThisLine || EmittedDirectiveOnThisLine) {
     OS << '\n';
     EmittedTokensOnThisLine = false;
     EmittedDirectiveOnThisLine = false;
-    if (ShouldUpdateCurrentLine)
-      ++CurLine;
-    return true;
   }
-
-  return false;
 }
 
 /// FileChanged - Whenever the preprocessor enters or exits a #include file
 /// it invokes this handler.  Update our conception of the current source
 /// position.
 void PrintPPOutputPPCallbacks::FileChanged(SourceLocation Loc,
                                            FileChangeReason Reason,
                                        SrcMgr::CharacteristicKind NewFileType,
                                        FileID PrevFID) {
   // Unless we are exiting a #include, make sure to skip ahead to the line the
   // #include directive was at.
   SourceManager &SourceMgr = SM;
 
   PresumedLoc UserLoc = SourceMgr.getPresumedLoc(Loc);
   if (UserLoc.isInvalid())
     return;
 
   unsigned NewLine = UserLoc.getLine();
 
   if (Reason == PPCallbacks::EnterFile) {
     SourceLocation IncludeLoc = UserLoc.getIncludeLoc();
     if (IncludeLoc.isValid())
-      MoveToLine(IncludeLoc);
+      MoveToLine(IncludeLoc, /*RequireStartOfLine=*/false);
   } else if (Reason == PPCallbacks::SystemHeaderPragma) {
     // GCC emits the # directive for this directive on the line AFTER the
     // directive and emits a bunch of spaces that aren't needed. This is because
     // otherwise we will emit a line marker for THIS line, which requires an
     // extra blank line after the directive to avoid making all following lines
     // off by one. We can do better by simply incrementing NewLine here.
     NewLine += 1;
   }
 
   CurLine = NewLine;
 
   CurFilename.clear();
   CurFilename += UserLoc.getFilename();
   FileType = NewFileType;
 
   if (DisableLineMarkers) {
-    startNewLineIfNeeded(/*ShouldUpdateCurrentLine=*/false);
+    if (!NormalizeWhitespace)
+      startNewLineIfNeeded();
     return;
   }
 
   if (!Initialized) {
     WriteLineInfo(CurLine);
     Initialized = true;
   }
 
void PrintPPOutputPPCallbacks::InclusionDirective(
     const FileEntry *File,
     StringRef SearchPath,
     StringRef RelativePath,
     const Module *Imported,
     SrcMgr::CharacteristicKind FileType) {
   // In -dI mode, dump #include directives prior to dumping their content or
   // interpretation.
   if (DumpIncludeDirectives) {
-    startNewLineIfNeeded();
-    MoveToLine(HashLoc);
+    MoveToLine(HashLoc, /*RequireStartOfLine=*/true);
     const std::string TokenText = PP.getSpelling(IncludeTok);
     assert(!TokenText.empty());
     OS << "#" << TokenText << " "
        << (IsAngled ? '<' : '"') << FileName << (IsAngled ? '>' : '"')
        << " /* clang -E -dI */";
     setEmittedDirectiveOnThisLine();
-    startNewLineIfNeeded();
   }
 
   // When preprocessing, turn implicit imports into module import pragmas.
   if (Imported) {
     switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) {
     case tok::pp_include:
     case tok::pp_import:
     case tok::pp_include_next:
-      startNewLineIfNeeded();
-      MoveToLine(HashLoc);
+      MoveToLine(HashLoc, /*RequireStartOfLine=*/true);
       OS << "#pragma clang module import " << Imported->getFullModuleName(true)
          << " /* clang -E: implicit import for "
          << "#" << PP.getSpelling(IncludeTok) << " "
          << (IsAngled ? '<' : '"') << FileName << (IsAngled ? '>' : '"')
          << " */";
-      // Since we want a newline after the pragma, but not a #<line>, start a
-      // new line immediately.
-      EmittedTokensOnThisLine = true;
-      startNewLineIfNeeded();
+      setEmittedDirectiveOnThisLine();
       break;
 
     case tok::pp___include_macros:
       // #__include_macros has no effect on a user of a preprocessed source
       // file; the only effect is on preprocessing.
       //
       // FIXME: That's not *quite* true: it causes the module in question to
       // be loaded, which can affect downstream diagnostics.
void PrintPPOutputPPCallbacks::EndModule(const Module *M) {
   startNewLineIfNeeded();
   OS << "#pragma clang module end /*" << M->getFullModuleName(true) << "*/";
   setEmittedDirectiveOnThisLine();
 }
 
 /// Ident - Handle #ident directives when read by the preprocessor.
 ///
 void PrintPPOutputPPCallbacks::Ident(SourceLocation Loc, StringRef S) {
-  MoveToLine(Loc);
+  MoveToLine(Loc, /*RequireStartOfLine=*/true);
 
   OS.write("#ident ", strlen("#ident "));
   OS.write(S.begin(), S.size());
-  EmittedTokensOnThisLine = true;
+  setEmittedTokensOnThisLine();
 }
 
 /// MacroDefined - This hook is called whenever a macro definition is seen.
 void PrintPPOutputPPCallbacks::MacroDefined(const Token &MacroNameTok,
                                             const MacroDirective *MD) {
   const MacroInfo *MI = MD->getMacroInfo();
   // Only print out macro definitions in -dD mode.
   if (!DumpDefines ||
       // Ignore __FILE__ etc.
       MI->isBuiltinMacro()) return;
 
-  MoveToLine(MI->getDefinitionLoc());
+  MoveToLine(MI->getDefinitionLoc(), /*RequireStartOfLine=*/true);
   PrintMacroDefinition(*MacroNameTok.getIdentifierInfo(), *MI, PP, OS);
   setEmittedDirectiveOnThisLine();
 }
 
 void PrintPPOutputPPCallbacks::MacroUndefined(const Token &MacroNameTok,
                                               const MacroDefinition &MD,
                                               const MacroDirective *Undef) {
   // Only print out macro definitions in -dD mode.
   if (!DumpDefines) return;
 
-  MoveToLine(MacroNameTok.getLocation());
+  MoveToLine(MacroNameTok.getLocation(), /*RequireStartOfLine=*/true);
   OS << "#undef " << MacroNameTok.getIdentifierInfo()->getName();
   setEmittedDirectiveOnThisLine();
 }
 
 static void outputPrintable(raw_ostream &OS, StringRef Str) {
   for (unsigned char Char : Str) {
     if (isPrintable(Char) && Char != '\\' && Char != '"')
       OS << (char)Char;
     else // Output anything hard as an octal escape.
       OS << '\\'
          << (char)('0' + ((Char >> 6) & 7))
          << (char)('0' + ((Char >> 3) & 7))
          << (char)('0' + ((Char >> 0) & 7));
   }
 }
 
 void PrintPPOutputPPCallbacks::PragmaMessage(SourceLocation Loc,
                                              StringRef Namespace,
                                              PragmaMessageKind Kind,
                                              StringRef Str) {
-  startNewLineIfNeeded();
-  MoveToLine(Loc);
+  MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma ";
   if (!Namespace.empty())
     OS << Namespace << ' ';
   switch (Kind) {
     case PMK_Message:
       OS << "message(\"";
       break;
     case PMK_Warning:
       OS << "warning \"";
       break;
     case PMK_Error:
       OS << "error \"";
       break;
   }
 
   outputPrintable(OS, Str);
   OS << '"';
   if (Kind == PMK_Message)
     OS << ')';
   setEmittedDirectiveOnThisLine();
 }
 
 void PrintPPOutputPPCallbacks::PragmaDebug(SourceLocation Loc,
                                            StringRef DebugType) {
-  startNewLineIfNeeded();
-  MoveToLine(Loc);
+  MoveToLine(Loc, /*RequireStartOfLine=*/true);
 
   OS << "#pragma clang __debug ";
   OS << DebugType;
 
   setEmittedDirectiveOnThisLine();
 }
 
 void PrintPPOutputPPCallbacks::
 PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace) {
-  startNewLineIfNeeded();
-  MoveToLine(Loc);
+  MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma " << Namespace << " diagnostic push";
   setEmittedDirectiveOnThisLine();
 }
 
 void PrintPPOutputPPCallbacks::
 PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace) {
-  startNewLineIfNeeded();
-  MoveToLine(Loc);
+  MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma " << Namespace << " diagnostic pop";
   setEmittedDirectiveOnThisLine();
 }
 
 void PrintPPOutputPPCallbacks::PragmaDiagnostic(SourceLocation Loc,
                                                 StringRef Namespace,
                                                 diag::Severity Map,
                                                 StringRef Str) {
-  startNewLineIfNeeded();
-  MoveToLine(Loc);
+  MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma " << Namespace << " diagnostic ";
   switch (Map) {
   case diag::Severity::Remark:
     OS << "remark";
     break;
   case diag::Severity::Warning:
     OS << "warning";
     break;
void PrintPPOutputPPCallbacks::PragmaDiagnostic(SourceLocation Loc,
   }
   OS << " \"" << Str << '"';
   setEmittedDirectiveOnThisLine();
 }
 
 void PrintPPOutputPPCallbacks::PragmaWarning(SourceLocation Loc,
                                              StringRef WarningSpec,
                                              ArrayRef<int> Ids) {
-  startNewLineIfNeeded();
-  MoveToLine(Loc);
+  MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma warning(" << WarningSpec << ':';
   for (ArrayRef<int>::iterator I = Ids.begin(), E = Ids.end(); I != E; ++I)
     OS << ' ' << *I;
   OS << ')';
   setEmittedDirectiveOnThisLine();
 }
 
 void PrintPPOutputPPCallbacks::PragmaWarningPush(SourceLocation Loc,
                                                  int Level) {
-  startNewLineIfNeeded();
-  MoveToLine(Loc);
+  MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma warning(push";
   if (Level >= 0)
     OS << ", " << Level;
   OS << ')';
   setEmittedDirectiveOnThisLine();
 }
 
 void PrintPPOutputPPCallbacks::PragmaWarningPop(SourceLocation Loc) {
-  startNewLineIfNeeded();
-  MoveToLine(Loc);
+  MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma warning(pop)";
   setEmittedDirectiveOnThisLine();
 }
 
 void PrintPPOutputPPCallbacks::PragmaExecCharsetPush(SourceLocation Loc,
                                                      StringRef Str) {
-  startNewLineIfNeeded();
-  MoveToLine(Loc);
+  MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma character_execution_set(push";
   if (!Str.empty())
     OS << ", " << Str;
   OS << ')';
   setEmittedDirectiveOnThisLine();
 }
 
 void PrintPPOutputPPCallbacks::PragmaExecCharsetPop(SourceLocation Loc) {
-  startNewLineIfNeeded();
-  MoveToLine(Loc);
+  MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma character_execution_set(pop)";
   setEmittedDirectiveOnThisLine();
 }
 
 void PrintPPOutputPPCallbacks::
 PragmaAssumeNonNullBegin(SourceLocation Loc) {
-  startNewLineIfNeeded();
-  MoveToLine(Loc);
+  MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma clang assume_nonnull begin";
   setEmittedDirectiveOnThisLine();
 }
 
 void PrintPPOutputPPCallbacks::
 PragmaAssumeNonNullEnd(SourceLocation Loc) {
-  startNewLineIfNeeded();
-  MoveToLine(Loc);
+  MoveToLine(Loc, /*RequireStartOfLine=*/true);
   OS << "#pragma clang assume_nonnull end";
   setEmittedDirectiveOnThisLine();
 }
 
-/// HandleFirstTokOnLine - When emitting a preprocessed file in -E mode, this
-/// is called for the first token on each new line.  If this really is the start
-/// of a new logical line, handle it and return true, otherwise return false.
-/// This may not be the start of a logical line because the "start of line"
-/// marker is set for spelling lines, not expansion ones.
-bool PrintPPOutputPPCallbacks::HandleFirstTokOnLine(Token &Tok) {
-  // Figure out what line we went to and insert the appropriate number of
-  // newline characters.
-  if (!MoveToLine(Tok.getLocation()))
-    return false;
+void PrintPPOutputPPCallbacks::HandleWhitespaceBeforeTok(Token &Tok,
+                                                         bool RequireSpace,
+                                                         bool RequireSameLine) {
+  // These tokens are not expand to anything and don't need whitespace before
+  // them.
+  if (Tok.is(tok::eof) ||
+      (Tok.isAnnotation() && !Tok.is(tok::annot_header_unit) &&
+       !Tok.is(tok::annot_module_begin) && !Tok.is(tok::annot_module_end)))
+    return;
 
+  if (!RequireSameLine && MoveToLine(Tok, /*RequireStartOfLine=*/false)) {
+    if (NormalizeWhitespace) {
+      // Avoid interpreting hash as a directive under -fpreprocessed.
+      if (Tok.is(tok::hash))
+        OS << ' ';
+    } else {
       // Print out space characters so that the first token on a line is
       // indented for easy reading.
       unsigned ColNo = SM.getExpansionColumnNumber(Tok.getLocation());
 
-  // The first token on a line can have a column number of 1, yet still expect
-  // leading white space, if a macro expansion in column 1 starts with an empty
-  // macro argument, or an empty nested macro expansion. In this case, move the
-  // token to column 2.
+      // The first token on a line can have a column number of 1, yet still
+      // expect leading white space, if a macro expansion in column 1 starts
+      // with an empty macro argument, or an empty nested macro expansion. In
+      // this case, move the token to column 2.
       if (ColNo == 1 && Tok.hasLeadingSpace())
         ColNo = 2;
 
       // This hack prevents stuff like:
       // #define HASH #
       // HASH define foo bar
       // From having the # character end up at column 1, which makes it so it
       // is not handled as a #define next time through the preprocessor if in
       // -fpreprocessed mode.
       if (ColNo <= 1 && Tok.is(tok::hash))
         OS << ' ';
 
       // Otherwise, indent the appropriate number of spaces.
       for (; ColNo > 1; --ColNo)
         OS << ' ';
+    }
+  } else {
+    // Insert whitespace between the previous and next token if either
+    // - The input had whitespace between them and we are not in
+    //   whitespace-normalization mode
+    // - The whitespace is necessary to keep the tokens apart and there is not
+    //   already a newline between them
+    if (RequireSpace || (!NormalizeWhitespace && Tok.hasLeadingSpace()) ||
+        ((EmittedTokensOnThisLine || EmittedTokensOnThisLine) &&
+         AvoidConcat(PrevPrevTok, PrevTok, Tok)))
+      OS << ' ';
+  }
 
-  return true;
+  PrevPrevTok = PrevTok;
+  PrevTok = Tok;
 }
 
 void PrintPPOutputPPCallbacks::HandleNewlinesInToken(const char *TokStr,
                                                      unsigned Len) {
   unsigned NumNewlines = 0;
   for (; Len; --Len, ++TokStr) {
     if (*TokStr != '\n' &&
         *TokStr != '\r')
struct UnknownPragmaHandler : public PragmaHandler {
   UnknownPragmaHandler(const char *prefix, PrintPPOutputPPCallbacks *callbacks,
                        bool RequireTokenExpansion)
       : Prefix(prefix), Callbacks(callbacks),
         ShouldExpandTokens(RequireTokenExpansion) {}
   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                     Token &PragmaTok) override {
     // Figure out what line we went to and insert the appropriate number of
     // newline characters.
-    Callbacks->startNewLineIfNeeded();
-    Callbacks->MoveToLine(PragmaTok.getLocation());
+    Callbacks->MoveToLine(PragmaTok.getLocation(), /*RequireStartOfLine=*/true);
     Callbacks->OS.write(Prefix, strlen(Prefix));
+    Callbacks->setEmittedTokensOnThisLine();
 
     if (ShouldExpandTokens) {
       // The first token does not have expanded macros. Expand them, if
       // required.
       auto Toks = std::make_unique<Token[]>(1);
       Toks[0] = PragmaTok;
       PP.EnterTokenStream(std::move(Toks), /*NumToks=*/1,
                           /*DisableMacroExpansion=*/false,
                           /*IsReinject=*/false);
       PP.Lex(PragmaTok);
     }
-    Token PrevToken;
-    Token PrevPrevToken;
-    PrevToken.startToken();
-    PrevPrevToken.startToken();
 
     // Read and print all of the pragma tokens.
+    bool IsFirst = true;
     while (PragmaTok.isNot(tok::eod)) {
-      if (PragmaTok.hasLeadingSpace() ||
-          Callbacks->AvoidConcat(PrevPrevToken, PrevToken, PragmaTok))
-        Callbacks->OS << ' ';
+      Callbacks->HandleWhitespaceBeforeTok(PragmaTok, /*RequireSpace=*/IsFirst,
+                                           /*RequireSameLine=*/true);
+      IsFirst = false;
       std::string TokSpell = PP.getSpelling(PragmaTok);
       Callbacks->OS.write(&TokSpell[0], TokSpell.size());
-
-      PrevPrevToken = PrevToken;
-      PrevToken = PragmaTok;
+      Callbacks->setEmittedTokensOnThisLine();
 
       if (ShouldExpandTokens)
         PP.Lex(PragmaTok);
       else
         PP.LexUnexpandedToken(PragmaTok);
     }
     Callbacks->setEmittedDirectiveOnThisLine();
   }
 };
 } // end anonymous namespace
 
 
 static void PrintPreprocessedTokens(Preprocessor &PP, Token &Tok,
                                     PrintPPOutputPPCallbacks *Callbacks,
                                     raw_ostream &OS) {
   bool DropComments = PP.getLangOpts().TraditionalCPP &&
                       !PP.getCommentRetentionState();
 
   char Buffer[256];
-  Token PrevPrevTok, PrevTok;
-  PrevPrevTok.startToken();
-  PrevTok.startToken();
   while (1) {
-    if (Callbacks->hasEmittedDirectiveOnThisLine()) {
-      Callbacks->startNewLineIfNeeded();
-      Callbacks->MoveToLine(Tok.getLocation());
-    }
-
-    // If this token is at the start of a line, emit newlines if needed.
-    if (Tok.isAtStartOfLine() && Callbacks->HandleFirstTokOnLine(Tok)) {
-      // done.
-    } else if (Tok.hasLeadingSpace() ||
-               // If we haven't emitted a token on this line yet, PrevTok isn't
-               // useful to look at and no concatenation could happen anyway.
-               (Callbacks->hasEmittedTokensOnThisLine() &&
-                // Don't print "-" next to "-", it would form "--".
-                Callbacks->AvoidConcat(PrevPrevTok, PrevTok, Tok))) {
-      OS << ' ';
-    }
+    Callbacks->HandleWhitespaceBeforeTok(Tok, /*RequireSpace=*/false,
+                                         /*RequireSameLine=*/false);
 
     if (DropComments && Tok.is(tok::comment)) {
       // Skip comments. Normally the preprocessor does not generate
       // tok::comment nodes at all when not keeping comments, but under
       // -traditional-cpp the lexer keeps /all/ whitespace, including comments.
-      SourceLocation StartLoc = Tok.getLocation();
-      Callbacks->MoveToLine(StartLoc.getLocWithOffset(Tok.getLength()));
     } else if (Tok.is(tok::eod)) {
       // Don't print end of directive tokens, since they are typically newlines
       // that mess up our line tracking. These come from unknown pre-processor
       // directives or hash-prefixed comments in standalone assembly files.
       PP.Lex(Tok);
       continue;
     } else if (Tok.is(tok::annot_module_include)) {
       // PrintPPOutputPPCallbacks::InclusionDirective handles producing
if (DropComments && Tok.is(tok::comment)) {
       const char *TokPtr = Buffer;
       unsigned Len = PP.getSpelling(Tok, TokPtr);
       OS.write(TokPtr, Len);
 
       // Tokens that can contain embedded newlines need to adjust our current
       // line number.
       if (Tok.getKind() == tok::comment || Tok.getKind() == tok::unknown)
         Callbacks->HandleNewlinesInToken(TokPtr, Len);
+      if (Tok.is(tok::comment) && Len >= 2 && TokPtr[0] == '/' &&
+          TokPtr[1] == '/') {
+        // It's a line comment;
+        // Ensure that we don't concatenate anything behind it.
+        Callbacks->setEmittedDirectiveOnThisLine();
+      }
     } else {
       std::string S = PP.getSpelling(Tok);
       OS.write(S.data(), S.size());
 
       // Tokens that can contain embedded newlines need to adjust our current
       // line number.
       if (Tok.getKind() == tok::comment || Tok.getKind() == tok::unknown)
         Callbacks->HandleNewlinesInToken(S.data(), S.size());
+      if (Tok.is(tok::comment) && S.size() >= 2 && S[0] == '/' && S[1] == '/') {
+        // It's a line comment;
+        // Ensure that we don't concatenate anything behind it.
+        Callbacks->setEmittedDirectiveOnThisLine();
+      }
     }
     Callbacks->setEmittedTokensOnThisLine();
 
     if (Tok.is(tok::eof)) break;
 
-    PrevPrevTok = PrevTok;
-    PrevTok = Tok;
     PP.Lex(Tok);
   }
 }
 
 typedef std::pair<const IdentifierInfo *, MacroInfo *> id_macro_pair;
 static int MacroIDCompare(const id_macro_pair *LHS, const id_macro_pair *RHS) {
   return LHS->first->getName().compare(RHS->first->getName());
 }
void clang::DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream *OS,
   }
 
   // Inform the preprocessor whether we want it to retain comments or not, due
   // to -C or -CC.
   PP.SetCommentRetentionState(Opts.ShowComments, Opts.ShowMacroComments);
 
   PrintPPOutputPPCallbacks *Callbacks = new PrintPPOutputPPCallbacks(
       PP, *OS, !Opts.ShowLineMarkers, Opts.ShowMacros,
-      Opts.ShowIncludeDirectives, Opts.UseLineDirectives);
+      Opts.ShowIncludeDirectives, Opts.UseLineDirectives,
+      Opts.NormalizeWhitespace);
 
   // Expand macros in pragmas with -fms-extensions.  The assumption is that
   // the majority of pragmas in such a file will be Microsoft pragmas.
   // Remember the handlers we will add so that we can remove them later.
   std::unique_ptr<UnknownPragmaHandler> MicrosoftExtHandler(
       new UnknownPragmaHandler(
           "#pragma", Callbacks,
           /*RequireTokenExpansion=*/PP.getLangOpts().MicrosoftExt));

clang/test/CXX/lex/lex.pptoken/p3-2a.cpp

 _Pragma("clang no_such_pragma (");
 // CHECK: import <foo  bar>;
 import <foo  bar>;
 
 #define HEADER <foo  bar>
 // CHECK: import <foo bar>;
 import HEADER;
 
-// CHECK: import <foo bar>;
+// CHECK: import <foo bar>
+// CHECK: ;
 import <
 foo
   bar
 >;
 
 // CHECK: import{{$}}
-// CHECK: {{^}}<foo bar>;
+// CHECK: {{^}}<foo bar>
+// CHECK: ;
 import
 <
 foo
   bar
 >;
 
 // CHECK: import{{$}}
 // CHECK: {{^}}<foo  bar>;
 import
 <foo  bar>;
 
 #define IMPORT import <foo  bar>
 // CHECK: import <foo bar>;
 IMPORT;

clang/test/Preprocessor/c99-6_10_3_4_p5.c

 #define str(x) # x 
             f(y+1) + f(f(z)) % t(t(g)(0) + t)(1); 
             g(x+(3,4)-w) | h 5) & m 
 (f)^m(m); 
 p() i[q()] = { q(1), r(2,3), r(4,), r(,5), r(,) }; 
 char c[2][6] = { str(hello), str() }; 
 
 // CHECK: f(2 * (y+1)) + f(2 * (f(2 * (z[0])))) % f(2 * (0)) + t(1);
-// CHECK: f(2 * (2 +(3,4)-0,1)) | f(2 * (~ 5)) & f(2 * (0,1))^m(0,1);
+// CHECK: f(2 * (2 +(3,4)-0,1)) | f(2 * (~ 5)) & f(2 * (0,1))
+// CHECK:    ^m(0,1);
 // CHECK: int i[] = { 1, 23, 4, 5, };
 // CHECK: char c[2][6] = { "hello", "" };
 

clang/test/Preprocessor/c99-6_10_3_4_p6.c

 fputs(str(strncmp("abc\0d" "abc", '\4') // this goes away 
           == 0) str(: @\n), s); 
 include xstr(INCFILE(2).h) 
 glue(HIGH, LOW); 
 xglue(HIGH, LOW) 
 
 
 // CHECK: printf("x" "1" "= %d, x" "2" "= s" x1, x2);
-// CHECK: fputs("strncmp(\"abc\\0d\" \"abc\", '\\4') == 0" ": @\n", s);
+// CHECK: fputs("strncmp(\"abc\\0d\" \"abc\", '\\4') == 0" 
+// CHECK:                 ": @\n", s);
 // CHECK: include "vers2.h"
 // CHECK: "hello";
 // CHECK: "hello" ", world"
 

clang/test/Preprocessor/comment_save.c

 // RUN: %clang_cc1 -E -C %s | FileCheck -strict-whitespace %s
+// RUN: %clang_cc1 -E -C -fnormalize-whitespace %s | FileCheck -strict-whitespace %s
 
 // foo
 // CHECK: // foo
 
 /* bar */
 // CHECK: /* bar */
 
 #if FOO

clang/test/Preprocessor/first-line-indent.c

        foo
 // RUN: %clang_cc1 -E %s | FileCheck -strict-whitespace %s
+// RUN: %clang_cc1 -E -fnormalize-whitespace %s | FileCheck -strict-whitespace %s --check-prefix=NORMCOL
+// RUN: %clang_cc1 -E -fnormalize-whitespace -P %s | FileCheck -strict-whitespace %s --check-prefix=NORMWS
        bar
 
 // CHECK: {{^       }}foo
 // CHECK: {{^       }}bar
 
+// NORMCOL: {{^}}foo
+// NORMCOL: {{^}}bar
+
+// NORMWS: {{^}}foo bar
+

clang/test/Preprocessor/hash_line.c

 // The 1 and # should not go on the same line.
 // RUN: %clang_cc1 -E %s | FileCheck --strict-whitespace %s
 // CHECK: {{^1$}}
 // CHECK-NEXT: {{^      #$}}
 // CHECK-NEXT: {{^2$}}
 // CHECK-NEXT: {{^           #$}}
+
+// RUN: %clang_cc1 -E -P -fnormalize-whitespace %s | FileCheck --strict-whitespace %s --check-prefix=NORMWS
+// NORMWS:  {{^}}1#2#{{$}}
+
 #define EMPTY
 #define IDENTITY(X) X
 1
 EMPTY #
 2
 IDENTITY() #

clang/test/Preprocessor/line-directive-output-normcol.c

+// RUN: %clang_cc1 -E -fnormalize-whitespace %s 2>&1 | FileCheck %s -strict-whitespace
+
+// CHECK:      # 6 "{{.*}}line-directive-output-normcol.c"
+// CHECK-NEXT: int x;
+// CHECK-NEXT: int y;
+int x;
+int y;
+// CHECK-NEXT: # 10 "{{.*}}line-directive-output-normcol.c"
+// CHECK-NEXT: int z;
+int z;

clang/test/Preprocessor/line-directive-output.c

 // RUN: %clang_cc1 -E %s 2>&1 | FileCheck %s -strict-whitespace
+// RUN: %clang_cc1 -E -fnormalize-whitespace %s 2>&1 | FileCheck %s -strict-whitespace
 // PR6101
 int a;
 // CHECK: # 1 "{{.*}}line-directive-output.c"
 
 // Check that we do not emit an enter marker for the main file.
 // CHECK-NOT: # 1 "{{.*}}line-directive-output.c" 1
 
 // CHECK: int a;

clang/test/Preprocessor/macro_space.c

 // RUN: %clang_cc1 -E %s | FileCheck --strict-whitespace %s
+// RUN: %clang_cc1 -E -P -fnormalize-whitespace %s | FileCheck --strict-whitespace %s --check-prefix=NORMWS
 
 #define FOO1()
 #define FOO2(x)x
 #define FOO3(x) x
 #define FOO4(x)x x
 #define FOO5(x) x x
 #define FOO6(x) [x]
 #define FOO7(x) [ x]
 #define FOO8(x) [x ]
 
 #define TEST(FOO,x) FOO <FOO()> < FOO()> <FOO ()> <FOO( )> <FOO() > <FOO()x> <FOO() x> < FOO()x>
 
 TEST(FOO1,)
 // CHECK: FOO1 <> < > <> <> < > <> < > < >
+// NORMWS: FOO1<><><><><><><><>
 
 TEST(FOO2,)
 // CHECK: FOO2 <> < > <> <> < > <> < > < >
+// NORMWS-SAME: FOO2<><><><><><><><>
 
 TEST(FOO3,)
 // CHECK: FOO3 <> < > <> <> < > <> < > < >
+// NORMWS-SAME: FOO3<><><><><><><><>
 
 TEST(FOO4,)
 // CHECK: FOO4 < > < > < > < > < > < > < > < >
+// NORMWS-SAME: FOO4<><><><><><><><>
 
 TEST(FOO5,)
 // CHECK: FOO5 < > < > < > < > < > < > < > < >
+// NORMWS-SAME: FOO5<><><><><><><><>
 
 TEST(FOO6,)
 // CHECK: FOO6 <[]> < []> <[]> <[]> <[] > <[]> <[] > < []>
+// NORMWS-SAME: FOO6<[]><[]><[]><[]><[]><[]><[]><[]>
 
 TEST(FOO7,)
 // CHECK: FOO7 <[ ]> < [ ]> <[ ]> <[ ]> <[ ] > <[ ]> <[ ] > < [ ]>
+// NORMWS-SAME: FOO7<[]><[]><[]><[]><[]><[]><[]><[]>
 
 TEST(FOO8,)
 // CHECK: FOO8 <[ ]> < [ ]> <[ ]> <[ ]> <[ ] > <[ ]> <[ ] > < [ ]>
+// NORMWS-SAME: FOO8<[]><[]><[]><[]><[]><[]><[]><[]>

clang/test/Preprocessor/normalize-whitespace.c

+// RUN: %clang_cc1 -E -fnormalize-whitespace %s 2>&1 | FileCheck %s --strict-whitespace --check-prefix=NORMCOL
+// RUN: %clang_cc1 -E -C -fnormalize-whitespace %s 2>&1 | FileCheck %s --strict-whitespace --check-prefix=NORMCCOL
+// RUN: %clang_cc1 -E -P -fnormalize-whitespace %s 2>&1 | FileCheck %s --strict-whitespace --check-prefix=NORMWS
+// RUN: %clang_cc1 -E -C -P -fnormalize-whitespace %s 2>&1 | FileCheck %s --strict-whitespace --check-prefix=NORMCWS
+
+#define NOT_OMP  omp  something
+#define HASH #
+
+  int  a;     /*  span-comment  */
+  int  b  ;   //  line-comment
+  _Pragma  (  "omp  barrier"  ) x //  more line-comments
+  #pragma  omp  nothing  //  another comment
+HASH  pragma  NOT_OMP
+  int  e;    // again a line
+  int  f  ;
+
+
+// NORMCOL:      {{^}}# 9 "{{.*}}normalize-whitespace.c"{{$}}
+// NORMCOL:      {{^}}int a;{{$}}
+// NORMCOL-NEXT: {{^}}int b;{{$}}
+// NORMCOL-NEXT: {{^}}#pragma omp barrier{{$}}
+// NORMCOL-NEXT: # 11 "{{.*}}normalize-whitespace.c"
+// NORMCOL-NEXT: {{^}}x{{$}}
+// NORMCOL-NEXT: {{^}}#pragma omp nothing{{$}}
+// NORMCOL-NEXT: {{^ }}#pragma omp something{{$}}
+// NORMCOL-NEXT: {{^}}int e;{{$}}
+// NORMCOL-NEXT: {{^}}int f;{{$}}
+
+// FIXME: Comments after pragmas disappear, even without -fnormalize-whitespace
+// NORMCCOL:      {{^}}# 9 "{{.*}}normalize-whitespace.c"{{$}}
+// NORMCCOL:      {{^}}int a;/*  span-comment  */{{$}}
+// NORMCCOL-NEXT: {{^}}int b;//  line-comment{{$}}
+// NORMCCOL-NEXT: {{^}}#pragma omp barrier{{$}}
+// NORMCCOL-NEXT: # 11 "{{.*}}normalize-whitespace.c"
+// NORMCCOL-NEXT: {{^}}x//  more line-comments{{$}}
+// NORMCCOL-NEXT: {{^}}#pragma omp nothing{{$}}
+// NORMCCOL-NEXT: {{^ }}#pragma omp something{{$}}
+// NORMCCOL-NEXT: {{^}}int e;// again a line{{$}}
+// NORMCCOL-NEXT: {{^}}int f;{{$}}
+
+// NORMWS:      {{^}}int a;int b;{{$}}
+// NORMWS-NEXT: {{^}}#pragma omp barrier{{$}}
+// NORMWS-NEXT: {{^}}x{{$}}
+// NORMWS-NEXT: {{^}}#pragma omp nothing{{$}}
+// NORMWS-NEXT: {{^ }}#pragma omp something int e;int f;{{$}}
+
+// FIXME: Comments after pragmas disappear, even without -fnormalize-whitespace
+// NORMCWS:      {{^}}int a;/*  span-comment  */int b;//  line-comment{{$}}
+// NORMCWS-NEXT: {{^}}#pragma omp barrier{{$}}
+// NORMCWS-NEXT: {{^}}x//  more line-comments{{$}}
+// NORMCWS-NEXT: {{^}}#pragma omp nothing{{$}}
+// NORMCWS-NEXT: {{^ }}#pragma omp something int e;// again a line{{$}}
+// NORMCWS-NEXT: {{^}}int f;
+

clang/test/Preprocessor/print_line_include.c

 // RUN: %clang_cc1 -E -P %s | FileCheck %s
 // CHECK: int x;
 // CHECK-NEXT: int x;
 
+// RUN: %clang_cc1 -E -P -fnormalize-whitespace %s | FileCheck %s --check-prefix=NORMWS --strict-whitespace
+// NORMWS: {{^}}int x;int x;{{$}}
+
 #include "print_line_include.h"
 #include "print_line_include.h"

clang/test/Preprocessor/stringize_space.c

 // RUN: %clang_cc1 -E %s | FileCheck --strict-whitespace %s
+// RUN: %clang_cc1 -E -P -fnormalize-whitespace %s | FileCheck --strict-whitespace %s --check-prefix=NORMWS
 
 #define A(b) -#b  ,  - #b  ,  -# b  ,  - # b
 A()
 
 // CHECK: {{^}}-"" , - "" , -"" , - ""{{$}}
-
+// NORMWS: {{^}}-"",-"",-"",-""
 
 #define t(x) #x
 t(a
 c)
 
 // CHECK: {{^}}"a c"{{$}}
+// NORMWS-SAME: "a c"
 
 #define str(x) #x
 #define f(x) str(-x)
 f(
     1)
 
 // CHECK: {{^}}"-1"
+// NORMWS-SAME: "-1"
 
 #define paste(a,b) str(a<b##ld)
 paste(hello1, wor)
 paste(hello2,
       wor)
 paste(hello3,
 wor)
 
 // CHECK: {{^}}"hello1<world"
 // CHECK: {{^}}"hello2<world"
 // CHECK: {{^}}"hello3<world"
+// NORMWS-SAME: {{^}}"hello1<world""hello2<world""hello3<world"{{$}}