[AsmParser][SystemZ][z/OS] Introducing HLASM Parser support to AsmParser - Part 2

[anirudhp]

Summary

• This patch is the second (and hopefully final) part of providing HLASM syntax for inline asm statements for z/OS to LLVM (continuing on from https://reviews.llvm.org/D98276)
• This second part deals with providing label support
• As mentioned in https://reviews.llvm.org/D98276, if the first token is not a space we process the first token as a label, and the remaining tokens as a possible machine instruction
• To achieve this, a new parseAsHLASMLabel function is introduced. This function processes the first token, validates whether it is an "acceptable" label according to HLASM standards, and then emits it
• After handling and emitting the label, call the parseAsMachineInstruction instruction to process the remaining tokens as a machine instruction.

[uweigand]

LGTM.

llvm/lib/MC/MCParser/AsmParser.cpp

protected:
 
   /// This routine uses the target specific ParseInstruction function to
   /// parse an instruction into Operands, and then call the target specific
   /// MatchAndEmit function to match and emit the instruction.
   bool parseAndMatchAndEmitTargetInstruction(ParseStatementInfo &Info,
                                              StringRef IDVal, AsmToken ID,
                                              SMLoc IDLoc);
 
+  /// Should we emit DWARF describing this assembler source?  (Returns false if
+  /// the source has .file directives, which means we don't want to generate
+  /// info describing the assembler source itself.)
+  bool enabledGenDwarfForAssembly();
+
 public:
   AsmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,
             const MCAsmInfo &MAI, unsigned CB);
   AsmParser(const AsmParser &) = delete;
   AsmParser &operator=(const AsmParser &) = delete;
   ~AsmParser() override;
 
   bool Run(bool NoInitialTextSection, bool NoFinalize = false) override;
private:
   void printMacroInstantiations();
   void printMessage(SMLoc Loc, SourceMgr::DiagKind Kind, const Twine &Msg,
                     SMRange Range = None) const {
     ArrayRef<SMRange> Ranges(Range);
     SrcMgr.PrintMessage(Loc, Kind, Msg, Ranges);
   }
   static void DiagHandler(const SMDiagnostic &Diag, void *Context);
 
-  /// Should we emit DWARF describing this assembler source?  (Returns false if
-  /// the source has .file directives, which means we don't want to generate
-  /// info describing the assembler source itself.)
-  bool enabledGenDwarfForAssembly();
-
   /// Enter the specified file. This returns true on failure.
   bool enterIncludeFile(const std::string &Filename);
 
   /// Process the specified file for the .incbin directive.
   /// This returns true on failure.
   bool processIncbinFile(const std::string &Filename, int64_t Skip = 0,
                          const MCExpr *Count = nullptr, SMLoc Loc = SMLoc());
 
bool AsmParser::parseMSInlineAsm(
   // Emit the remainder of the asm string.
   if (AsmStart != AsmEnd)
     OS << StringRef(AsmStart, AsmEnd - AsmStart);
 
   AsmString = OS.str();
   return false;
 }
 
+bool HLASMAsmParser::parseAsHLASMLabel(ParseStatementInfo &Info,
+                                       MCAsmParserSemaCallback *SI) {
+  AsmToken LabelTok = getTok();
+  SMLoc LabelLoc = LabelTok.getLoc();
+  StringRef LabelVal;
+
+  if (parseIdentifier(LabelVal))
+    return Error(LabelLoc, "The HLASM Label has to be an Identifier");
+
+  // We have validated whether the token is an Identifier.
+  // Now we have to validate whether the token is a
+  // valid HLASM Label.
+  if (!getTargetParser().isLabel(LabelTok) || checkForValidSection())
+    return true;
+
+  // Lex leading spaces to get to the next operand.
+  lexLeadingSpaces();
+
+  // We shouldn't emit the label if there is nothing else after the label.
+  // i.e asm("<token>\n")
+  if (getTok().is(AsmToken::EndOfStatement))
+    return Error(LabelLoc,
+                 "Cannot have just a label for an HLASM inline asm statement");
+
+  // FIXME: Later on, ensure emitted labels are case-insensitive.
+  MCSymbol *Sym = getContext().getOrCreateSymbol(LabelVal);
+
+  getTargetParser().doBeforeLabelEmit(Sym);
+
+  // Emit the label.
+  Out.emitLabel(Sym, LabelLoc);
+
+  // If we are generating dwarf for assembly source files then gather the
+  // info to make a dwarf label entry for this label if needed.
+  if (enabledGenDwarfForAssembly())
+    MCGenDwarfLabelEntry::Make(Sym, &getStreamer(), getSourceManager(),
+                               LabelLoc);
+
+  getTargetParser().onLabelParsed(Sym);
+
+  return false;
+}
+
 bool HLASMAsmParser::parseAsMachineInstruction(ParseStatementInfo &Info,
                                                MCAsmParserSemaCallback *SI) {
   AsmToken OperationEntryTok = Lexer.getTok();
   SMLoc OperationEntryLoc = OperationEntryTok.getLoc();
   StringRef OperationEntryVal;
 
-  // If we see a new line or carriage return, emit the new line
-  // and lex it.
-  if (OperationEntryTok.is(AsmToken::EndOfStatement)) {
-    if (getTok().getString().front() == '\n' ||
-        getTok().getString().front() == '\r') {
-      Out.AddBlankLine();
-      Lex();
-      return false;
-    }
-  }
-
   // Attempt to parse the first token as an Identifier
   if (parseIdentifier(OperationEntryVal))
     return Error(OperationEntryLoc, "unexpected token at start of statement");
 
   // Once we've parsed the operation entry successfully, lex
   // any spaces to get to the OperandEntries.
   lexLeadingSpaces();
 
   return parseAndMatchAndEmitTargetInstruction(
       Info, OperationEntryVal, OperationEntryTok, OperationEntryLoc);
 }
 
 bool HLASMAsmParser::parseStatement(ParseStatementInfo &Info,
                                     MCAsmParserSemaCallback *SI) {
   assert(!hasPendingError() && "parseStatement started with pending error");
 
-  // Should the first token be interpreted as a machine instruction.
-  bool ShouldParseAsMachineInstruction = false;
+  // Should the first token be interpreted as a HLASM Label.
+  bool ShouldParseAsHLASMLabel = false;
 
   // If a Name Entry exists, it should occur at the very
   // start of the string. In this case, we should parse the
   // first non-space token as a Label.
   // If the Name entry is missing (i.e. there's some other
   // token), then we attempt to parse the first non-space
   // token as a Machine Instruction.
-  if (getTok().is(AsmToken::Space))
-    ShouldParseAsMachineInstruction = true;
+  if (getTok().isNot(AsmToken::Space))
+    ShouldParseAsHLASMLabel = true;
 
   // If we have an EndOfStatement (which includes the target's comment
   // string) we can appropriately lex it early on)
   if (Lexer.is(AsmToken::EndOfStatement)) {
     // if this is a line comment we can drop it safely
     if (getTok().getString().empty() || getTok().getString().front() == '\r' ||
         getTok().getString().front() == '\n')
       Out.AddBlankLine();
     Lex();
     return false;
   }
 
   // We have established how to parse the inline asm statement.
   // Now we can safely lex any leading spaces to get to the
   // first token.
   lexLeadingSpaces();
 
-  if (ShouldParseAsMachineInstruction)
-    return parseAsMachineInstruction(Info, SI);
+  // If we see a new line or carriage return as the first operand,
+  // after lexing leading spaces, emit the new line and lex the
+  // EndOfStatement token.
+  if (Lexer.is(AsmToken::EndOfStatement)) {
+    if (getTok().getString().front() == '\n' ||
+        getTok().getString().front() == '\r') {
+      Out.AddBlankLine();
+      Lex();
+      return false;
+    }
+  }
 
-  // Label parsing support isn't implemented completely (yet).
-  SMLoc Loc = getTok().getLoc();
-  eatToEndOfStatement();
-  return Error(Loc, "HLASM Label parsing support not yet implemented");
+  // Handle the label first if we have to before processing the rest
+  // of the tokens as a machine instruction.
+  if (ShouldParseAsHLASMLabel) {
+    // If there were any errors while handling and emitting the label,
+    // early return.
+    if (parseAsHLASMLabel(Info, SI))
+      return true;
+  }
+
+  return parseAsMachineInstruction(Info, SI);
 }
 
 namespace llvm {
 namespace MCParserUtils {
 
 /// Returns whether the given symbol is used anywhere in the given expression,
 /// or subexpressions.
 static bool isSymbolUsedInExpression(const MCSymbol *Sym, const MCExpr *Value) {