[SystemZ][z/OS] Remove register prefixes when printing out the register.

[anirudhp]

Summary

• This patch is the first part in enforcing prefix-less registers for the HLASM dialect in z/OS
• This patch removes the "%[r|f|v]" prefix while printing registers
• To achieve this, the AssemblerDialect field of MAI was used
• There is also a bit of refactoring done to ensure code repetition is reduced.
• Currently the LLVM assembler for SystemZ/z/OS accepts both prefixed registers and prefix-less registers. A subsequent follow-up patch will restrict the SystemZAsmParser to only accept prefix-less registers.

Crediting @kianm as an author as well.

[anirudhp]

• Rebase on latest master

[abhina.sreeskantharajan]

LGTM

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

59

minor comment: Could we just pass in the AssemblerDialect instead of the MAI object because it seems to be the only thing being used? If there are future changes coming that use MAI, then feel free to ignore.

[uweigand]

LGTM as well.

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

59

I actually prefer passing the MAI, this is more general and done everywhere else as well.

llvm/lib/Target/SystemZ/MCTargetDesc/SystemZInstPrinter.h

 //==- SystemZInstPrinter.h - Convert SystemZ MCInst to assembly --*- C++ -*-==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This class prints a SystemZ MCInst to a .s file.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TARGET_SYSTEMZ_MCTARGETDESC_SYSTEMZINSTPRINTER_H
 #define LLVM_LIB_TARGET_SYSTEMZ_MCTARGETDESC_SYSTEMZINSTPRINTER_H
 
+#include "SystemZMCAsmInfo.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include <cstdint>
 
 namespace llvm {
 
 class MCOperand;
 
 class SystemZInstPrinter : public MCInstPrinter {
 public:
   SystemZInstPrinter(const MCAsmInfo &MAI, const MCInstrInfo &MII,
                      const MCRegisterInfo &MRI)
     : MCInstPrinter(MAI, MII, MRI) {}
 
   // Automatically generated by tblgen.
   std::pair<const char *, uint64_t> getMnemonic(const MCInst *MI) override;
   void printInstruction(const MCInst *MI, uint64_t Address, raw_ostream &O);
   static const char *getRegisterName(unsigned RegNo);
 
   // Print an address with the given base, displacement and index.
-  static void printAddress(unsigned Base, int64_t Disp, unsigned Index,
-                           raw_ostream &O);
+  static void printAddress(const MCAsmInfo *MAI, unsigned Base, int64_t Disp,
+                           unsigned Index, raw_ostream &O);
 
   // Print the given operand.
   static void printOperand(const MCOperand &MO, const MCAsmInfo *MAI,
                            raw_ostream &O);
 
+  static void printFormattedRegName(const MCAsmInfo *MAI, unsigned RegNo,
+                                    raw_ostream &O);
+
   // Override MCInstPrinter.
-  void printRegName(raw_ostream &O, unsigned RegNo) const override;
+  inline void printRegName(raw_ostream &O, unsigned RegNo) const override {
+    printFormattedRegName(&MAI, RegNo, O);
+  }
+
   void printInst(const MCInst *MI, uint64_t Address, StringRef Annot,
                  const MCSubtargetInfo &STI, raw_ostream &O) override;
 
 private:
   // Print various types of operand.
   void printOperand(const MCInst *MI, int OpNum, raw_ostream &O);
   void printOperand(const MCInst *MI, uint64_t /*Address*/, unsigned OpNum,
                     raw_ostream &O) {

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

 #include <cstdint>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "asm-printer"
 
 #include "SystemZGenAsmWriter.inc"
 
-void SystemZInstPrinter::printAddress(unsigned Base, int64_t Disp,
-                                      unsigned Index, raw_ostream &O) {
+void SystemZInstPrinter::printAddress(const MCAsmInfo *MAI, unsigned Base,
+                                      int64_t Disp, unsigned Index,
+                                      raw_ostream &O) {
   O << Disp;
   if (Base || Index) {
     O << '(';
     if (Index) {
-      O << '%' << getRegisterName(Index);
+      printFormattedRegName(MAI, Index, O);
       if (Base)
         O << ',';
     }
     if (Base)
-      O << '%' << getRegisterName(Base);
+      printFormattedRegName(MAI, Base, O);
     O << ')';
   }
 }
 
 void SystemZInstPrinter::printOperand(const MCOperand &MO, const MCAsmInfo *MAI,
                                       raw_ostream &O) {
   if (MO.isReg()) {
     if (!MO.getReg())
       O << '0';
     else
-      O << '%' << getRegisterName(MO.getReg());
+      printFormattedRegName(MAI, MO.getReg(), O);
   }
   else if (MO.isImm())
     O << MO.getImm();
   else if (MO.isExpr())
     MO.getExpr()->print(O, MAI);
   else
     llvm_unreachable("Invalid operand");
 }
 
+void SystemZInstPrinter::printFormattedRegName(const MCAsmInfo *MAI,
+                                               unsigned RegNo, raw_ostream &O) {
+  const char *RegName = getRegisterName(RegNo);
+  if (MAI->getAssemblerDialect() == AD_HLASM) {
+    // Skip register prefix so that only register number is left
+    assert(isalpha(RegName[0]) && isdigit(RegName[1]));
+    O << (RegName + 1);
+  } else
+    O << '%' << RegName;
+}
+
 void SystemZInstPrinter::printInst(const MCInst *MI, uint64_t Address,
                                    StringRef Annot, const MCSubtargetInfo &STI,
                                    raw_ostream &O) {
   printInstruction(MI, Address, O);
   printAnnotation(O, Annot);
 }
 
-void SystemZInstPrinter::printRegName(raw_ostream &O, unsigned RegNo) const {
-  O << '%' << getRegisterName(RegNo);
-}
-
 template <unsigned N>
 static void printUImmOperand(const MCInst *MI, int OpNum, raw_ostream &O) {
   int64_t Value = MI->getOperand(OpNum).getImm();
   assert(isUInt<N>(Value) && "Invalid uimm argument");
   O << Value;
 }
 
 template <unsigned N>

 
 void SystemZInstPrinter::printOperand(const MCInst *MI, int OpNum,
                                       raw_ostream &O) {
   printOperand(MI->getOperand(OpNum), &MAI, O);
 }
 
 void SystemZInstPrinter::printBDAddrOperand(const MCInst *MI, int OpNum,
                                             raw_ostream &O) {
-  printAddress(MI->getOperand(OpNum).getReg(),
+  printAddress(&MAI, MI->getOperand(OpNum).getReg(),
                MI->getOperand(OpNum + 1).getImm(), 0, O);
 }
 
 void SystemZInstPrinter::printBDXAddrOperand(const MCInst *MI, int OpNum,
                                              raw_ostream &O) {
-  printAddress(MI->getOperand(OpNum).getReg(),
+  printAddress(&MAI, MI->getOperand(OpNum).getReg(),
                MI->getOperand(OpNum + 1).getImm(),
                MI->getOperand(OpNum + 2).getReg(), O);
 }
 
 void SystemZInstPrinter::printBDLAddrOperand(const MCInst *MI, int OpNum,
                                              raw_ostream &O) {
   unsigned Base = MI->getOperand(OpNum).getReg();
   uint64_t Disp = MI->getOperand(OpNum + 1).getImm();
   uint64_t Length = MI->getOperand(OpNum + 2).getImm();
   O << Disp << '(' << Length;
-  if (Base)
-    O << ",%" << getRegisterName(Base);
+  if (Base) {
+    O << ",";
+    printRegName(O, Base);
+  }
   O << ')';
 }
 
 void SystemZInstPrinter::printBDRAddrOperand(const MCInst *MI, int OpNum,
                                              raw_ostream &O) {
   unsigned Base = MI->getOperand(OpNum).getReg();
   uint64_t Disp = MI->getOperand(OpNum + 1).getImm();
   unsigned Length = MI->getOperand(OpNum + 2).getReg();
-  O << Disp << "(%" << getRegisterName(Length);
-  if (Base)
-    O << ",%" << getRegisterName(Base);
+  O << Disp << "(";
+  printRegName(O, Length);
+  if (Base) {
+    O << ",";
+    printRegName(O, Base);
+  }
   O << ')';
 }
 
 void SystemZInstPrinter::printBDVAddrOperand(const MCInst *MI, int OpNum,
                                              raw_ostream &O) {
-  printAddress(MI->getOperand(OpNum).getReg(),
+  printAddress(&MAI, MI->getOperand(OpNum).getReg(),
                MI->getOperand(OpNum + 1).getImm(),
                MI->getOperand(OpNum + 2).getReg(), O);
 }
 
 void SystemZInstPrinter::printCond4Operand(const MCInst *MI, int OpNum,
                                            raw_ostream &O) {
   static const char *const CondNames[] = {
     "o", "h", "nle", "l", "nhe", "lh", "ne",
     "e", "nlh", "he", "nl", "le", "nh", "no"
   };
   uint64_t Imm = MI->getOperand(OpNum).getImm();
   assert(Imm > 0 && Imm < 15 && "Invalid condition");
   O << CondNames[Imm - 1];
 }

llvm/lib/Target/SystemZ/SystemZAsmPrinter.cpp

bool SystemZAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
   SystemZInstPrinter::printOperand(MO, MAI, OS);
   return false;
 }
 
 bool SystemZAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
                                               unsigned OpNo,
                                               const char *ExtraCode,
                                               raw_ostream &OS) {
-  SystemZInstPrinter::printAddress(MI->getOperand(OpNo).getReg(),
+  SystemZInstPrinter::printAddress(MAI, MI->getOperand(OpNo).getReg(),
                                    MI->getOperand(OpNo + 1).getImm(),
                                    MI->getOperand(OpNo + 2).getReg(), OS);
   return false;
 }
 
 void SystemZAsmPrinter::emitEndOfAsmFile(Module &M) {
   emitStackMaps(SM);
 }
 
 // Force static initialization.
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeSystemZAsmPrinter() {
   RegisterAsmPrinter<SystemZAsmPrinter> X(getTheSystemZTarget());
 }