[SystemZ] Support PrintBranchImmAsAddress in disassembler (llvm#141064)

As noticed in llvm#140471, the
SystemZ target currently implements disassembly of PC-relative target
addresses differently from other back-ends. This patch brings SystemZ in
line with other targets.

Specifically, this patch changes the relevant MCInst instructions to
carry a PC-relative displacement instead of an absolute target address
in their immediate fields. When printing the instruction, this
displacement will either be shown as is (e.g. for llvm-mc), or else
translated into an absolute address at print time (e.g. for
llvm-objdump).

The existing llvm-mc based tests using PC-relative operands no longer
work and have to be rewritten, but printing displacements makes those
tests easier to maintain anyway.

Author: uweigand

llvm/lib/Target/SystemZ/Disassembler/SystemZDisassembler.cpp

@@ -280,9 +280,9 @@ static DecodeStatus decodePCDBLOperand(MCInst &Inst, uint64_t Imm,
                                        uint64_t Address, bool isBranch,
                                        const MCDisassembler *Decoder) {
   assert(isUInt<N>(Imm) && "Invalid PC-relative offset");
-  uint64_t Value = SignExtend64<N>(Imm) * 2 + Address;
+  uint64_t Value = SignExtend64<N>(Imm) * 2;
 
-  if (!tryAddingSymbolicOperand(Value, isBranch, Address, 2, N / 8,
+  if (!tryAddingSymbolicOperand(Value + Address, isBranch, Address, 2, N / 8,
                                 Inst, Decoder))
     Inst.addOperand(MCOperand::createImm(Value));
 

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

@@ -148,22 +148,38 @@ void SystemZInstPrinterCommon::printU48ImmOperand(const MCInst *MI, int OpNum,
   printUImmOperand<48>(MI, OpNum, O);
 }
 
-void SystemZInstPrinterCommon::printPCRelOperand(const MCInst *MI, int OpNum,
+void SystemZInstPrinterCommon::printPCRelOperand(const MCInst *MI,
+                                                 uint64_t Address, int OpNum,
                                                  raw_ostream &O) {
   const MCOperand &MO = MI->getOperand(OpNum);
+
+  // If the label has already been resolved to an immediate offset (say, when
+  // we're running the disassembler), just print the immediate.
   if (MO.isImm()) {
-    WithMarkup M = markup(O, Markup::Immediate);
-    O << "0x";
-    O.write_hex(MO.getImm());
-  } else
+    int64_t Offset = MO.getImm();
+    if (PrintBranchImmAsAddress)
+      markup(O, Markup::Target) << formatHex(Address + Offset);
+    else
+      markup(O, Markup::Immediate) << formatImm(Offset);
+    return;
+  }
+
+  // If the branch target is simply an address then print it in hex.
+  const MCConstantExpr *BranchTarget = dyn_cast<MCConstantExpr>(MO.getExpr());
+  int64_t TargetAddress;
+  if (BranchTarget && BranchTarget->evaluateAsAbsolute(TargetAddress)) {
+    markup(O, Markup::Target) << formatHex((uint64_t)TargetAddress);
+  } else {
+    // Otherwise, just print the expression.
     MO.getExpr()->print(O, &MAI);
+  }
 }
 
 void SystemZInstPrinterCommon::printPCRelTLSOperand(const MCInst *MI,
                                                     uint64_t Address, int OpNum,
                                                     raw_ostream &O) {
   // Output the PC-relative operand.
-  printPCRelOperand(MI, OpNum, O);
+  printPCRelOperand(MI, Address, OpNum, O);
 
   // Output the TLS marker if present.
   if ((unsigned)OpNum + 1 < MI->getNumOperands()) {

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

@@ -71,11 +71,8 @@ class SystemZInstPrinterCommon : public MCInstPrinter {
   void printS32ImmOperand(const MCInst *MI, int OpNum, raw_ostream &O);
   void printU32ImmOperand(const MCInst *MI, int OpNum, raw_ostream &O);
   void printU48ImmOperand(const MCInst *MI, int OpNum, raw_ostream &O);
-  void printPCRelOperand(const MCInst *MI, int OpNum, raw_ostream &O);
-  void printPCRelOperand(const MCInst *MI, uint64_t /*Address*/, int OpNum,
-                         raw_ostream &O) {
-    printPCRelOperand(MI, OpNum, O);
-  }
+  void printPCRelOperand(const MCInst *MI, uint64_t Address, int OpNum,
+                         raw_ostream &O);
   void printPCRelTLSOperand(const MCInst *MI, uint64_t Address, int OpNum,
                             raw_ostream &O);