[MC] Prevent out of order HashDirective lexing in AsmLexer.

[niravd]

Summary

To lex hash directives we peek ahead to find component tokens, create a
unified token, and unlex the peeked tokens so the parser does not need
to parse the tokens then. Make sure we do not to lex another hash
directive during peek operation.

This fixes PR28921.

[rnk]

include/llvm/MC/MCParser/AsmLexer.h

30–35

We should give all these scalars default member initializers and delete the assignments in the ctor.

lib/MC/MCParser/AsmLexer.cpp

496

Do you think this would be improved with our SaveAndRestore<bool> RAII helper? Same for the rest of the saved local copies.

[niravd]

cei
Resolve comments

[rnk]

lgtm

include/llvm/MC/MCParser/AsmLexer.h

30–35

No, I mean C++11 default member initializers, so we don't have to repeat all the scalar members in the ctor:

class AsmLexer ... {
  ...
  const char *CurPtr = nullptr;
  bool IsAtStartOfLine = true;
  bool IsPeeking = false;
  ...

include/llvm/MC/MCParser/AsmLexer.h

 namespace llvm {
 class MemoryBuffer;
 class MCAsmInfo;
 
 /// AsmLexer - Lexer class for assembly files.
 class AsmLexer : public MCAsmLexer {
   const MCAsmInfo &MAI;
 
   const char *CurPtr;
   StringRef CurBuf;
   bool IsAtStartOfLine;
   bool IsAtStartOfStatement;
   bool IsParsingMSInlineAsm;
-
+  bool IsPeeking;
   void operator=(const AsmLexer&) = delete;
   AsmLexer(const AsmLexer&) = delete;
 
 protected:
   /// LexToken - Read the next token and return its code.
   AsmToken LexToken() override;
 
 public:

lib/MC/MCParser/AsmLexer.cpp

 
 using namespace llvm;
 
 AsmLexer::AsmLexer(const MCAsmInfo &MAI) : MAI(MAI) {
   CurPtr = nullptr;
   IsAtStartOfLine = true;
   IsAtStartOfStatement = true;
   IsParsingMSInlineAsm = false;
+  IsPeeking = false;
   AllowAtInIdentifier = !StringRef(MAI.getCommentString()).startswith("@");
 }
 
 AsmLexer::~AsmLexer() {
 }
 
 void AsmLexer::setBuffer(StringRef Buf, const char *ptr) {
   CurBuf = Buf;

 
 size_t AsmLexer::peekTokens(MutableArrayRef<AsmToken> Buf,
                             bool ShouldSkipSpace) {
   const char *SavedTokStart = TokStart;
   const char *SavedCurPtr = CurPtr;
   bool SavedAtStartOfLine = IsAtStartOfLine;
   bool SavedAtStartOfStatement = IsAtStartOfStatement;
   bool SavedSkipSpace = SkipSpace;
+  bool SavedIsPeeking = IsPeeking;
+  IsPeeking = true;
 
   std::string SavedErr = getErr();
   SMLoc SavedErrLoc = getErrLoc();
 
   SkipSpace = ShouldSkipSpace;
 
   size_t ReadCount;
   for (ReadCount = 0; ReadCount < Buf.size(); ++ReadCount) {
     AsmToken Token = LexToken();
 
     Buf[ReadCount] = Token;
 
     if (Token.is(AsmToken::Eof))
       break;
   }
 
   SetError(SavedErrLoc, SavedErr);
 
   SkipSpace = SavedSkipSpace;
   IsAtStartOfLine = SavedAtStartOfLine;
   IsAtStartOfStatement = SavedAtStartOfStatement;
   CurPtr = SavedCurPtr;
   TokStart = SavedTokStart;
-
+  IsPeeking = SavedIsPeeking;
   return ReadCount;
 }
 
 bool AsmLexer::isAtStartOfComment(const char *Ptr) {
   const char *CommentString = MAI.getCommentString();
 
   if (CommentString[1] == '\0')
     return CommentString[0] == Ptr[0];
return strncmp(Ptr, MAI.getSeparatorString(),
                  strlen(MAI.getSeparatorString())) == 0;
 }
 
 AsmToken AsmLexer::LexToken() {
   TokStart = CurPtr;
   // This always consumes at least one character.
   int CurChar = getNextChar();
 
-  if (CurChar == '#' && IsAtStartOfStatement) {
+  if (!IsPeeking && CurChar == '#' && IsAtStartOfStatement) {
     // If this starts with a '#', this may be a cpp
     // hash directive and otherwise a line comment.
     AsmToken TokenBuf[2];
     MutableArrayRef<AsmToken> Buf(TokenBuf, 2);
     size_t num = peekTokens(Buf, true);
     // There cannot be a space preceeding this
     if (IsAtStartOfLine && num == 2 && TokenBuf[0].is(AsmToken::Integer) &&
         TokenBuf[1].is(AsmToken::String)) {

test/MC/AsmParser/pr28921.s

+// RUN: llvm-mc -triple i386-unknown-unknown %s
+
+# 1 "kernel.S"
+# 1 "<built-in>" 1
+# 1 "kernel.S" 2
+##
+# 10 "kernel.S"
+##