[llvm] Adopt WithMarkup in the SystemZ backend

[JDevlieghere]

Summary

Adopt the new markup overload, introduced in 77d1032516e7, in the SystemZ backend.

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

void SystemZInstPrinter::printOperand(const MCOperand &MO, const MCAsmInfo *MAI,
                                       raw_ostream &O) {
   if (MO.isReg()) {
     if (!MO.getReg())
       O << '0';
     else
       printFormattedRegName(MAI, MO.getReg(), O);
   }
   else if (MO.isImm())
-    O << markup("<imm:") << MO.getImm() << markup(">");
+    markup(O, Markup::Immediate) << MO.getImm();
   else if (MO.isExpr())
     MO.getExpr()->print(O, MAI);
   else
     llvm_unreachable("Invalid operand");
 }
 
 void SystemZInstPrinter::printFormattedRegName(const MCAsmInfo *MAI,
                                                MCRegister Reg,
                                                raw_ostream &O) const {
   const char *RegName = getRegisterName(Reg);
   if (MAI->getAssemblerDialect() == AD_HLASM) {
     // Skip register prefix so that only register number is left
     assert(isalpha(RegName[0]) && isdigit(RegName[1]));
-    O << markup("<reg:") << (RegName + 1) << markup(">");
+    markup(O, Markup::Register) << (RegName + 1);
   } else
-    O << markup("<reg:") << '%' << RegName << markup(">");
+    markup(O, Markup::Register) << '%' << RegName;
 }
 
 void SystemZInstPrinter::printRegName(raw_ostream &O, MCRegister Reg) const {
   printFormattedRegName(&MAI, Reg, O);
 }
 
 void SystemZInstPrinter::printInst(const MCInst *MI, uint64_t Address,
                                    StringRef Annot, const MCSubtargetInfo &STI,
                                    raw_ostream &O) {
   printInstruction(MI, Address, O);
   printAnnotation(O, Annot);
 }
 
 template <unsigned N>
 void SystemZInstPrinter::printUImmOperand(const MCInst *MI, int OpNum,
                                           raw_ostream &O) {
   const MCOperand &MO = MI->getOperand(OpNum);
   if (MO.isExpr()) {
     O << *MO.getExpr();
     return;
   }
   uint64_t Value = static_cast<uint64_t>(MO.getImm());
   assert(isUInt<N>(Value) && "Invalid uimm argument");
-  O << markup("<imm:") << Value << markup(">");
+  markup(O, Markup::Immediate) << Value;
 }
 
 template <unsigned N>
 void SystemZInstPrinter::printSImmOperand(const MCInst *MI, int OpNum,
                                           raw_ostream &O) {
   const MCOperand &MO = MI->getOperand(OpNum);
   if (MO.isExpr()) {
     O << *MO.getExpr();
     return;
   }
   int64_t Value = MI->getOperand(OpNum).getImm();
   assert(isInt<N>(Value) && "Invalid simm argument");
-  O << markup("<imm:") << Value << markup(">");
+  markup(O, Markup::Immediate) << Value;
 }
 
 void SystemZInstPrinter::printU1ImmOperand(const MCInst *MI, int OpNum,
                                            raw_ostream &O) {
   printUImmOperand<1>(MI, OpNum, O);
 }
 
 void SystemZInstPrinter::printU2ImmOperand(const MCInst *MI, int OpNum,
void SystemZInstPrinter::printU48ImmOperand(const MCInst *MI, int OpNum,
                                             raw_ostream &O) {
   printUImmOperand<48>(MI, OpNum, O);
 }
 
 void SystemZInstPrinter::printPCRelOperand(const MCInst *MI, int OpNum,
                                            raw_ostream &O) {
   const MCOperand &MO = MI->getOperand(OpNum);
   if (MO.isImm()) {
-    O << markup("<imm:") << "0x";
+    WithMarkup M = markup(O, Markup::Immediate);
+    O << "0x";
     O.write_hex(MO.getImm());
-    O << markup(">");
   } else
     MO.getExpr()->print(O, &MAI);
 }
 
 void SystemZInstPrinter::printPCRelTLSOperand(const MCInst *MI,
                                               uint64_t Address, int OpNum,
                                               raw_ostream &O) {
   // Output the PC-relative operand.