[AsmParser][SystemZ][z/OS] Support for emitting labels in upper case

[anirudhp]

Summary

• Currently, the emitting of labels in the parsePrimaryExpr function is case independent. It just takes the identifier and emits it.
• However, for HLASM the emitting of labels is case independent. We are emitting them in the upper case only, to enforce case independency. So we need to ensure that at the time of parsing the label we are emitting the upper case (in parseAsHLASMLabel), but also, when we are processing a PC-relative relocatable expression, we need to ensure we emit it in upper case (in parsePrimaryExpr)
• To achieve this a new MCAsmInfo attribute has been introduced which corresponding targets can override if needed.

[abhina.sreeskantharajan]

LGTM

[uweigand]

LGTM

llvm/include/llvm/MC/MCAsmInfo.h

protected:
 
   /// Should we emit the '\t' as the starting indentation marker for GNU inline
   /// asm statements. Defaults to true.
   bool EmitGNUAsmStartIndentationMarker = true;
 
   /// This is appended to emitted labels.  Defaults to ":"
   const char *LabelSuffix;
 
+  /// Emit labels in purely upper case. Defaults to false.
+  bool EmitLabelsInUpperCase = false;
+
   // Print the EH begin symbol with an assignment. Defaults to false.
   bool UseAssignmentForEHBegin = false;
 
   // Do we need to create a local symbol for .size?
   bool NeedsLocalForSize = false;
 
   /// This prefix is used for globals like constant pool entries that are
   /// completely private to the .s file and should not have names in the .o
public:
   bool getRestrictCommentStringToStartOfStatement() const {
     return RestrictCommentStringToStartOfStatement;
   }
   bool shouldAllowAdditionalComments() const { return AllowAdditionalComments; }
   bool getEmitGNUAsmStartIndentationMarker() const {
     return EmitGNUAsmStartIndentationMarker;
   }
   const char *getLabelSuffix() const { return LabelSuffix; }
+  bool shouldEmitLabelsInUpperCase() const { return EmitLabelsInUpperCase; }
 
   bool useAssignmentForEHBegin() const { return UseAssignmentForEHBegin; }
   bool needsLocalForSize() const { return NeedsLocalForSize; }
   StringRef getPrivateGlobalPrefix() const { return PrivateGlobalPrefix; }
   StringRef getPrivateLabelPrefix() const { return PrivateLabelPrefix; }
 
   bool hasLinkerPrivateGlobalPrefix() const {
     return !LinkerPrivateGlobalPrefix.empty();

llvm/lib/MC/MCParser/AsmParser.cpp

if (!Split.second.empty()) {
       } else {
         return Error(SMLoc::getFromPointer(Split.second.begin()),
                      "invalid variant '" + Split.second + "'");
       }
     }
 
     MCSymbol *Sym = getContext().getInlineAsmLabel(SymbolName);
     if (!Sym)
-      Sym = getContext().getOrCreateSymbol(SymbolName);
+      Sym = getContext().getOrCreateSymbol(
+          MAI.shouldEmitLabelsInUpperCase() ? SymbolName.upper() : SymbolName);
 
     // If this is an absolute variable reference, substitute it now to preserve
     // semantics in the face of reassignment.
     if (Sym->isVariable()) {
       auto V = Sym->getVariableValue(/*SetUsed*/ false);
       bool DoInline = isa<MCConstantExpr>(V) && !Variant;
       if (auto TV = dyn_cast<MCTargetExpr>(V))
         DoInline = TV->inlineAssignedExpr();
bool HLASMAsmParser::parseAsHLASMLabel(ParseStatementInfo &Info,
   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);
+  MCSymbol *Sym = getContext().getOrCreateSymbol(
+      getContext().getAsmInfo()->shouldEmitLabelsInUpperCase()
+          ? LabelVal.upper()
+          : 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.

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

SystemZMCAsmInfo::SystemZMCAsmInfo(const Triple &TT) {
   AllowAdditionalComments = (AssemblerDialect == AD_ATT);
   AllowAtAtStartOfIdentifier = (AssemblerDialect == AD_HLASM);
   AllowDollarAtStartOfIdentifier = (AssemblerDialect == AD_HLASM);
   AllowHashAtStartOfIdentifier = (AssemblerDialect == AD_HLASM);
   DotIsPC = (AssemblerDialect == AD_ATT);
   StarIsPC = (AssemblerDialect == AD_HLASM);
   EmitGNUAsmStartIndentationMarker = (AssemblerDialect == AD_ATT);
   AllowAtInName = (AssemblerDialect == AD_HLASM);
+  EmitLabelsInUpperCase = (AssemblerDialect == AD_HLASM);
 
   ZeroDirective = "\t.space\t";
   Data64bitsDirective = "\t.quad\t";
   UsesELFSectionDirectiveForBSS = true;
   SupportsDebugInformation = true;
   ExceptionsType = ExceptionHandling::DwarfCFI;
 }
 
 bool SystemZMCAsmInfo::isAcceptableChar(char C) const {
   if (AssemblerDialect == AD_ATT)
     return MCAsmInfo::isAcceptableChar(C);
 
   return MCAsmInfo::isAcceptableChar(C) || C == '#';
 }

llvm/unittests/MC/SystemZ/SystemZAsmLexerTest.cpp

public:
   void setAllowDollarAtStartOfIdentifier(bool Value) {
     AllowDollarAtStartOfIdentifier = Value;
   }
   void setAllowHashAtStartOfIdentifier(bool Value) {
     AllowHashAtStartOfIdentifier = Value;
   }
   void setAllowDotIsPC(bool Value) { DotIsPC = Value; }
   void setAssemblerDialect(unsigned Value) { AssemblerDialect = Value; }
+  void setEmitLabelsInUpperCase(bool Value) { EmitLabelsInUpperCase = Value; }
 };
 
 // Setup a testing class that the GTest framework can call.
 class SystemZAsmLexerTest : public ::testing::Test {
 protected:
   static void SetUpTestCase() {
     LLVMInitializeSystemZTargetInfo();
     LLVMInitializeSystemZTargetMC();

 
 TEST_F(SystemZAsmLexerTest, CheckPrintAcceptableSymbol2) {
   MUPMAI->setAssemblerDialect(1);
   std::string AsmStr = "ab13_$.@";
   EXPECT_EQ(true, MUPMAI->isValidUnquotedName(AsmStr));
   AsmStr += "#";
   EXPECT_EQ(true, MUPMAI->isValidUnquotedName(AsmStr));
 }
+
+TEST_F(SystemZAsmLexerTest, CheckLabelCaseUpperCase2) {
+  StringRef AsmStr = "label\nlabel";
+
+  // Setup.
+  setupCallToAsmParser(AsmStr);
+
+  // Lex initially to get the string.
+  Parser->getLexer().Lex();
+
+  const MCExpr *Expr;
+  bool ParsePrimaryExpr = Parser->parseExpression(Expr);
+  EXPECT_EQ(ParsePrimaryExpr, false);
+
+  const MCSymbolRefExpr *SymbolExpr = dyn_cast<MCSymbolRefExpr>(Expr);
+  EXPECT_NE(SymbolExpr, nullptr);
+  EXPECT_NE(&SymbolExpr->getSymbol(), nullptr);
+  EXPECT_EQ((&SymbolExpr->getSymbol())->getName(), StringRef("label"));
+
+  // Lex the end of statement token.
+  Parser->getLexer().Lex();
+
+  MUPMAI->setEmitLabelsInUpperCase(true);
+
+  ParsePrimaryExpr = Parser->parseExpression(Expr);
+  EXPECT_EQ(ParsePrimaryExpr, false);
+
+  SymbolExpr = dyn_cast<MCSymbolRefExpr>(Expr);
+  EXPECT_NE(SymbolExpr, nullptr);
+  EXPECT_NE(&SymbolExpr->getSymbol(), nullptr);
+  EXPECT_EQ((&SymbolExpr->getSymbol())->getName(), StringRef("LABEL"));
+}
 } // end anonymous namespace