Asm preprocessor fix for unknown hash-lines

[andrew.zhogin]

Summary

clang/lib/Frontend/PrintPreprocessedOutput.cpp has a problem with unknown pragmas.
It inserts an additional empty line after each unrecognized pragma.
It means such a file:

# some comment 1
# some comment 2
# some comment 3

Will be preprocessed (clang -cc1 -E -x assembler-with-cpp) into:

# some comment 1

# some comment 2

# some comment 3

And it breaks debug info (generate wrong line numbers).

For sure, '#' is not right symbol for llvm assembly comments, but it is still a bug.

Here is patch to fix such behaviour.

[andrew.zhogin]

Updated to the current repository state.

lib/Frontend/PrintPreprocessedOutput.cpp

private:
   SrcMgr::CharacteristicKind FileType;
   SmallString<512> CurFilename;
   bool Initialized;
   bool DisableLineMarkers;
   bool DumpDefines;
   bool DumpIncludeDirectives;
   bool UseLineDirectives;
   bool IsFirstFileEntered;
+  bool NewLinesInTokenHandled;
 public:
   PrintPPOutputPPCallbacks(Preprocessor &pp, raw_ostream &os, bool lineMarkers,
                            bool defines, bool DumpIncludeDirectives,
                            bool UseLineDirectives)
       : PP(pp), SM(PP.getSourceManager()), ConcatInfo(PP), OS(os),
         DisableLineMarkers(lineMarkers), DumpDefines(defines),
         DumpIncludeDirectives(DumpIncludeDirectives),
         UseLineDirectives(UseLineDirectives) {
     CurLine = 0;
     CurFilename += "<uninit>";
     EmittedTokensOnThisLine = false;
     EmittedDirectiveOnThisLine = false;
     FileType = SrcMgr::C_User;
     Initialized = false;
     IsFirstFileEntered = false;
+    NewLinesInTokenHandled = false;
   }
 
   void setEmittedTokensOnThisLine() { EmittedTokensOnThisLine = true; }
   bool hasEmittedTokensOnThisLine() const { return EmittedTokensOnThisLine; }
 
   void setEmittedDirectiveOnThisLine() { EmittedDirectiveOnThisLine = true; }
   bool hasEmittedDirectiveOnThisLine() const {
     return EmittedDirectiveOnThisLine;
public:
 
   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; }
-  void HandleNewlinesInToken(const char *TokStr, unsigned Len);
+  void HandleNewlinesInToken(const char *TokStr, unsigned Len, bool IsSp);
 
   /// MacroDefined - This hook is called whenever a macro definition is seen.
   void MacroDefined(const Token &MacroNameTok,
                     const MacroDirective *MD) override;
 
   /// MacroUndefined - This hook is called whenever a macro #undef is seen.
   void MacroUndefined(const Token &MacroNameTok,
                       const MacroDefinition &MD,

 
 /// 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) {
   // If this line is "close enough" to the original line, just print newlines,
   // otherwise print a #line directive.
+  bool WasNewLines = NewLinesInTokenHandled;
+  NewLinesInTokenHandled = false;
   if (LineNo-CurLine <= 8) {
     if (LineNo-CurLine == 1)
       OS << '\n';
     else if (LineNo == CurLine)
-      return false;    // Spelling line moved, but expansion line didn't.
+      return WasNewLines;    // 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);
   } else {
bool PrintPPOutputPPCallbacks::HandleFirstTokOnLine(Token &Tok) {
   // Otherwise, indent the appropriate number of spaces.
   for (; ColNo > 1; --ColNo)
     OS << ' ';
 
   return true;
 }
 
 void PrintPPOutputPPCallbacks::HandleNewlinesInToken(const char *TokStr,
-                                                     unsigned Len) {
+                                                     unsigned Len, bool IsSp) {
   unsigned NumNewlines = 0;
   for (; Len; --Len, ++TokStr) {
     if (*TokStr != '\n' &&
         *TokStr != '\r')
       continue;
 
     ++NumNewlines;
 
     // If we have \n\r or \r\n, skip both and count as one line.
     if (Len != 1 &&
         (TokStr[1] == '\n' || TokStr[1] == '\r') &&
         TokStr[0] != TokStr[1]) {
       ++TokStr;
       --Len;
     }
   }
 
   if (NumNewlines == 0) return;
 
   CurLine += NumNewlines;
+  if (IsSp) NewLinesInTokenHandled = true;
 }
 
 
 namespace {
 struct UnknownPragmaHandler : public PragmaHandler {
   const char *Prefix;
   PrintPPOutputPPCallbacks *Callbacks;
 
while (1) {
     } else if (Tok.getLength() < 256) {
       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);
+        Callbacks->HandleNewlinesInToken(TokPtr, Len, false);
+      if (Tok.getKind() == tok::eod)
+        Callbacks->HandleNewlinesInToken(TokPtr, Len, true);
     } else {
       std::string S = PP.getSpelling(Tok);
       OS.write(&S[0], 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[0], S.size());
+        Callbacks->HandleNewlinesInToken(&S[0], S.size(), false);
+      if (Tok.getKind() == tok::eod)
+        Callbacks->HandleNewlinesInToken(&S[0], S.size(), true);
     }
     Callbacks->setEmittedTokensOnThisLine();
 
     if (Tok.is(tok::eof)) break;
 
     PrevPrevTok = PrevTok;
     PrevTok = Tok;
     PP.Lex(Tok);

test/Misc/asm_hash_comments.s

+// RUN: %clang_cc1 -E -x assembler-with-cpp %s | FileCheck --strict-whitespace %s
+// CHECK: # some comment 1
+// CHECK-NEXT: # some comment 2
+// CHECK-NEXT: # some comment 3
+
+# some comment 1
+# some comment 2
+# some comment 3
+
+