[AsmParser][SystemZ][z/OS] Reject "Dot" as current PC on z/OS

[anirudhp]

Summary

• Currently, the "." (Dot) character, when not identifying an Identifier or a Constant, refers to the current PC (Program Counter)
• However, in z/OS, for the HLASM dialect, it strictly accepts only the "*" as the current PC (Support for this will be put up in a follow-up patch)
• The changes in this patch allow individual platforms to choose whether they would like to use the "." (Dot) character as a marker for the current PC or not.
• It is achieved by introducing a new field in MCAsmInfo.h called DotIsPC (similar to DollarIsPC)

[MaskRay]

Seems fine

[anirudhp]

• Rebase on latest master

[Kai]

llvm/include/llvm/MC/MCAsmInfo.h

122

Comment is in contradiction with code below.

[anirudhp]

• Fixed misleading comment.

[abhina.sreeskantharajan]

LGTM

llvm/include/llvm/MC/MCAsmInfo.h

protected:
   /// Every possible instruction length is a multiple of this value.  Factored
   /// out in .debug_frame and .debug_line.  Defaults to 1.
   unsigned MinInstAlignment = 1;
 
   /// The '$' token, when not referencing an identifier or constant, refers to
   /// the current PC.  Defaults to false.
   bool DollarIsPC = false;
 
+  /// Allow '.' token, when not referencing an identifier or constant, to refer
+  /// to the current PC. Defaults to true.
+  bool DotIsPC = true;
+
   /// This string, if specified, is used to separate instructions from each
   /// other when on the same line.  Defaults to ';'
   const char *SeparatorString;
 
   /// This indicates the comment string used by the assembler.  Defaults to
   /// "#"
   StringRef CommentString;
 
public:
   /// Returns the maximum possible encoded instruction size in bytes. If \p STI
   /// is null, this should be the maximum size for any subtarget.
   virtual unsigned getMaxInstLength(const MCSubtargetInfo *STI = nullptr) const {
     return MaxInstLength;
   }
 
   unsigned getMinInstAlignment() const { return MinInstAlignment; }
   bool getDollarIsPC() const { return DollarIsPC; }
+  bool getDotIsPC() const { return DotIsPC; }
   const char *getSeparatorString() const { return SeparatorString; }
 
   /// This indicates the column (zero-based) at which asm comments should be
   /// printed.
   unsigned getCommentColumn() const { return 40; }
 
   StringRef getCommentString() const { return CommentString; }
   bool getRestrictCommentStringToStartOfStatement() const {

llvm/lib/MC/MCParser/AsmParser.cpp

case AsmToken::Real: {
     APFloat RealVal(APFloat::IEEEdouble(), getTok().getString());
     uint64_t IntVal = RealVal.bitcastToAPInt().getZExtValue();
     Res = MCConstantExpr::create(IntVal, getContext());
     EndLoc = Lexer.getTok().getEndLoc();
     Lex(); // Eat token.
     return false;
   }
   case AsmToken::Dot: {
+    if (!MAI.getDotIsPC())
+      return TokError("cannot use . as current PC");
+
     // This is a '.' reference, which references the current PC.  Emit a
     // temporary label to the streamer and refer to it.
     MCSymbol *Sym = Ctx.createTempSymbol();
     Out.emitLabel(Sym);
     Res = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext());
     EndLoc = Lexer.getTok().getEndLoc();
     Lex(); // Eat identifier.
     return false;

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZMCAsmInfo.cpp

SystemZMCAsmInfo::SystemZMCAsmInfo(const Triple &TT) {
   MaxInstLength = 6;
 
   CommentString = AssemblerDialect == AD_HLASM ? "*" : "#";
   RestrictCommentStringToStartOfStatement = (AssemblerDialect == AD_HLASM);
   AllowAdditionalComments = (AssemblerDialect == AD_ATT);
   AllowAtAtStartOfIdentifier = (AssemblerDialect == AD_HLASM);
   AllowDollarAtStartOfIdentifier = (AssemblerDialect == AD_HLASM);
   AllowHashAtStartOfIdentifier = (AssemblerDialect == AD_HLASM);
+  DotIsPC = (AssemblerDialect == AD_ATT);
 
   ZeroDirective = "\t.space\t";
   Data64bitsDirective = "\t.quad\t";
   UsesELFSectionDirectiveForBSS = true;
   SupportsDebugInformation = true;
   ExceptionsType = ExceptionHandling::DwarfCFI;
 }

llvm/unittests/MC/SystemZ/SystemZAsmLexerTest.cpp

void setAllowAtAtStartOfIdentifier(bool Value) {
     AllowAtAtStartOfIdentifier = Value;
   }
   void setAllowDollarAtStartOfIdentifier(bool Value) {
     AllowDollarAtStartOfIdentifier = Value;
   }
   void setAllowHashAtStartOfIdentifier(bool Value) {
     AllowHashAtStartOfIdentifier = Value;
   }
+  void setAllowDotIsPC(bool Value) { DotIsPC = Value; }
 };
 
 // Setup a testing class that the GTest framework can call.
 class SystemZAsmLexerTest : public ::testing::Test {
 protected:
   static void SetUpTestCase() {
     LLVMInitializeSystemZTargetInfo();
     LLVMInitializeSystemZTargetMC();
+    LLVMInitializeSystemZAsmParser();
   }
 
   std::unique_ptr<MCRegisterInfo> MRI;
   std::unique_ptr<MockedUpMCAsmInfo> MUPMAI;
   std::unique_ptr<const MCInstrInfo> MII;
   std::unique_ptr<MCStreamer> Str;
   std::unique_ptr<MCAsmParser> Parser;
   std::unique_ptr<MCContext> Ctx;
+  std::unique_ptr<MCSubtargetInfo> STI;
+  std::unique_ptr<MCTargetAsmParser> TargetAsmParser;
 
   SourceMgr SrcMgr;
   std::string TripleName;
   llvm::Triple Triple;
   const Target *TheTarget;
 
   const MCTargetOptions MCOptions;
   MCObjectFileInfo MOFI;
 
   SystemZAsmLexerTest() {
     // We will use the SystemZ triple, because of missing
     // Object File and Streamer support for the z/OS target.
     TripleName = "s390x-ibm-linux";
     Triple = llvm::Triple(TripleName);
 
     std::string Error;
     TheTarget = TargetRegistry::lookupTarget(TripleName, Error);
     EXPECT_NE(TheTarget, nullptr);
 
     MRI.reset(TheTarget->createMCRegInfo(TripleName));
     EXPECT_NE(MRI, nullptr);
 
+    MII.reset(TheTarget->createMCInstrInfo());
+    EXPECT_NE(MII, nullptr);
+
+    STI.reset(TheTarget->createMCSubtargetInfo(TripleName, "z10", ""));
+    EXPECT_NE(STI, nullptr);
+
     std::unique_ptr<MCAsmInfo> MAI;
     MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
     EXPECT_NE(MAI, nullptr);
 
     // Now we cast to our mocked up version of MCAsmInfo.
     MUPMAI.reset(static_cast<MockedUpMCAsmInfo *>(MAI.release()));
     // MUPMAI should "hold" MAI.
     EXPECT_NE(MUPMAI, nullptr);
     // After releasing, MAI should now be null.
     EXPECT_EQ(MAI, nullptr);
   }
 
   void setupCallToAsmParser(StringRef AsmStr) {
     std::unique_ptr<MemoryBuffer> Buffer(MemoryBuffer::getMemBuffer(AsmStr));
     SrcMgr.AddNewSourceBuffer(std::move(Buffer), SMLoc());
     EXPECT_EQ(Buffer, nullptr);
 
     Ctx.reset(
         new MCContext(MUPMAI.get(), MRI.get(), &MOFI, &SrcMgr, &MCOptions));
     MOFI.InitMCObjectFileInfo(Triple, false, *Ctx, false);
 
     Str.reset(TheTarget->createNullStreamer(*Ctx));
 
     Parser.reset(createMCAsmParser(SrcMgr, *Ctx, *Str, *MUPMAI));
+
+    TargetAsmParser.reset(
+        TheTarget->createMCAsmParser(*STI, *Parser, *MII, MCOptions));
+    Parser->setTargetParser(*TargetAsmParser);
   }
 
   void lexAndCheckTokens(StringRef AsmStr,
                          SmallVector<AsmToken::TokenKind> ExpectedTokens) {
     // Get reference to AsmLexer.
     MCAsmLexer &Lexer = Parser->getLexer();
     // Loop through all expected tokens checking one by one.
     for (size_t I = 0; I < ExpectedTokens.size(); ++I) {
TEST_F(SystemZAsmLexerTest, CheckAcceptHashAtStartOfIdentifier4) {
   // only strings starting with the CommentString attribute are
   // lexed as possible comments.
   // Hence, "##a$b$c" is lexed as an Identifier because the
   // AllowHashAtStartOfIdentifier attribute is set to true.
   SmallVector<AsmToken::TokenKind> ExpectedTokens(
       {AsmToken::Identifier, AsmToken::EndOfStatement, AsmToken::Eof});
   lexAndCheckTokens(AsmStr, ExpectedTokens);
 }
+
+TEST_F(SystemZAsmLexerTest, CheckRejectDotAsCurrentPC) {
+  StringRef AsmStr = ".-4";
+
+  // Setup.
+  MUPMAI->setAllowDotIsPC(false);
+  setupCallToAsmParser(AsmStr);
+
+  // 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);
+}
 } // end anonymous namespace