From 9c47d494f8d1a53918eed5ad1a3f0163af8106f5 Mon Sep 17 00:00:00 2001 From: diggerlin Date: Fri, 29 May 2020 11:08:51 -0400 Subject: [PATCH] [AIX][XCOFF] add symbol priority for the llvm-objdump -D -symbol-description SUMMARY: when there are two symbol has the same address. llvm-objdump -D -symbol-description will select symbol based on the following rule: 1. using Label first if there is a Label symbol. 2. If there is not Label, using a symbol which has Storage Mapping class. 3. if more than one symbol has storage mapping class, put the TC0 has the low priority, for other storage mapping class , compare based on the value. Reviewers: James Henderson ,hubert.reinterpretcast, Differential Revision: https://reviews.llvm.org/D78387 --- .../llvm/MC/MCDisassembler/MCDisassembler.h | 9 ++-- lib/MC/MCDisassembler/MCDisassembler.cpp | 53 +++++++++++++++++++ .../XCOFF/disassemble-symbol-description.test | 2 +- unittests/MC/CMakeLists.txt | 1 + unittests/MC/MCDisassemblerTest.cpp | 49 +++++++++++++++++ 5 files changed, 110 insertions(+), 4 deletions(-) create mode 100644 unittests/MC/MCDisassemblerTest.cpp diff --git a/include/llvm/MC/MCDisassembler/MCDisassembler.h b/include/llvm/MC/MCDisassembler/MCDisassembler.h index 2d7efc8acc2..cddf325994f 100644 --- a/include/llvm/MC/MCDisassembler/MCDisassembler.h +++ b/include/llvm/MC/MCDisassembler/MCDisassembler.h @@ -26,6 +26,8 @@ struct XCOFFSymbolInfo { XCOFFSymbolInfo(Optional Smc, Optional Idx, bool Label) : StorageMappingClass(Smc), Index(Idx), IsLabel(Label) {} + + bool operator<(const XCOFFSymbolInfo &SymInfo) const; }; struct SymbolInfoTy { @@ -53,9 +55,10 @@ private: assert(P1.IsXCOFF == P2.IsXCOFF && "P1.IsXCOFF should be equal to P2.IsXCOFF."); if (P1.IsXCOFF) - return std::tie(P1.Addr, P1.Name) < std::tie(P2.Addr, P2.Name); - else - return std::tie(P1.Addr, P1.Name, P1.Type) < + return std::tie(P1.Addr, P1.XCOFFSymInfo, P1.Name) < + std::tie(P2.Addr, P2.XCOFFSymInfo, P2.Name); + + return std::tie(P1.Addr, P1.Name, P1.Type) < std::tie(P2.Addr, P2.Name, P2.Type); } }; diff --git a/lib/MC/MCDisassembler/MCDisassembler.cpp b/lib/MC/MCDisassembler/MCDisassembler.cpp index 373916fbed7..40ffd1fc5b7 100644 --- a/lib/MC/MCDisassembler/MCDisassembler.cpp +++ b/lib/MC/MCDisassembler/MCDisassembler.cpp @@ -43,3 +43,56 @@ void MCDisassembler::tryAddingPcLoadReferenceComment(int64_t Value, void MCDisassembler::setSymbolizer(std::unique_ptr Symzer) { Symbolizer = std::move(Symzer); } + +#define SMC_PCASE(A, P) \ + case XCOFF::XMC_##A: \ + return P; + +uint8_t getSMCPriority(XCOFF::StorageMappingClass SMC) { + switch (SMC) { + SMC_PCASE(PR, 1) + SMC_PCASE(RO, 1) + SMC_PCASE(DB, 1) + SMC_PCASE(GL, 1) + SMC_PCASE(XO, 1) + SMC_PCASE(SV, 1) + SMC_PCASE(SV64, 1) + SMC_PCASE(SV3264, 1) + SMC_PCASE(TI, 1) + SMC_PCASE(TB, 1) + SMC_PCASE(RW, 1) + SMC_PCASE(TC0, 0) + SMC_PCASE(TC, 1) + SMC_PCASE(TD, 1) + SMC_PCASE(DS, 1) + SMC_PCASE(UA, 1) + SMC_PCASE(BS, 1) + SMC_PCASE(UC, 1) + SMC_PCASE(TL, 1) + SMC_PCASE(UL, 1) + SMC_PCASE(TE, 1) +#undef SMC_PCASE + } + return 0; +} + +/// The function is for symbol sorting when symbols have the same address. +/// The symbols in the same section are sorted in ascending order. +/// llvm-objdump -D will choose the highest priority symbol to display when +/// there are symbols with the same address. +bool XCOFFSymbolInfo::operator<(const XCOFFSymbolInfo &SymInfo) const { + // Label symbols have higher priority than non-label symbols. + if (IsLabel != SymInfo.IsLabel) + return SymInfo.IsLabel; + + // Symbols with a StorageMappingClass have higher priority than those without. + if (StorageMappingClass.hasValue() != SymInfo.StorageMappingClass.hasValue()) + return SymInfo.StorageMappingClass.hasValue(); + + if (StorageMappingClass.hasValue()) { + return getSMCPriority(StorageMappingClass.getValue()) < + getSMCPriority(SymInfo.StorageMappingClass.getValue()); + } + + return false; +} diff --git a/test/tools/llvm-objdump/XCOFF/disassemble-symbol-description.test b/test/tools/llvm-objdump/XCOFF/disassemble-symbol-description.test index c92772b8cba..71c5958fa91 100644 --- a/test/tools/llvm-objdump/XCOFF/disassemble-symbol-description.test +++ b/test/tools/llvm-objdump/XCOFF/disassemble-symbol-description.test @@ -25,7 +25,7 @@ COMMON: Inputs/xcoff-section-headers.o: file format aixcoff-rs6000 COMMON: Disassembly of section .text: PLAIN: 00000000 <.text>: -DESC: 00000000 (idx: 4) .text: +DESC: 00000000 (idx: 16) .func: COMMON-NEXT: 0: 80 62 00 04 lwz 3, 4(2) RELOC: 00000002: R_TOC (idx: 26) a[TC] COMMON-NEXT: 4: 80 63 00 00 lwz 3, 0(3) diff --git a/unittests/MC/CMakeLists.txt b/unittests/MC/CMakeLists.txt index 48c06183ab9..3827a2b4fc4 100644 --- a/unittests/MC/CMakeLists.txt +++ b/unittests/MC/CMakeLists.txt @@ -17,5 +17,6 @@ add_llvm_unittest(MCTests MCInstPrinter.cpp StringTableBuilderTest.cpp TargetRegistry.cpp + MCDisassemblerTest.cpp ) diff --git a/unittests/MC/MCDisassemblerTest.cpp b/unittests/MC/MCDisassemblerTest.cpp new file mode 100644 index 00000000000..07d13cfa24c --- /dev/null +++ b/unittests/MC/MCDisassemblerTest.cpp @@ -0,0 +1,49 @@ +//===- MCDisassemblerTest.cpp - Tests for MCDisassembler.cpp --------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +#include "llvm/MC/MCDisassembler/MCDisassembler.h" +#include "gtest/gtest.h" + +using namespace llvm; + +TEST(MCDisassembler, XCOFFSymbolPriorityTest) { + + SymbolInfoTy SIT1(0x100000, "sym1", None, 1, false); + SymbolInfoTy SIT2(0x110000, "sym2", None, 2, false); + SymbolInfoTy SIT3(0x120000, ".func", XCOFF::XMC_PR, 3, true); + SymbolInfoTy SIT4(0x120000, ".text", XCOFF::XMC_PR, 4, false); + SymbolInfoTy SIT5(0x130000, "TOC", XCOFF::XMC_TC0, 5, false); + SymbolInfoTy SIT6(0x130000, "func", XCOFF::XMC_TC, 6, false); + + // Test that higher addresses would appear later than lower ones when symbols + // are sorted in ascending order. + EXPECT_TRUE(SIT1 < SIT2); + EXPECT_FALSE(SIT2 < SIT1); + + // Test that symbols with a StorageMappingClass have higher priority than those + // without. + EXPECT_TRUE(SIT2 < SIT5); + EXPECT_FALSE(SIT5 < SIT2); + + // Test that symbols with a TC0 StorageMappingClass have lower priority than those + // with some other StorageMappingClass. + EXPECT_TRUE(SIT5 < SIT6); + EXPECT_FALSE(SIT6 < SIT5); + + // Test label symbols have higher priorty than non-label symbols. + EXPECT_TRUE(SIT4 < SIT3); + EXPECT_FALSE(SIT3 < SIT4); + + // Test symbols comparing with themselves. + EXPECT_FALSE(SIT1 < SIT1); + EXPECT_FALSE(SIT2 < SIT2); + EXPECT_FALSE(SIT3 < SIT3); + EXPECT_FALSE(SIT4 < SIT4); + EXPECT_FALSE(SIT5 < SIT5); + EXPECT_FALSE(SIT6 < SIT6); +}