[aarch64] Fix the problem of using a "//" as comment start.

[tubafranz]

Summary

Hello folks out there,
here is my first patch to llvm. Bon appetit.

Franesco

The AsmLexer has been implemented with the assumption that the
CommentString defined as a const char * in MCAsmInfo.h should be
defined as a single char. In AArch64 CommentString is defined as "//",
so that even "/" was defined as comment start.

Regression tests has been introduced in test/MC/AsmParser/AsmLexer/,
and some of the darwin regression tests has been adapted to the "##"
CommentString.

[jannau]

duplicates http://reviews.llvm.org/D4597

The changes to the darwin tests are actually wrong. A single '#' has to be recognized as comment for x86 darwin

include/llvm/MC/MCParser/AsmLexer.h

 
   const AsmToken peekTok(bool ShouldSkipSpace = true) override;
 
-  bool isAtStartOfComment(char Char);
+  bool isAtStartOfComment(const char * Char);
   bool isAtStatementSeparator(const char *Ptr);
 
   const MCAsmInfo &getMAI() const { return MAI; }

lib/MC/MCParser/AsmLexer.cpp

 StringRef AsmLexer::LexUntilEndOfStatement() {
   TokStart = CurPtr;
 
-  while (!isAtStartOfComment(*CurPtr) &&    // Start of line comment.
+  while (!isAtStartOfComment(CurPtr) &&    // Start of line comment.
          !isAtStatementSeparator(CurPtr) && // End of statement marker.
          *CurPtr != '\n' && *CurPtr != '\r' &&
          (*CurPtr != 0 || CurPtr != CurBuf.end())) {

   return Token;
 }
 
-bool AsmLexer::isAtStartOfComment(char Char) {
-  // FIXME: This won't work for multi-character comment indicators like "//".
-  return Char == *MAI.getCommentString();
+bool AsmLexer::isAtStartOfComment(const char * Char) {
+  return strncmp(Char, MAI.getCommentString(), strlen(MAI.getCommentString()))==0;
 }
 
 bool AsmLexer::isAtStatementSeparator(const char *Ptr) {

   // This always consumes at least one character.
   int CurChar = getNextChar();
 
-  if (isAtStartOfComment(CurChar)) {
+  if (isAtStartOfComment(TokStart)) {
     // If this comment starts with a '#', then return the Hash token and let
     // the assembler parser see if it can be parsed as a cpp line filename
     // comment. We do this only if we are at the start of a line.

test/MC/AsmParser/AsmLexer/aarch64-comment.s

+; RUN: echo "add  s0, s1,s2  //" | llvm-mc -as-lex -triple=aarch64 | FileCheck %s
+; CHECK: identifier: add ("add")
+; CHECK: identifier: s0 ("s0")
+; CHECK: Comma (",")
+; CHECK: identifier: s1 ("s1")
+; CHECK: Comma (",")
+; CHECK: identifier: s2 ("s2")
+; CHECK: EndOfStatement ("")

test/MC/AsmParser/AsmLexer/aarch64-not-a-comment.s

+; RUN: echo "add  s0, s1,s2  /" | llvm-mc -as-lex -triple=aarch64 | FileCheck %s
+; CHECK: identifier: add ("add")
+; CHECK: identifier: s0 ("s0")
+; CHECK: Comma (",")
+; CHECK: identifier: s1 ("s1")
+; CHECK: Comma (",")
+; CHECK: identifier: s2 ("s2")
+; CHECK: Slash ("/")
+; CHECK: EndOfStatement ("\n")

test/MC/AsmParser/macros-darwin.s

 // CHECK: .globl  "a,b,c"
 test8 a, b, c
 // CHECK: .globl  "%1,%2,%3"
-test8 %1, %2, %3 #a comment
+test8 %1, %2, %3 ##a comment
 // CHECK: .globl "x-y,z,1"
 test8 x - y, z, 1
 // CHECK: .globl  "1 2 3"

test/MC/MachO/tlv-reloc.s

 
 _foo:
    movq   _a@TLVP(%rip), %rdi
-   call *(%rdi) # returns &a in %rax
+   call *(%rdi) ## returns &a in %rax
    ret
 
 // CHECK: ('cputype', 16777223)

test/MC/MachO/x86_32-optimal_nop.s

 // RUN: llvm-mc -triple i386-apple-darwin9 %s -filetype=obj -o - | macho-dump --dump-section-data | FileCheck %s
 
 # 1 byte nop test
-        .align 4, 0 # start with 16 byte alignment filled with zeros
+        .align 4, 0 ## start with 16 byte alignment filled with zeros
         ret
         # nop
         # 0x90
         .align 1, 0x90
         ret
 # 2 byte nop test
-        .align 4, 0 # start with 16 byte alignment filled with zeros
+        .align 4, 0 ## start with 16 byte alignment filled with zeros
         ret
         ret
         # xchg %ax,%ax

         .align 2, 0x90
         ret
 # 3 byte nop test
-        .align 4, 0 # start with 16 byte alignment filled with zeros
+        .align 4, 0 ## start with 16 byte alignment filled with zeros
         ret
         # nopl (%[re]ax)
         # 0x0f, 0x1f, 0x00
         .align 2, 0x90
         ret
 # 4 byte nop test
-        .align 4, 0 # start with 16 byte alignment filled with zeros
+        .align 4, 0 ## start with 16 byte alignment filled with zeros
         ret
         ret
         ret

         .align 3, 0x90
         ret
 # 5 byte nop test
-        .align 4, 0 # start with 16 byte alignment filled with zeros
+        .align 4, 0 ## start with 16 byte alignment filled with zeros
         ret
         ret
         ret

         .align 3, 0x90
         ret
 # 6 byte nop test
-        .align 4, 0 # start with 16 byte alignment filled with zeros
+        .align 4, 0 ## start with 16 byte alignment filled with zeros
         ret
         ret
         # nopw 0(%[re]ax,%[re]ax,1)

         .align 3, 0x90
         ret
 # 7 byte nop test
-        .align 4, 0 # start with 16 byte alignment filled with zeros
+        .align 4, 0 ## start with 16 byte alignment filled with zeros
         ret
         # nopl 0L(%[re]ax)
         # 0x0f, 0x1f, 0x80, 0x00, 0x00, 0x00, 0x00
         .align 3, 0x90
         ret
 # 8 byte nop test
-        .align 4, 0 # start with 16 byte alignment filled with zeros
+        .align 4, 0 ## start with 16 byte alignment filled with zeros
         ret
         ret
         ret

         .align 3, 0x90
         ret
 # 9 byte nop test
-        .align 4, 0 # start with 16 byte alignment filled with zeros
+        .align 4, 0 ## start with 16 byte alignment filled with zeros
         ret
         ret
         ret

         .align 4, 0x90
         ret
 # 10 byte nop test
-        .align 4, 0 # start with 16 byte alignment filled with zeros
+        .align 4, 0 ## start with 16 byte alignment filled with zeros
         ret
         ret
         ret

         .align 4, 0x90
         ret
 # 11 byte nop test
-        .align 4, 0 # start with 16 byte alignment filled with zeros
+        .align 4, 0 ## start with 16 byte alignment filled with zeros
         ret
         ret
         ret

         .align 4, 0x90
         ret
 # 12 byte nop test
-        .align 4, 0 # start with 16 byte alignment filled with zeros
+        .align 4, 0 ## start with 16 byte alignment filled with zeros
         ret
         ret
         ret

         .align 4, 0x90
         ret
 # 13 byte nop test
-        .align 4, 0 # start with 16 byte alignment filled with zeros
+        .align 4, 0 ## start with 16 byte alignment filled with zeros
         ret
         ret
         ret

         .align 4, 0x90
         ret
 # 14 byte nop test
-        .align 4, 0 # start with 16 byte alignment filled with zeros
+        .align 4, 0 ## start with 16 byte alignment filled with zeros
         ret
         ret
         # nopl 0L(%[re]ax)

         .align 4, 0x90
         ret
 # 15 byte nop test
-        .align 4, 0 # start with 16 byte alignment filled with zeros
+        .align 4, 0 ## start with 16 byte alignment filled with zeros
         ret
         # nopl 0L(%[re]ax)
         # nopl 0L(%[re]ax,%[re]ax,1)