[AsmParser][SystemZ][z/OS] Reject character and string literals for HLASM

[anirudhp]

Summary

• As per the HLASM support we are providing, i.e. support only for the first parameter of the inline asm block, only pertaining to Z machine instructions defined in LLVM, character literals and string literals are not supported (see Figure 4 - https://www-01.ibm.com/servers/resourcelink/svc00100.nsf/pages/zOSV2R3sc264940/$file/asmr1023.pdf for more information)
• This patch explicitly rejects the usage of char literals and string literals (for example "abc 'a'") when the relevant field is set
• This is achieved by introducing a field called LexHLASMStrings in MCAsmLexer similar to LexMasmStrings

[abhina.sreeskantharajan]

LGTM

[Kai]

LGTM.

llvm/include/llvm/MC/MCParser/MCAsmLexer.h

protected: // Can only create subclasses.
   bool IsAtStartOfStatement = true;
   bool LexMasmHexFloats = false;
   bool LexMasmIntegers = false;
   bool LexMasmStrings = false;
   bool LexMotorolaIntegers = false;
   bool UseMasmDefaultRadix = false;
   unsigned DefaultRadix = 10;
   bool LexHLASMIntegers = false;
+  bool LexHLASMStrings = false;
   AsmCommentConsumer *CommentConsumer = nullptr;
 
   MCAsmLexer();
 
   virtual AsmToken LexToken() = 0;
 
   void SetError(SMLoc errLoc, const std::string &err) {
     ErrLoc = errLoc;
public:
   void setLexMasmStrings(bool V) { LexMasmStrings = V; }
 
   /// Set whether to lex Motorola-style integer literals, such as $deadbeef or
   /// %01010110.
   void setLexMotorolaIntegers(bool V) { LexMotorolaIntegers = V; }
 
   /// Set whether to lex HLASM-flavour integers. For now this is only [0-9]*
   void setLexHLASMIntegers(bool V) { LexHLASMIntegers = V; }
+
+  /// Set whether to "lex" HLASM-flavour character and string literals. For now,
+  /// setting this option to true, will disable lexing for character and string
+  /// literals.
+  void setLexHLASMStrings(bool V) { LexHLASMStrings = V; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCPARSER_MCASMLEXER_H

llvm/lib/MC/MCParser/AsmLexer.cpp

AsmToken AsmLexer::LexDigit() {
 
   return intToken(Result, Value);
 }
 
 /// LexSingleQuote: Integer: 'b'
 AsmToken AsmLexer::LexSingleQuote() {
   int CurChar = getNextChar();
 
+  if (LexHLASMStrings)
+    return ReturnError(TokStart, "invalid usage of character literals");
+
   if (LexMasmStrings) {
     while (CurChar != EOF) {
       if (CurChar != '\'') {
         CurChar = getNextChar();
       } else if (peekNextChar() == '\'') {
         // In MASM single-quote strings, doubled single-quotes mean an escaped
         // single quote, so should be lexed in.
         getNextChar();
if (Res.startswith("\'\\")) {
     Value = TokStart[1];
 
   return AsmToken(AsmToken::Integer, Res, Value);
 }
 
 /// LexQuote: String: "..."
 AsmToken AsmLexer::LexQuote() {
   int CurChar = getNextChar();
+  if (LexHLASMStrings)
+    return ReturnError(TokStart, "invalid usage of string literals");
+
   if (LexMasmStrings) {
     while (CurChar != EOF) {
       if (CurChar != '"') {
         CurChar = getNextChar();
       } else if (peekNextChar() == '"') {
         // In MASM double-quoted strings, doubled double-quotes mean an escaped
         // double quote, so should be lexed in.
         getNextChar();

llvm/unittests/MC/SystemZ/SystemZAsmLexerTest.cpp

TEST_F(SystemZAsmLexerTest, CheckRejectStarAsCurrentPC) {
   // Lex initially to get the string.
   Parser->getLexer().Lex();
 
   const MCExpr *Expr;
   bool ParsePrimaryExpr = Parser->parseExpression(Expr);
   EXPECT_EQ(ParsePrimaryExpr, true);
   EXPECT_EQ(Parser->hasPendingError(), true);
 }
+
+TEST_F(SystemZAsmLexerTest, CheckRejectCharLiterals) {
+  StringRef AsmStr = "abc 'd'";
+
+  // Setup.
+  setupCallToAsmParser(AsmStr);
+  Parser->getLexer().setLexHLASMStrings(true);
+
+  // Lex initially to get the string.
+  Parser->getLexer().Lex();
+
+  SmallVector<AsmToken::TokenKind> ExpectedTokens(
+      {AsmToken::Identifier, AsmToken::Error, AsmToken::Error,
+       AsmToken::EndOfStatement, AsmToken::Eof});
+  lexAndCheckTokens(AsmStr, ExpectedTokens);
+}
+
+TEST_F(SystemZAsmLexerTest, CheckRejectStringLiterals) {
+  StringRef AsmStr = "abc \"ef\"";
+
+  // Setup.
+  setupCallToAsmParser(AsmStr);
+  Parser->getLexer().setLexHLASMStrings(true);
+
+  // Lex initially to get the string.
+  Parser->getLexer().Lex();
+
+  SmallVector<AsmToken::TokenKind> ExpectedTokens(
+      {AsmToken::Identifier, AsmToken::Error, AsmToken::Identifier,
+       AsmToken::Error, AsmToken::EndOfStatement, AsmToken::Eof});
+  lexAndCheckTokens(AsmStr, ExpectedTokens);
+}
 } // end anonymous namespace