llvm/lib/MC/MCDisassembler/MCDisassembler.cpp

   1 //===- MCDisassembler.cpp - Disassembler interface ------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
  10 #include "llvm/ADT/ArrayRef.h"
  11
  12 using namespace llvm;
  13
  14 MCDisassembler::~MCDisassembler() = default;
  15
  16 Expected<bool> MCDisassembler::onSymbolStart(SymbolInfoTy &Symbol,
  17                                              uint64_t &Size,
  18                                              ArrayRef<uint8_t> Bytes,
  19                                              uint64_t Address) const {
  20   return false;
  21 }
  22
  23 uint64_t MCDisassembler::suggestBytesToSkip(ArrayRef<uint8_t> Bytes,
  24                                             uint64_t Address) const {
  25   return 1;
  26 }
  27
  28 bool MCDisassembler::tryAddingSymbolicOperand(MCInst &Inst, int64_t Value,
  29                                               uint64_t Address, bool IsBranch,
  30                                               uint64_t Offset, uint64_t OpSize,
  31                                               uint64_t InstSize) const {
  32   if (Symbolizer)
  33     return Symbolizer->tryAddingSymbolicOperand(Inst, *CommentStream, Value,
  34                                                 Address, IsBranch, Offset,
  35                                                 OpSize, InstSize);
  36   return false;
  37 }
  38
  39 void MCDisassembler::tryAddingPcLoadReferenceComment(int64_t Value,
  40                                                      uint64_t Address) const {
  41   if (Symbolizer)
  42     Symbolizer->tryAddingPcLoadReferenceComment(*CommentStream, Value, Address);
  43 }
  44
  45 void MCDisassembler::setSymbolizer(std::unique_ptr<MCSymbolizer> Symzer) {
  46   Symbolizer = std::move(Symzer);
  47 }
  48
  49 #define SMC_PCASE(A, P)                                                         \
  50   case XCOFF::XMC_##A:                                                         \
  51     return P;
  52
  53 static uint8_t getSMCPriority(XCOFF::StorageMappingClass SMC) {
  54   switch (SMC) {
  55     SMC_PCASE(PR, 1)
  56     SMC_PCASE(RO, 1)
  57     SMC_PCASE(DB, 1)
  58     SMC_PCASE(GL, 1)
  59     SMC_PCASE(XO, 1)
  60     SMC_PCASE(SV, 1)
  61     SMC_PCASE(SV64, 1)
  62     SMC_PCASE(SV3264, 1)
  63     SMC_PCASE(TI, 1)
  64     SMC_PCASE(TB, 1)
  65     SMC_PCASE(RW, 1)
  66     SMC_PCASE(TC0, 0)
  67     SMC_PCASE(TC, 1)
  68     SMC_PCASE(TD, 1)
  69     SMC_PCASE(DS, 1)
  70     SMC_PCASE(UA, 1)
  71     SMC_PCASE(BS, 1)
  72     SMC_PCASE(UC, 1)
  73     SMC_PCASE(TL, 1)
  74     SMC_PCASE(UL, 1)
  75     SMC_PCASE(TE, 1)
  76 #undef SMC_PCASE
  77   }
  78   return 0;
  79 }
  80
  81 /// The function is for symbol sorting when symbols have the same address.
  82 /// The symbols in the same section are sorted in ascending order.
  83 /// llvm-objdump -D will choose the highest priority symbol to display when
  84 /// there are symbols with the same address.
  85 bool XCOFFSymbolInfoTy::operator<(const XCOFFSymbolInfoTy &SymInfo) const {
  86   // Label symbols have higher priority than non-label symbols.
  87   if (IsLabel != SymInfo.IsLabel)
  88     return SymInfo.IsLabel;
  89
  90   // Symbols with a StorageMappingClass have higher priority than those without.
  91   if (StorageMappingClass.has_value() !=
  92       SymInfo.StorageMappingClass.has_value())
  93     return SymInfo.StorageMappingClass.has_value();
  94
  95   if (StorageMappingClass) {
  96     return getSMCPriority(*StorageMappingClass) <
  97            getSMCPriority(*SymInfo.StorageMappingClass);
  98   }
  99
 100   return false;
 101 }