[AsmParser][SystemZ][z/OS] Implement HLASM location counter syntax ("*") for Z PC-relative instructions.

[anirudhp]

Summary

• This patch attempts to implement the location counter syntax (*) for the HLASM variant for PC-relative instructions.
• In the HLASM variant, for purely constant relocatable values, we expect a * token preceding it, with special support for " *" which is parsed as "<pc-rel-insn 0>"
• For combinations of absolute values and relocatable values, we don't expect the "*" preceding the token.

When you have a " * " what’s accepted is:

*<space>.*{.*} -> <pc-rel-insn> 0
*[+|-][constant-value] -> <pc-rel-insn> [+|-]constant-value

When you don’t have a " * " what’s accepted is:

brasl  1,func           is allowed (MCSymbolRef type)
brasl  1,func+4         is allowed (MCBinary type)
brasl  1,4+func         is allowed (MCBinary type)
brasl  1,-4+func        is allowed (MCBinary type)
brasl  1,func-4         is allowed (MCBinary type)
brasl  1,*func          is not allowed (* cannot be used for non-MCConstantExprs)
brasl  1,*+func         is not allowed (* cannot be used for non-MCConstantExprs)
brasl  1,*+func+4       is not allowed (* cannot be used for non-MCConstantExprs)
brasl  1,*+4+func       is not allowed (* cannot be used for non-MCConstantExprs)
brasl  1,*-4+8+func     is not allowed (* cannot be used for non-MCConstantExprs)

[anirudhp]

• Rebase on latest master

[Kai]

LGTM.

[anirudhp]

• Rebasing on latest.

[anirudhp]

• Rebase on latest + moving the StarIsPC field in SystemZMCAsmInfo.cpp to below DotIsPC

[anirudhp]

Ping :)

[anirudhp]

• Rebase on latest

llvm/include/llvm/MC/MCAsmInfo.h

protected:
   /// 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;
 
+  /// Whether the '*' token refers to the current PC. This is used for the
+  /// HLASM dialect.
+  bool StarIsPC = false;
+
   /// 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:
   /// 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; }
+  bool getStarIsPC() const { return StarIsPC; }
   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::Error:
     return true;
   case AsmToken::Exclaim:
     Lex(); // Eat the operator.
     if (parsePrimaryExpr(Res, EndLoc, TypeInfo))
       return true;
     Res = MCUnaryExpr::createLNot(Res, getContext(), FirstTokenLoc);
     return false;
   case AsmToken::Dollar:
+  case AsmToken::Star:
   case AsmToken::At:
   case AsmToken::String:
   case AsmToken::Identifier: {
     StringRef Identifier;
     if (parseIdentifier(Identifier)) {
-      // We may have failed but $ may be a valid token.
-      if (getTok().is(AsmToken::Dollar)) {
-        if (Lexer.getMAI().getDollarIsPC()) {
-          Lex();
-          // 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 = FirstTokenLoc;
-          return false;
-        }
-        return Error(FirstTokenLoc, "invalid token in expression");
-      }
+      // We may have failed but '$'|'*' may be a valid token in context of
+      // the current PC.
+      if (getTok().is(AsmToken::Dollar) || getTok().is(AsmToken::Star)) {
+        bool ShouldGenerateTempSymbol = false;
+        if ((getTok().is(AsmToken::Dollar) && MAI.getDollarIsPC()) ||
+            (getTok().is(AsmToken::Star) && MAI.getStarIsPC()))
+          ShouldGenerateTempSymbol = true;
+
+        if (!ShouldGenerateTempSymbol)
+          return Error(FirstTokenLoc, "invalid token in expression");
+
+        // Eat the '$'|'*' token.
+        // This is either a '$'|'*' reference, which references the current PC.
+        // Emit a temporary label to the streamer and refer to it.
     }
     // Parse symbol variant
     std::pair<StringRef, StringRef> Split;
     if (!MAI.useParensForSymbolVariant()) {
       if (FirstTokenKind == AsmToken::String) {
         if (Lexer.is(AsmToken::At)) {
           Lex(); // eat @
           SMLoc AtLoc = getLexer().getLoc();

llvm/lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp

if (auto *CE = dyn_cast<MCConstantExpr>(E)) {
         return true;
     }
     return false;
   };
 
   // For consistency with the GNU assembler, treat immediates as offsets
   // from ".".
   if (auto *CE = dyn_cast<MCConstantExpr>(Expr)) {
+    if (isParsingHLASM()) {
+      Error(StartLoc, "Expected PC-relative expression");
+      return MatchOperand_ParseFail;
+    }
     if (isOutOfRangeConstant(CE)) {
       Error(StartLoc, "offset out of range");
       return MatchOperand_ParseFail;
     }
     int64_t Value = CE->getValue();
     MCSymbol *Sym = Ctx.createTempSymbol();
     Out.emitLabel(Sym);
     const MCExpr *Base = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None,

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

SystemZMCAsmInfo::SystemZMCAsmInfo(const Triple &TT) {
 
   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);
+  StarIsPC = (AssemblerDialect == AD_HLASM);
 
   ZeroDirective = "\t.space\t";
   Data64bitsDirective = "\t.quad\t";
   UsesELFSectionDirectiveForBSS = true;
   SupportsDebugInformation = true;
   ExceptionsType = ExceptionHandling::DwarfCFI;
 }

llvm/test/MC/AsmParser/directive_rept-diagnostics.s

 # RUN: not llvm-mc -triple i686-elf -filetype asm -o /dev/null %s 2>&1 \
 # RUN:   | FileCheck %s
 
   .data
 
   .global invalid_expression
   .type invalid_expression,@object
 invalid_expression:
   .rept *
 
-# CHECK: error: unknown token in expression
+# CHECK: error: invalid token in expression
 # CHECK:  .rept *
 # CHECK:              ^
 
   .global bad_token
   .type bad_token,@object
 bad_token:
   .rept bad_token
 

llvm/unittests/MC/SystemZ/SystemZAsmLexerTest.cpp

TEST_F(SystemZAsmLexerTest, CheckRejectDotAsCurrentPC) {
   // 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, CheckRejectStarAsCurrentPC) {
+  StringRef AsmStr = "*-4";
+
+  // Setup.
+  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