[PowerPC][llvm-objdump] enable --symbolize-operands for PowerPC ELF/XCOFF.

[Esme]

Summary

--symbolize-operands
When disassembling, symbolize a branch target operand to print a label instead of a real address.

[MaskRay]

llvm/test/tools/llvm-objdump/ELF/PowerPC/elf-disassemble-symbolize-operands.yaml

7

Add -NEXT:

43

obj2yaml created test file has many redundant things which are noise, e.g. eh_frame, .note.GNU-stack, STT_FILE. They can all be deleted.

How about using assembly with llvm-mc -filetype=obj? The main thing to test is the code sequence which is opaque as the yaml test (Content). An assembly test is easier to update.

llvm/tools/llvm-objdump/llvm-objdump.cpp

981

You can order PowerPC before X86 for an alphabetical order.

[jhenderson]

llvm/test/tools/llvm-objdump/ELF/PowerPC/elf-disassemble-symbolize-operands.yaml

1

Don't prefix test names with elf- if they're in an ELF subdirectory.

llvm/test/tools/llvm-objdump/XCOFF/disassemble-symbolize-operands.yaml

17–18

Similar comment to MaskRay's above - the input probably wants to just be IR or assembly.

[Esme]

Address comments.

[shchenz]

lld/test/ELF/ppc64-toc-call-to-pcrel.s

32–33

The change is not so straightforward to me.

Could we use <callee>:, <caller>:, <__toc_save_callee>: as the check label content? So it would not be confused with the new added branch target like <__toc_save_callee>.

llvm/test/tools/llvm-objdump/ELF/PowerPC/disassemble-symbolize-operands.ll

1 ↗

(On Diff #392618)

Can we add a case with internal/external function calls?

3 ↗

(On Diff #392618)

And maybe another case for CTR loop too?(for bdnz)

llvm/test/tools/llvm-objdump/XCOFF/disassemble-symbolize-operands.ll

2 ↗

(On Diff #392618)

Can we show the leading-addr? As it can show whether the label matches the addr or not.

[Esme]

1. Address comments.
2. Skip recording branches for function calls in collectLocalBranchTargets();

[jhenderson]

My comments have been addressed. Looks good, but leaving approval to someone who actually knows about the disassembly.

[shchenz]

llvm/test/tools/llvm-objdump/ELF/PowerPC/disassemble-symbolize-operands.ll

29 ↗

(On Diff #394497)

we can add an internal attribute for the internal function to make sure it is internally called in the function foo. For now, it is not internally called. I saw two external calls there.

Linux system objdump can dump the internal function call as:

78:   89 ff ff 4b     bl      0 <internal>

So it's better llvm-objdump can also dump the internal function call like this.

llvm/tools/llvm-objdump/llvm-objdump.cpp

1002

s/PowerPc/PowerPC/g

1004

Can this logic be added in PPCMCInstrAnalysis? So we don't need the target check here.

[Esme]

Address comments.

llvm/tools/llvm-objdump/llvm-objdump.cpp

1004

I think we should return true for such cases in evaluateBranch(), because they are indeed branch operands, and their targets should be printed just like the behavior of system objdump when no --symbolize-operands is requires.

88:      	bl 0x88 <foo+0x48>
8c:      	nop

[shchenz]

LGTM. Thanks for adding this support.

One minor comment: need to update the doc for PowerPC for --symbolize-operands option in llvm-objdump.rst.

Better to wait for some days before committing.

llvm/test/tools/llvm-objdump/XCOFF/disassemble-symbolize-operands.ll

6 ↗

(On Diff #395061)

This seems not right, expect .internal here. I guess it should be a legacy issue. Should be ok to do this in another patch.

[Esme]

llvm/test/tools/llvm-objdump/XCOFF/disassemble-symbolize-operands.ll

6 ↗

(On Diff #395061)

I will leave a TODO for this.

lld/test/ELF/ppc64-toc-call-to-pcrel.s

 # a local function with st_other=1, a TOC save stub is inserted.
 
 # SYMBOL: Symbol table '.symtab' contains 7 entries
 # SYMBOL: 10010000     0 NOTYPE  LOCAL  DEFAULT [<other: 0x20>]   1 callee
 # SYMBOL: 10020000     0 NOTYPE  LOCAL  DEFAULT [<other: 0x60>]   2 caller
 # SYMBOL: 10020020     0 NOTYPE  LOCAL  DEFAULT [<other: 0x60>]   2 caller_14
 # SYMBOL: 10020040     8 FUNC    LOCAL  DEFAULT                   2 __toc_save_callee
 
-# CHECK-LABEL: callee
-# CHECK:       blr
+# CHECK:      <callee>
+# CHECK:      blr
 
-# CHECK-LABEL: caller
-# CHECK:       bl 0x10020040
-# CHECK-NEXT:  ld 2, 24(1)
-# CHECK-NEXT:  blr
+# CHECK:      <caller>
+# CHECK:      bl 0x10020040
+# CHECK-NEXT: ld 2, 24(1)
+# CHECK-NEXT: blr
 
-# CHECK-LABEL: caller_14
-# CHECK:       bfl 0, 0x10020040
-# CHECK-NEXT:  ld 2, 24(1)
-# CHECK-NEXT:  blr
+# CHECK:      <caller_14>
+# CHECK:      bfl 0, 0x10020040 <__toc_save_callee>
+# CHECK-NEXT: ld 2, 24(1)
+# CHECK-NEXT: blr
 
-# CHECK-LABEL: __toc_save_callee
-# CHECK-NEXT:  std 2, 24(1)
-# CHECK-NEXT:  b 0x10010000
-
+# CHECK:      <__toc_save_callee>
+# CHECK-NEXT: std 2, 24(1)
+# CHECK-NEXT: b 0x10010000 <callee>
 
 .section .text_callee, "ax", %progbits
 callee:
   .localentry callee, 1
   blr
 
 .section .text_caller, "ax", %progbits
 caller:

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp

 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCELFStreamer.h"
 #include "llvm/MC/MCExpr.h"
+#include "llvm/MC/MCInstrAnalysis.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSectionXCOFF.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolELF.h"

 static MCInstPrinter *createPPCMCInstPrinter(const Triple &T,
                                              unsigned SyntaxVariant,
                                              const MCAsmInfo &MAI,
                                              const MCInstrInfo &MII,
                                              const MCRegisterInfo &MRI) {
   return new PPCInstPrinter(MAI, MII, MRI, T);
 }
 
+namespace {
+
+class PPCMCInstrAnalysis : public MCInstrAnalysis {
+public:
+  explicit PPCMCInstrAnalysis(const MCInstrInfo *Info)
+      : MCInstrAnalysis(Info) {}
+
+  bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
+                      uint64_t &Target) const override {
+    int64_t Imm;
+    const MCInstrDesc &Desc = Info->get(Inst.getOpcode());
+    if (isUnconditionalBranch(Inst) && Desc.getNumOperands() == 1 &&
+        Inst.getOperand(0).isImm()) {
+      Imm = Inst.getOperand(0).getImm();
+    } else if (isConditionalBranch(Inst)) {
+      if (Desc.getNumOperands() == 2 && Inst.getOperand(1).isImm())
+        Imm = Inst.getOperand(1).getImm();
+      else if (Desc.getNumOperands() == 3 && Inst.getOperand(2).isImm())
+        Imm = Inst.getOperand(2).getImm();
+      else
+        return false;
+    } else {
+      return false;
+    }
+
+    Target = Addr + Imm * Size;
+    return true;
+  }
+};
+
+} // end anonymous namespace
+
+static MCInstrAnalysis *createPPCMCInstrAnalysis(const MCInstrInfo *Info) {
+  return new PPCMCInstrAnalysis(Info);
+}
+
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializePowerPCTargetMC() {
   for (Target *T : {&getThePPC32Target(), &getThePPC32LETarget(),
                     &getThePPC64Target(), &getThePPC64LETarget()}) {
     // Register the MC asm info.
     RegisterMCAsmInfoFn C(*T, createPPCMCAsmInfo);
 
     // Register the MC instruction info.
     TargetRegistry::RegisterMCInstrInfo(*T, createPPCMCInstrInfo);
 
     // Register the MC register info.
     TargetRegistry::RegisterMCRegInfo(*T, createPPCMCRegisterInfo);
 
     // Register the MC subtarget info.
     TargetRegistry::RegisterMCSubtargetInfo(*T, createPPCMCSubtargetInfo);
 
+    // Register the MC instruction analyzer.
+    TargetRegistry::RegisterMCInstrAnalysis(*T, createPPCMCInstrAnalysis);
+
     // Register the MC Code Emitter
     TargetRegistry::RegisterMCCodeEmitter(*T, createPPCMCCodeEmitter);
 
     // Register the asm backend.
     TargetRegistry::RegisterMCAsmBackend(*T, createPPCAsmBackend);
 
     // Register the elf streamer.
     TargetRegistry::RegisterELFStreamer(*T, createPPCELFStreamer);

llvm/test/tools/llvm-objdump/ELF/PowerPC/elf-disassemble-symbolize-operands.yaml

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-objdump %t -d --symbolize-operands --no-show-raw-insn --no-leading-addr | \
+# RUN:   FileCheck %s
+
+## Expect to find the branch labels.
+# CHECK:       andi. 4, 4, 1
+# CHECK:       li 4, 1
+# CHECK:       b 0x28 <L0>
+# CHECK: <L2>:
+# CHECK:       addi 4, 4, 1
+# CHECK: <L1>:
+# CHECK:       bclr 4, 1 <L1>
+# CHECK: <L0>:
+# CHECK:       cmplw 1, 3, 4
+# CHECK:       bf 4, 0x20 <L2>
+# CHECK:       dcbf 0, 3
+# CHECK:       b 0x20 <L2>
+
+## This yaml was created from the following LLVM IR by:
+## $ llc -mtriple=powerpc64le-unknown-linux-gnu 1.ll -filetype=obj -o a.elf
+## $ obj2yaml a.elf
+## ```
+##   define void @break_cond_is_arg(i32 %arg, i1 %breakcond) {
+##   entry:
+##     br label %loop
+##   loop:
+##     %tmp23phi = phi i32 [ %tmp23, %endif ], [ 0, %entry ]
+##     %tmp23 = add nuw i32 %tmp23phi, 1
+##     %tmp27 = icmp ult i32 %arg, %tmp23
+##     br i1 %tmp27, label %then, label %endif
+##   then:                                             ; preds = %bb
+##     tail call void @llvm.ppc.dcbf(i8* undef)
+##     br label %endif
+##   endif:                                             ; preds = %bb28, %bb
+##     br i1 %breakcond, label %loop, label %loopexit
+##   loopexit:
+##     ret void
+##   }
+##   
+##   declare void @llvm.ppc.dcbf(i8*)
+## ```
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_PPC64
+  Flags:           [  ]
+  SectionHeaderStringTable: .strtab
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x20
+    Content:         0100847001008038200000480000006000000060000000600000006000000060010084382000814C4020837CF4FF8440AC18007CECFFFF4B000000000000000000000000
+  - Name:            .note.GNU-stack
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x1
+  - Name:            .eh_frame
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    AddressAlign:    0x8
+    Content:         1000000000000000017A5200047841011B0C01001000000018000000000000004400000000000000
+  - Name:            .rela.eh_frame
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x8
+    Info:            .eh_frame
+    Relocations:
+      - Offset:          0x1C
+        Symbol:          .text
+        Type:            R_PPC64_REL32
+  - Type:            SectionHeaderTable
+    Sections:
+      - Name:            .strtab
+      - Name:            .text
+      - Name:            .note.GNU-stack
+      - Name:            .eh_frame
+      - Name:            .rela.eh_frame
+      - Name:            .symtab
+Symbols:
+  - Name:            1.ll
+    Type:            STT_FILE
+    Index:           SHN_ABS
+  - Name:            .text
+    Type:            STT_SECTION
+    Section:         .text
+  - Name:            break_cond_is_arg
+    Type:            STT_FUNC
+    Section:         .text
+    Binding:         STB_GLOBAL
+    Size:            0x44
+...

llvm/test/tools/llvm-objdump/XCOFF/disassemble-symbolize-operands.yaml

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-objdump %t -d --symbolize-operands --no-show-raw-insn --no-leading-addr | \
+# RUN:   FileCheck %s
+
+## Expect to find the branch labels.
+# CHECK:      b 0x14 <L0>
+# CHECK: <L2>:
+# CHECK:      addi 4, 4, 1
+# CHECK: <L1>:
+# CHECK:      bclr 4, 1 <L1>
+# CHECK: <L0>:
+# CHECK:      cmplw 1, 3, 4
+# CHECK:      bf 4, 0xc <L2>
+# CHECK:      dcbf 0, 3
+# CHECK:      b 0xc <L2>
+
+## This yaml was created from the following LLVM IR by:
+## $ llc -mtriple=powerpc-ibm-aix-xcoff 1.ll -filetype=obj -o a.xcoff
+## $ obj2yaml a.xcoff
+## ```
+##   define void @break_cond_is_arg(i32 %arg, i1 %breakcond) {
+##   entry:
+##     br label %loop
+##   loop:
+##     %tmp23phi = phi i32 [ %tmp23, %endif ], [ 0, %entry ]
+##     %tmp23 = add nuw i32 %tmp23phi, 1
+##     %tmp27 = icmp ult i32 %arg, %tmp23
+##     br i1 %tmp27, label %then, label %endif
+##   then:                                             ; preds = %bb
+##     tail call void @llvm.ppc.dcbf(i8* undef)
+##     br label %endif
+##   endif:                                             ; preds = %bb28, %bb
+##     br i1 %breakcond, label %loop, label %loopexit
+##   loopexit:
+##     ret void
+##   }
+##   
+##   declare void @llvm.ppc.dcbf(i8*)
+## ```
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:     0x1DF
+  NumberOfSections: 2
+  CreationTime:    0
+  OffsetToSymbolTable: 0xD0
+  EntriesInSymbolTable: 9
+  AuxiliaryHeaderSize: 0
+  Flags:           0x0
+Sections:
+  - Name:            .text
+    Address:         0x0
+    Size:            0x4C
+    FileOffsetToData: 0x64
+    FileOffsetToRelocations: 0x0
+    FileOffsetToLineNumbers: 0x0
+    NumberOfRelocations: 0x0
+    NumberOfLineNumbers: 0x0
+    Flags:           [ STYP_TEXT ]
+    SectionData:     70840001388000014800000C388400014C8100207C8320404084FFF47C0018AC4BFFFFEC00000000000920408000020100000000000000240011627265616B5F636F6E645F69735F61726700
+  - Name:            .data
+    Address:         0x4C
+    Size:            0xC
+    FileOffsetToData: 0xB0
+    FileOffsetToRelocations: 0xBC
+    FileOffsetToLineNumbers: 0x0
+    NumberOfRelocations: 0x2
+    NumberOfLineNumbers: 0x0
+    Flags:           [ STYP_DATA ]
+    SectionData:     '000000000000005800000000'
+    Relocations:
+      - Address:         0x4C
+        Symbol:          0x3
+        Info:            0x1F
+        Type:            0x0
+      - Address:         0x50
+        Symbol:          0x7
+        Info:            0x1F
+        Type:            0x0
+Symbols:
+  - Name:            .file
+    Value:           0x0
+    Section:         N_DEBUG
+    Type:            0x0
+    StorageClass:    C_FILE
+    NumberOfAuxEntries: 0
+  - Name:            .text
+    Value:           0x0
+    Section:         .text
+    Type:            0x0
+    StorageClass:    C_HIDEXT
+    NumberOfAuxEntries: 1
+  - Name:            .break_cond_is_arg
+    Value:           0x0
+    Section:         .text
+    Type:            0x0
+    StorageClass:    C_EXT
+    NumberOfAuxEntries: 1
+  - Name:            break_cond_is_arg
+    Value:           0x4C
+    Section:         .data
+    Type:            0x0
+    StorageClass:    C_EXT
+    NumberOfAuxEntries: 1
+  - Name:            TOC
+    Value:           0x58
+    Section:         .data
+    Type:            0x0
+    StorageClass:    C_HIDEXT
+    NumberOfAuxEntries: 1

llvm/tools/llvm-objdump/llvm-objdump.cpp

 }
 
 static void
 collectLocalBranchTargets(ArrayRef<uint8_t> Bytes, const MCInstrAnalysis *MIA,
                           MCDisassembler *DisAsm, MCInstPrinter *IP,
                           const MCSubtargetInfo *STI, uint64_t SectionAddr,
                           uint64_t Start, uint64_t End,
                           std::unordered_map<uint64_t, std::string> &Labels) {
-  // So far only supports X86.
-  if (!STI->getTargetTriple().isX86())
+  // So far only supports X86 and PowerPC.
+  if (!STI->getTargetTriple().isX86() && !STI->getTargetTriple().isPPC())
     return;
 
   Labels.clear();
   unsigned LabelCount = 0;
   Start += SectionAddr;
   End += SectionAddr;
   uint64_t Index = Start;
   while (Index < End) {
     // Disassemble a real instruction and record function-local branch labels.
     MCInst Inst;
     uint64_t Size;
     bool Disassembled = DisAsm->getInstruction(
         Inst, Size, Bytes.slice(Index - SectionAddr), Index, nulls());
     if (Size == 0)
       Size = 1;
 
     if (Disassembled && MIA) {
       uint64_t Target;
       bool TargetKnown = MIA->evaluateBranch(Inst, Index, Size, Target);
       if (TargetKnown && (Target >= Start && Target < End) &&
           !Labels.count(Target))
         Labels[Target] = ("L" + Twine(LabelCount++)).str();
     }
 
     Index += Size;
   }
 }
 
 // Create an MCSymbolizer for the target and add it to the MCDisassembler.
 // This is currently only used on AMDGPU, and assumes the format of the