[llvm-branch-commits] [clang] 4a450da - Revert "[Preprocessor] Implement -fminimize-whitespace."
Tom Stellard via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Mon Aug 2 15:22:57 PDT 2021
Author: Tom Stellard
Date: 2021-08-02T15:22:19-07:00
New Revision: 4a450da71b3fbef613376cd7c8066942785af937
URL: https://github.com/llvm/llvm-project/commit/4a450da71b3fbef613376cd7c8066942785af937
DIFF: https://github.com/llvm/llvm-project/commit/4a450da71b3fbef613376cd7c8066942785af937.diff
LOG: Revert "[Preprocessor] Implement -fminimize-whitespace."
This reverts commit ae6b40000238e5faaaa319ffcfc713a15e459be8.
llvm.org/PR51300
Added:
Modified:
clang/docs/ClangCommandLineReference.rst
clang/include/clang/Basic/DiagnosticDriverKinds.td
clang/include/clang/Driver/Options.td
clang/include/clang/Driver/Types.h
clang/include/clang/Frontend/PreprocessorOutputOptions.h
clang/lib/Driver/ToolChains/Clang.cpp
clang/lib/Driver/Types.cpp
clang/lib/Frontend/PrintPreprocessedOutput.cpp
clang/lib/Lex/Preprocessor.cpp
clang/test/Preprocessor/comment_save.c
clang/test/Preprocessor/first-line-indent.c
clang/test/Preprocessor/hash_line.c
clang/test/Preprocessor/line-directive-output.c
clang/test/Preprocessor/macro_space.c
clang/test/Preprocessor/print_line_include.c
clang/test/Preprocessor/stringize_space.c
Removed:
clang/test/Preprocessor/line-directive-output-mincol.c
clang/test/Preprocessor/minimize-whitespace-messages.c
clang/test/Preprocessor/minimize-whitespace.c
################################################################################
diff --git a/clang/docs/ClangCommandLineReference.rst b/clang/docs/ClangCommandLineReference.rst
index 35a3fdd382b41..74557c5bd5814 100644
--- a/clang/docs/ClangCommandLineReference.rst
+++ b/clang/docs/ClangCommandLineReference.rst
@@ -2475,16 +2475,6 @@ Turn on loop unroller
Use #line in preprocessed output
-.. option:: -fminimize-whitespace, -fno-minimize-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 normalize whitespace such that two files with only formatting
-changes are equal.
-
-Only valid with -E on C-like inputs and 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
diff --git a/clang/include/clang/Basic/DiagnosticDriverKinds.td b/clang/include/clang/Basic/DiagnosticDriverKinds.td
index 3b4daa59f66b5..fc3704303a956 100644
--- a/clang/include/clang/Basic/DiagnosticDriverKinds.td
+++ b/clang/include/clang/Basic/DiagnosticDriverKinds.td
@@ -129,8 +129,6 @@ def err_drv_invalid_Xopenmp_target_with_args : Error<
"invalid -Xopenmp-target argument: '%0', options requiring arguments are unsupported">;
def err_drv_argument_only_allowed_with : Error<
"invalid argument '%0' only allowed with '%1'">;
-def err_drv_minws_unsupported_input_type : Error<
- "'-fminimize-whitespace' invalid for input of type %0">;
def err_drv_amdgpu_ieee_without_no_honor_nans : Error<
"invalid argument '-mno-amdgpu-ieee' only allowed with relaxed NaN handling">;
def err_drv_argument_not_allowed_with : Error<
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
index 5a9fd078390e1..ab1a5487d9c03 100644
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -1799,9 +1799,6 @@ def frewrite_map_file_EQ : Joined<["-"], "frewrite-map-file=">,
defm use_line_directives : BoolFOption<"use-line-directives",
PreprocessorOutputOpts<"UseLineDirectives">, DefaultFalse,
PosFlag<SetTrue, [CC1Option], "Use #line in preprocessed output">, NegFlag<SetFalse>>;
-defm minimize_whitespace : BoolFOption<"minimize-whitespace",
- PreprocessorOutputOpts<"MinimizeWhitespace">, DefaultFalse,
- PosFlag<SetTrue, [CC1Option], "Minimize whitespace when emitting preprocessor output">, NegFlag<SetFalse>>;
def ffreestanding : Flag<["-"], "ffreestanding">, Group<f_Group>, Flags<[CC1Option]>,
HelpText<"Assert that the compilation takes place in a freestanding environment">,
diff --git a/clang/include/clang/Driver/Types.h b/clang/include/clang/Driver/Types.h
index c9d63551090cf..6a1f57416ae5b 100644
--- a/clang/include/clang/Driver/Types.h
+++ b/clang/include/clang/Driver/Types.h
@@ -66,14 +66,6 @@ namespace types {
/// isAcceptedByClang - Can clang handle this input type.
bool isAcceptedByClang(ID Id);
- /// isDerivedFromC - Is the input derived from C.
- ///
- /// That is, does the lexer follow the rules of
- /// TokenConcatenation::AvoidConcat. If this is the case, the preprocessor may
- /// add and remove whitespace between tokens. Used to determine whether the
- /// input can be processed by -fminimize-whitespace.
- bool isDerivedFromC(ID Id);
-
/// isCXX - Is this a "C++" input (C++ and Obj-C++ sources and headers).
bool isCXX(ID Id);
diff --git a/clang/include/clang/Frontend/PreprocessorOutputOptions.h b/clang/include/clang/Frontend/PreprocessorOutputOptions.h
index 257538ee06065..72e5ad1137fb7 100644
--- a/clang/include/clang/Frontend/PreprocessorOutputOptions.h
+++ b/clang/include/clang/Frontend/PreprocessorOutputOptions.h
@@ -24,7 +24,6 @@ class PreprocessorOutputOptions {
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 MinimizeWhitespace : 1; ///< Ignore whitespace from input.
public:
PreprocessorOutputOptions() {
@@ -37,7 +36,6 @@ class PreprocessorOutputOptions {
ShowIncludeDirectives = 0;
RewriteIncludes = 0;
RewriteImports = 0;
- MinimizeWhitespace = 0;
}
};
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
index a4b53a640ab5c..1870bd81789c5 100644
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -52,9 +52,8 @@ using namespace clang;
using namespace llvm::opt;
static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) {
- if (Arg *A = Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC,
- options::OPT_fminimize_whitespace,
- options::OPT_fno_minimize_whitespace)) {
+ if (Arg *A =
+ Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC)) {
if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) &&
!Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) {
D.Diag(clang::diag::err_drv_argument_only_allowed_with)
@@ -6068,16 +6067,6 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
options::OPT_fno_use_line_directives, false))
CmdArgs.push_back("-fuse-line-directives");
- // -fno-minimize-whitespace is default.
- if (Args.hasFlag(options::OPT_fminimize_whitespace,
- options::OPT_fno_minimize_whitespace, false)) {
- types::ID InputType = Inputs[0].getType();
- if (!isDerivedFromC(InputType))
- D.Diag(diag::err_drv_minws_unsupported_input_type)
- << types::getTypeName(InputType);
- CmdArgs.push_back("-fminimize-whitespace");
- }
-
// -fms-extensions=0 is default.
if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,
IsWindowsMSVC))
diff --git a/clang/lib/Driver/Types.cpp b/clang/lib/Driver/Types.cpp
index 3cb2d6e8f6fd7..b7ccdf23cbaaf 100644
--- a/clang/lib/Driver/Types.cpp
+++ b/clang/lib/Driver/Types.cpp
@@ -147,45 +147,6 @@ bool types::isAcceptedByClang(ID Id) {
}
}
-bool types::isDerivedFromC(ID Id) {
- switch (Id) {
- default:
- return false;
-
- case TY_PP_C:
- case TY_C:
- case TY_CL:
- case TY_CLCXX:
- case TY_PP_CUDA:
- case TY_CUDA:
- case TY_CUDA_DEVICE:
- case TY_PP_HIP:
- case TY_HIP:
- case TY_HIP_DEVICE:
- case TY_PP_ObjC:
- case TY_PP_ObjC_Alias:
- case TY_ObjC:
- case TY_PP_CXX:
- case TY_CXX:
- case TY_PP_ObjCXX:
- case TY_PP_ObjCXX_Alias:
- case TY_ObjCXX:
- case TY_RenderScript:
- case TY_PP_CHeader:
- case TY_CHeader:
- case TY_CLHeader:
- case TY_PP_ObjCHeader:
- case TY_ObjCHeader:
- case TY_PP_CXXHeader:
- case TY_CXXHeader:
- case TY_PP_ObjCXXHeader:
- case TY_ObjCXXHeader:
- case TY_CXXModule:
- case TY_PP_CXXModule:
- return true;
- }
-}
-
bool types::isObjC(ID Id) {
switch (Id) {
default:
diff --git a/clang/lib/Frontend/PrintPreprocessedOutput.cpp b/clang/lib/Frontend/PrintPreprocessedOutput.cpp
index b7259569595d6..24ea1ccba207f 100644
--- a/clang/lib/Frontend/PrintPreprocessedOutput.cpp
+++ b/clang/lib/Frontend/PrintPreprocessedOutput.cpp
@@ -95,20 +95,14 @@ class PrintPPOutputPPCallbacks : public PPCallbacks {
bool DumpIncludeDirectives;
bool UseLineDirectives;
bool IsFirstFileEntered;
- bool MinimizeWhitespace;
-
- Token PrevTok;
- Token PrevPrevTok;
-
public:
PrintPPOutputPPCallbacks(Preprocessor &pp, raw_ostream &os, bool lineMarkers,
bool defines, bool DumpIncludeDirectives,
- bool UseLineDirectives, bool MinimizeWhitespace)
+ bool UseLineDirectives)
: PP(pp), SM(PP.getSourceManager()), ConcatInfo(PP), OS(os),
DisableLineMarkers(lineMarkers), DumpDefines(defines),
DumpIncludeDirectives(DumpIncludeDirectives),
- UseLineDirectives(UseLineDirectives),
- MinimizeWhitespace(MinimizeWhitespace) {
+ UseLineDirectives(UseLineDirectives) {
CurLine = 0;
CurFilename += "<uninit>";
EmittedTokensOnThisLine = false;
@@ -116,13 +110,8 @@ class PrintPPOutputPPCallbacks : public PPCallbacks {
FileType = SrcMgr::C_User;
Initialized = false;
IsFirstFileEntered = false;
-
- PrevTok.startToken();
- PrevPrevTok.startToken();
}
- bool isMinimizeWhitespace() const { return MinimizeWhitespace; }
-
void setEmittedTokensOnThisLine() { EmittedTokensOnThisLine = true; }
bool hasEmittedTokensOnThisLine() const { return EmittedTokensOnThisLine; }
@@ -131,12 +120,7 @@ class PrintPPOutputPPCallbacks : public PPCallbacks {
return EmittedDirectiveOnThisLine;
}
- /// 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 that represent the input, use
- /// MoveToLine(/*...*/, /*RequireStartOfLine=*/true).
- void startNewLineIfNeeded();
+ bool startNewLineIfNeeded(bool ShouldUpdateCurrentLine = true);
void FileChanged(SourceLocation Loc, FileChangeReason Reason,
SrcMgr::CharacteristicKind FileType,
@@ -164,45 +148,18 @@ class PrintPPOutputPPCallbacks : public PPCallbacks {
void PragmaAssumeNonNullBegin(SourceLocation Loc) override;
void PragmaAssumeNonNullEnd(SourceLocation Loc) override;
- /// 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(const Token &Tok, bool RequireSpace,
- bool RequireSameLine);
+ bool HandleFirstTokOnLine(Token &Tok);
/// Move to the line of the provided source location. This will
- /// 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 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) {
+ /// return true if the output stream required adjustment or if
+ /// the requested location is on the first line.
+ bool MoveToLine(SourceLocation Loc) {
PresumedLoc PLoc = SM.getPresumedLoc(Loc);
if (PLoc.isInvalid())
return false;
- return MoveToLine(PLoc.getLine(), RequireStartOfLine);
+ return MoveToLine(PLoc.getLine()) || (PLoc.getLine() == 1);
}
- bool MoveToLine(unsigned LineNo, bool RequireStartOfLine);
+ bool MoveToLine(unsigned LineNo);
bool AvoidConcat(const Token &PrevPrevTok, const Token &PrevTok,
const Token &Tok) {
@@ -230,7 +187,7 @@ class PrintPPOutputPPCallbacks : public PPCallbacks {
void PrintPPOutputPPCallbacks::WriteLineInfo(unsigned LineNo,
const char *Extra,
unsigned ExtraLen) {
- startNewLineIfNeeded();
+ startNewLineIfNeeded(/*ShouldUpdateCurrentLine=*/false);
// Emit #line directives or GNU line markers depending on what mode we're in.
if (UseLineDirectives) {
@@ -257,57 +214,43 @@ void PrintPPOutputPPCallbacks::WriteLineInfo(unsigned LineNo,
/// 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 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;
- }
-
+bool PrintPPOutputPPCallbacks::MoveToLine(unsigned LineNo) {
// If this line is "close enough" to the original line, just print newlines,
// otherwise print a #line directive.
- if (CurLine == LineNo) {
- // Nothing to do if we are already on the correct line.
- } else if (!StartedNewLine && (!MinimizeWhitespace || !DisableLineMarkers) &&
- LineNo - CurLine == 1) {
- // Printing a single line has priority over printing a #line directive, even
- // when minimizing whitespace which otherwise would print #line directives
- // for every single line.
- OS << '\n';
- StartedNewLine = true;
- } else if (!MinimizeWhitespace && LineNo - CurLine <= 8) {
- const char *NewLines = "\n\n\n\n\n\n\n\n";
- OS.write(NewLines, LineNo - CurLine);
- StartedNewLine = true;
+ 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);
+ }
} else if (!DisableLineMarkers) {
// Emit a #line or line marker.
WriteLineInfo(LineNo, nullptr, 0);
- StartedNewLine = true;
- }
-
- if (StartedNewLine) {
- EmittedTokensOnThisLine = false;
- EmittedDirectiveOnThisLine = false;
+ } else {
+ // Okay, we're in -P mode, which turns off line markers. However, we still
+ // need to emit a newline between tokens on
diff erent lines.
+ startNewLineIfNeeded(/*ShouldUpdateCurrentLine=*/false);
}
CurLine = LineNo;
- return StartedNewLine;
+ return true;
}
-void PrintPPOutputPPCallbacks::startNewLineIfNeeded() {
+bool
+PrintPPOutputPPCallbacks::startNewLineIfNeeded(bool ShouldUpdateCurrentLine) {
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
@@ -330,7 +273,7 @@ void PrintPPOutputPPCallbacks::FileChanged(SourceLocation Loc,
if (Reason == PPCallbacks::EnterFile) {
SourceLocation IncludeLoc = UserLoc.getIncludeLoc();
if (IncludeLoc.isValid())
- MoveToLine(IncludeLoc, /*RequireStartOfLine=*/false);
+ MoveToLine(IncludeLoc);
} 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
@@ -347,8 +290,7 @@ void PrintPPOutputPPCallbacks::FileChanged(SourceLocation Loc,
FileType = NewFileType;
if (DisableLineMarkers) {
- if (!MinimizeWhitespace)
- startNewLineIfNeeded();
+ startNewLineIfNeeded(/*ShouldUpdateCurrentLine=*/false);
return;
}
@@ -394,13 +336,15 @@ void PrintPPOutputPPCallbacks::InclusionDirective(
// In -dI mode, dump #include directives prior to dumping their content or
// interpretation.
if (DumpIncludeDirectives) {
- MoveToLine(HashLoc, /*RequireStartOfLine=*/true);
+ startNewLineIfNeeded();
+ MoveToLine(HashLoc);
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.
@@ -409,13 +353,17 @@ void PrintPPOutputPPCallbacks::InclusionDirective(
case tok::pp_include:
case tok::pp_import:
case tok::pp_include_next:
- MoveToLine(HashLoc, /*RequireStartOfLine=*/true);
+ startNewLineIfNeeded();
+ MoveToLine(HashLoc);
OS << "#pragma clang module import " << Imported->getFullModuleName(true)
<< " /* clang -E: implicit import for "
<< "#" << PP.getSpelling(IncludeTok) << " "
<< (IsAngled ? '<' : '"') << FileName << (IsAngled ? '>' : '"')
<< " */";
- setEmittedDirectiveOnThisLine();
+ // Since we want a newline after the pragma, but not a #<line>, start a
+ // new line immediately.
+ EmittedTokensOnThisLine = true;
+ startNewLineIfNeeded();
break;
case tok::pp___include_macros:
@@ -450,11 +398,11 @@ void PrintPPOutputPPCallbacks::EndModule(const Module *M) {
/// Ident - Handle #ident directives when read by the preprocessor.
///
void PrintPPOutputPPCallbacks::Ident(SourceLocation Loc, StringRef S) {
- MoveToLine(Loc, /*RequireStartOfLine=*/true);
+ MoveToLine(Loc);
OS.write("#ident ", strlen("#ident "));
OS.write(S.begin(), S.size());
- setEmittedTokensOnThisLine();
+ EmittedTokensOnThisLine = true;
}
/// MacroDefined - This hook is called whenever a macro definition is seen.
@@ -466,7 +414,7 @@ void PrintPPOutputPPCallbacks::MacroDefined(const Token &MacroNameTok,
// Ignore __FILE__ etc.
MI->isBuiltinMacro()) return;
- MoveToLine(MI->getDefinitionLoc(), /*RequireStartOfLine=*/true);
+ MoveToLine(MI->getDefinitionLoc());
PrintMacroDefinition(*MacroNameTok.getIdentifierInfo(), *MI, PP, OS);
setEmittedDirectiveOnThisLine();
}
@@ -477,7 +425,7 @@ void PrintPPOutputPPCallbacks::MacroUndefined(const Token &MacroNameTok,
// Only print out macro definitions in -dD mode.
if (!DumpDefines) return;
- MoveToLine(MacroNameTok.getLocation(), /*RequireStartOfLine=*/true);
+ MoveToLine(MacroNameTok.getLocation());
OS << "#undef " << MacroNameTok.getIdentifierInfo()->getName();
setEmittedDirectiveOnThisLine();
}
@@ -498,7 +446,8 @@ void PrintPPOutputPPCallbacks::PragmaMessage(SourceLocation Loc,
StringRef Namespace,
PragmaMessageKind Kind,
StringRef Str) {
- MoveToLine(Loc, /*RequireStartOfLine=*/true);
+ startNewLineIfNeeded();
+ MoveToLine(Loc);
OS << "#pragma ";
if (!Namespace.empty())
OS << Namespace << ' ';
@@ -523,7 +472,8 @@ void PrintPPOutputPPCallbacks::PragmaMessage(SourceLocation Loc,
void PrintPPOutputPPCallbacks::PragmaDebug(SourceLocation Loc,
StringRef DebugType) {
- MoveToLine(Loc, /*RequireStartOfLine=*/true);
+ startNewLineIfNeeded();
+ MoveToLine(Loc);
OS << "#pragma clang __debug ";
OS << DebugType;
@@ -533,14 +483,16 @@ void PrintPPOutputPPCallbacks::PragmaDebug(SourceLocation Loc,
void PrintPPOutputPPCallbacks::
PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace) {
- MoveToLine(Loc, /*RequireStartOfLine=*/true);
+ startNewLineIfNeeded();
+ MoveToLine(Loc);
OS << "#pragma " << Namespace << " diagnostic push";
setEmittedDirectiveOnThisLine();
}
void PrintPPOutputPPCallbacks::
PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace) {
- MoveToLine(Loc, /*RequireStartOfLine=*/true);
+ startNewLineIfNeeded();
+ MoveToLine(Loc);
OS << "#pragma " << Namespace << " diagnostic pop";
setEmittedDirectiveOnThisLine();
}
@@ -549,7 +501,8 @@ void PrintPPOutputPPCallbacks::PragmaDiagnostic(SourceLocation Loc,
StringRef Namespace,
diag::Severity Map,
StringRef Str) {
- MoveToLine(Loc, /*RequireStartOfLine=*/true);
+ startNewLineIfNeeded();
+ MoveToLine(Loc);
OS << "#pragma " << Namespace << " diagnostic ";
switch (Map) {
case diag::Severity::Remark:
@@ -575,7 +528,8 @@ void PrintPPOutputPPCallbacks::PragmaDiagnostic(SourceLocation Loc,
void PrintPPOutputPPCallbacks::PragmaWarning(SourceLocation Loc,
StringRef WarningSpec,
ArrayRef<int> Ids) {
- MoveToLine(Loc, /*RequireStartOfLine=*/true);
+ startNewLineIfNeeded();
+ MoveToLine(Loc);
OS << "#pragma warning(" << WarningSpec << ':';
for (ArrayRef<int>::iterator I = Ids.begin(), E = Ids.end(); I != E; ++I)
OS << ' ' << *I;
@@ -585,7 +539,8 @@ void PrintPPOutputPPCallbacks::PragmaWarning(SourceLocation Loc,
void PrintPPOutputPPCallbacks::PragmaWarningPush(SourceLocation Loc,
int Level) {
- MoveToLine(Loc, /*RequireStartOfLine=*/true);
+ startNewLineIfNeeded();
+ MoveToLine(Loc);
OS << "#pragma warning(push";
if (Level >= 0)
OS << ", " << Level;
@@ -594,14 +549,16 @@ void PrintPPOutputPPCallbacks::PragmaWarningPush(SourceLocation Loc,
}
void PrintPPOutputPPCallbacks::PragmaWarningPop(SourceLocation Loc) {
- MoveToLine(Loc, /*RequireStartOfLine=*/true);
+ startNewLineIfNeeded();
+ MoveToLine(Loc);
OS << "#pragma warning(pop)";
setEmittedDirectiveOnThisLine();
}
void PrintPPOutputPPCallbacks::PragmaExecCharsetPush(SourceLocation Loc,
StringRef Str) {
- MoveToLine(Loc, /*RequireStartOfLine=*/true);
+ startNewLineIfNeeded();
+ MoveToLine(Loc);
OS << "#pragma character_execution_set(push";
if (!Str.empty())
OS << ", " << Str;
@@ -610,80 +567,64 @@ void PrintPPOutputPPCallbacks::PragmaExecCharsetPush(SourceLocation Loc,
}
void PrintPPOutputPPCallbacks::PragmaExecCharsetPop(SourceLocation Loc) {
- MoveToLine(Loc, /*RequireStartOfLine=*/true);
+ startNewLineIfNeeded();
+ MoveToLine(Loc);
OS << "#pragma character_execution_set(pop)";
setEmittedDirectiveOnThisLine();
}
void PrintPPOutputPPCallbacks::
PragmaAssumeNonNullBegin(SourceLocation Loc) {
- MoveToLine(Loc, /*RequireStartOfLine=*/true);
+ startNewLineIfNeeded();
+ MoveToLine(Loc);
OS << "#pragma clang assume_nonnull begin";
setEmittedDirectiveOnThisLine();
}
void PrintPPOutputPPCallbacks::
PragmaAssumeNonNullEnd(SourceLocation Loc) {
- MoveToLine(Loc, /*RequireStartOfLine=*/true);
+ startNewLineIfNeeded();
+ MoveToLine(Loc);
OS << "#pragma clang assume_nonnull end";
setEmittedDirectiveOnThisLine();
}
-void PrintPPOutputPPCallbacks::HandleWhitespaceBeforeTok(const Token &Tok,
- bool RequireSpace,
- bool RequireSameLine) {
- // These tokens are not expanded 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;
+/// 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;
+
+ // 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.
+ 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 << ' ';
- if (!RequireSameLine && MoveToLine(Tok, /*RequireStartOfLine=*/false)) {
- if (MinimizeWhitespace) {
- // 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.
- 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 caller requires it
- // - The input had whitespace between them and we are not in
- // whitespace-minimization mode
- // - The whitespace is necessary to keep the tokens apart and there is not
- // already a newline between them
- if (RequireSpace || (!MinimizeWhitespace && Tok.hasLeadingSpace()) ||
- ((EmittedTokensOnThisLine || EmittedTokensOnThisLine) &&
- AvoidConcat(PrevPrevTok, PrevTok, Tok)))
- OS << ' ';
- }
+ // Otherwise, indent the appropriate number of spaces.
+ for (; ColNo > 1; --ColNo)
+ OS << ' ';
- PrevPrevTok = PrevTok;
- PrevTok = Tok;
+ return true;
}
void PrintPPOutputPPCallbacks::HandleNewlinesInToken(const char *TokStr,
@@ -727,9 +668,9 @@ struct UnknownPragmaHandler : public PragmaHandler {
Token &PragmaTok) override {
// Figure out what line we went to and insert the appropriate number of
// newline characters.
- Callbacks->MoveToLine(PragmaTok.getLocation(), /*RequireStartOfLine=*/true);
+ Callbacks->startNewLineIfNeeded();
+ Callbacks->MoveToLine(PragmaTok.getLocation());
Callbacks->OS.write(Prefix, strlen(Prefix));
- Callbacks->setEmittedTokensOnThisLine();
if (ShouldExpandTokens) {
// The first token does not have expanded macros. Expand them, if
@@ -741,16 +682,21 @@ struct UnknownPragmaHandler : public PragmaHandler {
/*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)) {
- Callbacks->HandleWhitespaceBeforeTok(PragmaTok, /*RequireSpace=*/IsFirst,
- /*RequireSameLine=*/true);
- IsFirst = false;
+ if (PragmaTok.hasLeadingSpace() ||
+ Callbacks->AvoidConcat(PrevPrevToken, PrevToken, PragmaTok))
+ Callbacks->OS << ' ';
std::string TokSpell = PP.getSpelling(PragmaTok);
Callbacks->OS.write(&TokSpell[0], TokSpell.size());
- Callbacks->setEmittedTokensOnThisLine();
+
+ PrevPrevToken = PrevToken;
+ PrevToken = PragmaTok;
if (ShouldExpandTokens)
PP.Lex(PragmaTok);
@@ -769,41 +715,44 @@ static void PrintPreprocessedTokens(Preprocessor &PP, Token &Tok,
bool DropComments = PP.getLangOpts().TraditionalCPP &&
!PP.getCommentRetentionState();
- bool IsStartOfLine = false;
char Buffer[256];
+ Token PrevPrevTok, PrevTok;
+ PrevPrevTok.startToken();
+ PrevTok.startToken();
while (1) {
- // Two lines joined with line continuation ('\' as last character on the
- // line) must be emitted as one line even though Tok.getLine() returns two
- //
diff erent values. In this situation Tok.isAtStartOfLine() is false even
- // though it may be the first token on the lexical line. When
- // dropping/skipping a token that is at the start of a line, propagate the
- // start-of-line-ness to the next token to not append it to the previous
- // line.
- IsStartOfLine = IsStartOfLine || Tok.isAtStartOfLine();
-
- Callbacks->HandleWhitespaceBeforeTok(Tok, /*RequireSpace=*/false,
- /*RequireSameLine=*/!IsStartOfLine);
+ 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 << ' ';
+ }
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.
- PP.Lex(Tok);
- continue;
+ 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);
- // FIXME: The token on the next line after #include should have
- // Tok.isAtStartOfLine() set.
- IsStartOfLine = true;
continue;
} else if (Tok.is(tok::annot_module_include)) {
// PrintPPOutputPPCallbacks::InclusionDirective handles producing
// appropriate output here. Ignore this token entirely.
PP.Lex(Tok);
- IsStartOfLine = true;
continue;
} else if (Tok.is(tok::annot_module_begin)) {
// FIXME: We retrieve this token after the FileChanged callback, and
@@ -815,13 +764,11 @@ static void PrintPreprocessedTokens(Preprocessor &PP, Token &Tok,
Callbacks->BeginModule(
reinterpret_cast<Module *>(Tok.getAnnotationValue()));
PP.Lex(Tok);
- IsStartOfLine = true;
continue;
} else if (Tok.is(tok::annot_module_end)) {
Callbacks->EndModule(
reinterpret_cast<Module *>(Tok.getAnnotationValue()));
PP.Lex(Tok);
- IsStartOfLine = true;
continue;
} else if (Tok.is(tok::annot_header_unit)) {
// This is a header-name that has been (effectively) converted into a
@@ -849,17 +796,8 @@ static void PrintPreprocessedTokens(Preprocessor &PP, Token &Tok,
// Tokens that can contain embedded newlines need to adjust our current
// line number.
- // FIXME: The token may end with a newline in which case
- // setEmittedDirectiveOnThisLine/setEmittedTokensOnThisLine afterwards is
- // wrong.
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());
@@ -868,17 +806,13 @@ static void PrintPreprocessedTokens(Preprocessor &PP, Token &Tok,
// 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();
- IsStartOfLine = false;
if (Tok.is(tok::eof)) break;
+ PrevPrevTok = PrevTok;
+ PrevTok = Tok;
PP.Lex(Tok);
}
}
@@ -936,8 +870,7 @@ void clang::DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream *OS,
PrintPPOutputPPCallbacks *Callbacks = new PrintPPOutputPPCallbacks(
PP, *OS, !Opts.ShowLineMarkers, Opts.ShowMacros,
- Opts.ShowIncludeDirectives, Opts.UseLineDirectives,
- Opts.MinimizeWhitespace);
+ Opts.ShowIncludeDirectives, Opts.UseLineDirectives);
// Expand macros in pragmas with -fms-extensions. The assumption is that
// the majority of pragmas in such a file will be Microsoft pragmas.
diff --git a/clang/lib/Lex/Preprocessor.cpp b/clang/lib/Lex/Preprocessor.cpp
index 32ea8791d29a8..e376fff904329 100644
--- a/clang/lib/Lex/Preprocessor.cpp
+++ b/clang/lib/Lex/Preprocessor.cpp
@@ -716,12 +716,6 @@ IdentifierInfo *Preprocessor::LookUpIdentifierInfo(Token &Identifier) const {
}
// Update the token info (identifier info and appropriate token kind).
- // FIXME: the raw_identifier may contain leading whitespace which is removed
- // from the cleaned identifier token. The SourceLocation should be updated to
- // refer to the non-whitespace character. For instance, the text "\\\nB" (a
- // line continuation before 'B') is parsed as a single tok::raw_identifier and
- // is cleaned to tok::identifier "B". After cleaning the token's length is
- // still 3 and the SourceLocation refers to the location of the backslash.
Identifier.setIdentifierInfo(II);
if (getLangOpts().MSVCCompat && II->isCPlusPlusOperatorKeyword() &&
getSourceManager().isInSystemHeader(Identifier.getLocation()))
diff --git a/clang/test/Preprocessor/comment_save.c b/clang/test/Preprocessor/comment_save.c
index 84eaed0a2272f..1100ea29bba9c 100644
--- a/clang/test/Preprocessor/comment_save.c
+++ b/clang/test/Preprocessor/comment_save.c
@@ -1,5 +1,4 @@
// RUN: %clang_cc1 -E -C %s | FileCheck -strict-whitespace %s
-// RUN: %clang_cc1 -E -C -fminimize-whitespace %s | FileCheck -strict-whitespace %s
// foo
// CHECK: // foo
diff --git a/clang/test/Preprocessor/first-line-indent.c b/clang/test/Preprocessor/first-line-indent.c
index 9aafa9ce43521..d220d57a28201 100644
--- a/clang/test/Preprocessor/first-line-indent.c
+++ b/clang/test/Preprocessor/first-line-indent.c
@@ -1,14 +1,7 @@
foo
// RUN: %clang_cc1 -E %s | FileCheck -strict-whitespace %s
-// RUN: %clang_cc1 -E -fminimize-whitespace %s | FileCheck -strict-whitespace %s --check-prefix=MINCOL
-// RUN: %clang_cc1 -E -fminimize-whitespace -P %s | FileCheck -strict-whitespace %s --check-prefix=MINWS
bar
// CHECK: {{^ }}foo
// CHECK: {{^ }}bar
-// MINCOL: {{^}}foo
-// MINCOL: {{^}}bar
-
-// MINWS: {{^}}foo bar
-
diff --git a/clang/test/Preprocessor/hash_line.c b/clang/test/Preprocessor/hash_line.c
index 1b5064fe549dc..c4de9f04044e2 100644
--- a/clang/test/Preprocessor/hash_line.c
+++ b/clang/test/Preprocessor/hash_line.c
@@ -4,10 +4,6 @@
// CHECK-NEXT: {{^ #$}}
// CHECK-NEXT: {{^2$}}
// CHECK-NEXT: {{^ #$}}
-
-// RUN: %clang_cc1 -E -P -fminimize-whitespace %s | FileCheck --strict-whitespace %s --check-prefix=MINWS
-// MINWS: {{^}}1#2#{{$}}
-
#define EMPTY
#define IDENTITY(X) X
1
diff --git a/clang/test/Preprocessor/line-directive-output-mincol.c b/clang/test/Preprocessor/line-directive-output-mincol.c
deleted file mode 100644
index 0f2466ebee971..0000000000000
--- a/clang/test/Preprocessor/line-directive-output-mincol.c
+++ /dev/null
@@ -1,11 +0,0 @@
-// RUN: %clang_cc1 -E -fminimize-whitespace %s 2>&1 | FileCheck %s -strict-whitespace
-
-// CHECK: # 6 "{{.*}}line-directive-output-mincol.c"
-// CHECK-NEXT: int x;
-// CHECK-NEXT: int y;
-int x;
-int y;
-// CHECK-NEXT: # 10 "{{.*}}line-directive-output-mincol.c"
-// CHECK-NEXT: int z;
-int z;
-
diff --git a/clang/test/Preprocessor/line-directive-output.c b/clang/test/Preprocessor/line-directive-output.c
index 5e3dec155cad4..caeb88dd855cc 100644
--- a/clang/test/Preprocessor/line-directive-output.c
+++ b/clang/test/Preprocessor/line-directive-output.c
@@ -1,5 +1,4 @@
// RUN: %clang_cc1 -E %s 2>&1 | FileCheck %s -strict-whitespace
-// RUN: %clang_cc1 -E -fminimize-whitespace %s 2>&1 | FileCheck %s -strict-whitespace
// PR6101
int a;
// CHECK: # 1 "{{.*}}line-directive-output.c"
diff --git a/clang/test/Preprocessor/macro_space.c b/clang/test/Preprocessor/macro_space.c
index 0734bca9ea59a..13e531fff1511 100644
--- a/clang/test/Preprocessor/macro_space.c
+++ b/clang/test/Preprocessor/macro_space.c
@@ -1,5 +1,4 @@
// RUN: %clang_cc1 -E %s | FileCheck --strict-whitespace %s
-// RUN: %clang_cc1 -E -P -fminimize-whitespace %s | FileCheck --strict-whitespace %s --check-prefix=MINWS
#define FOO1()
#define FOO2(x)x
@@ -14,32 +13,24 @@
TEST(FOO1,)
// CHECK: FOO1 <> < > <> <> < > <> < > < >
-// MINWS: FOO1<><><><><><><><>
TEST(FOO2,)
// CHECK: FOO2 <> < > <> <> < > <> < > < >
-// MINWS-SAME: FOO2<><><><><><><><>
TEST(FOO3,)
// CHECK: FOO3 <> < > <> <> < > <> < > < >
-// MINWS-SAME: FOO3<><><><><><><><>
TEST(FOO4,)
// CHECK: FOO4 < > < > < > < > < > < > < > < >
-// MINWS-SAME: FOO4<><><><><><><><>
TEST(FOO5,)
// CHECK: FOO5 < > < > < > < > < > < > < > < >
-// MINWS-SAME: FOO5<><><><><><><><>
TEST(FOO6,)
// CHECK: FOO6 <[]> < []> <[]> <[]> <[] > <[]> <[] > < []>
-// MINWS-SAME: FOO6<[]><[]><[]><[]><[]><[]><[]><[]>
TEST(FOO7,)
// CHECK: FOO7 <[ ]> < [ ]> <[ ]> <[ ]> <[ ] > <[ ]> <[ ] > < [ ]>
-// MINWS-SAME: FOO7<[]><[]><[]><[]><[]><[]><[]><[]>
TEST(FOO8,)
// CHECK: FOO8 <[ ]> < [ ]> <[ ]> <[ ]> <[ ] > <[ ]> <[ ] > < [ ]>
-// MINWS-SAME: FOO8<[]><[]><[]><[]><[]><[]><[]><[]>
diff --git a/clang/test/Preprocessor/minimize-whitespace-messages.c b/clang/test/Preprocessor/minimize-whitespace-messages.c
deleted file mode 100644
index a78ddb471fb7c..0000000000000
--- a/clang/test/Preprocessor/minimize-whitespace-messages.c
+++ /dev/null
@@ -1,8 +0,0 @@
-// RUN: not %clang -c -fminimize-whitespace %s 2>&1 | FileCheck %s --check-prefix=ON
-// ON: error: invalid argument '-fminimize-whitespace' only allowed with '-E'
-
-// RUN: not %clang -c -fno-minimize-whitespace %s 2>&1 | FileCheck %s --check-prefix=OFF
-// OFF: error: invalid argument '-fno-minimize-whitespace' only allowed with '-E'
-
-// RUN: not %clang -E -fminimize-whitespace -x assembler-with-cpp %s 2>&1 | FileCheck %s --check-prefix=ASM
-// ASM: error: '-fminimize-whitespace' invalid for input of type assembler-with-cpp
diff --git a/clang/test/Preprocessor/minimize-whitespace.c b/clang/test/Preprocessor/minimize-whitespace.c
deleted file mode 100644
index 3608e318dc135..0000000000000
--- a/clang/test/Preprocessor/minimize-whitespace.c
+++ /dev/null
@@ -1,55 +0,0 @@
-// RUN: %clang_cc1 -fminimize-whitespace -E %s 2>&1 | FileCheck %s --strict-whitespace --check-prefix=MINCOL
-// RUN: %clang_cc1 -fminimize-whitespace -E -C %s 2>&1 | FileCheck %s --strict-whitespace --check-prefix=MINCCOL
-// RUN: %clang_cc1 -fminimize-whitespace -E -P %s 2>&1 | FileCheck %s --strict-whitespace --check-prefix=MINWS
-// RUN: %clang_cc1 -fminimize-whitespace -E -C -P %s 2>&1 | FileCheck %s --strict-whitespace --check-prefix=MINCWS
-
-#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 ;
-
-
-// MINCOL: {{^}}# 9 "{{.*}}minimize-whitespace.c"{{$}}
-// MINCOL: {{^}}int a;{{$}}
-// MINCOL-NEXT: {{^}}int b;{{$}}
-// MINCOL-NEXT: {{^}}#pragma omp barrier{{$}}
-// MINCOL-NEXT: # 11 "{{.*}}minimize-whitespace.c"
-// MINCOL-NEXT: {{^}}x{{$}}
-// MINCOL-NEXT: {{^}}#pragma omp nothing{{$}}
-// MINCOL-NEXT: {{^ }}#pragma omp something{{$}}
-// MINCOL-NEXT: {{^}}int e;{{$}}
-// MINCOL-NEXT: {{^}}int f;{{$}}
-
-// FIXME: Comments after pragmas disappear, even without -fminimize-whitespace
-// MINCCOL: {{^}}# 9 "{{.*}}minimize-whitespace.c"{{$}}
-// MINCCOL: {{^}}int a;/* span-comment */{{$}}
-// MINCCOL-NEXT: {{^}}int b;// line-comment{{$}}
-// MINCCOL-NEXT: {{^}}#pragma omp barrier{{$}}
-// MINCCOL-NEXT: # 11 "{{.*}}minimize-whitespace.c"
-// MINCCOL-NEXT: {{^}}x// more line-comments{{$}}
-// MINCCOL-NEXT: {{^}}#pragma omp nothing{{$}}
-// MINCCOL-NEXT: {{^ }}#pragma omp something{{$}}
-// MINCCOL-NEXT: {{^}}int e;// again a line{{$}}
-// MINCCOL-NEXT: {{^}}int f;{{$}}
-
-// MINWS: {{^}}int a;int b;{{$}}
-// MINWS-NEXT: {{^}}#pragma omp barrier{{$}}
-// MINWS-NEXT: {{^}}x{{$}}
-// MINWS-NEXT: {{^}}#pragma omp nothing{{$}}
-// MINWS-NEXT: {{^ }}#pragma omp something int e;int f;{{$}}
-
-// FIXME: Comments after pragmas disappear, even without -fminimize-whitespace
-// MINCWS: {{^}}int a;/* span-comment */int b;// line-comment{{$}}
-// MINCWS-NEXT: {{^}}#pragma omp barrier{{$}}
-// MINCWS-NEXT: {{^}}x// more line-comments{{$}}
-// MINCWS-NEXT: {{^}}#pragma omp nothing{{$}}
-// MINCWS-NEXT: {{^ }}#pragma omp something int e;// again a line{{$}}
-// MINCWS-NEXT: {{^}}int f;
-
diff --git a/clang/test/Preprocessor/print_line_include.c b/clang/test/Preprocessor/print_line_include.c
index 4810fbca99b1e..d65873cb73668 100644
--- a/clang/test/Preprocessor/print_line_include.c
+++ b/clang/test/Preprocessor/print_line_include.c
@@ -2,8 +2,5 @@
// CHECK: int x;
// CHECK-NEXT: int x;
-// RUN: %clang_cc1 -E -P -fminimize-whitespace %s | FileCheck %s --check-prefix=MINWS --strict-whitespace
-// MINWS: {{^}}int x;int x;{{$}}
-
#include "print_line_include.h"
#include "print_line_include.h"
diff --git a/clang/test/Preprocessor/stringize_space.c b/clang/test/Preprocessor/stringize_space.c
index 43276264eb4e7..cbc7386cd09b3 100644
--- a/clang/test/Preprocessor/stringize_space.c
+++ b/clang/test/Preprocessor/stringize_space.c
@@ -1,18 +1,16 @@
// RUN: %clang_cc1 -E %s | FileCheck --strict-whitespace %s
-// RUN: %clang_cc1 -E -P -fminimize-whitespace %s | FileCheck --strict-whitespace %s --check-prefix=MINWS
#define A(b) -#b , - #b , -# b , - # b
A()
// CHECK: {{^}}-"" , - "" , -"" , - ""{{$}}
-// MINWS: {{^}}-"",-"",-"",-""
+
#define t(x) #x
t(a
c)
// CHECK: {{^}}"a c"{{$}}
-// MINWS-SAME: "a c"
#define str(x) #x
#define f(x) str(-x)
@@ -20,7 +18,6 @@ f(
1)
// CHECK: {{^}}"-1"
-// MINWS-SAME: "-1"
#define paste(a,b) str(a<b##ld)
paste(hello1, wor)
@@ -32,4 +29,3 @@ wor)
// CHECK: {{^}}"hello1<world"
// CHECK: {{^}}"hello2<world"
// CHECK: {{^}}"hello3<world"
-// MINWS-SAME: {{^}}"hello1<world""hello2<world""hello3<world"{{$}}
More information about the llvm-branch-commits
mailing list