llvm/lib/MC/MCInstPrinter.cpp

   1 //===- MCInstPrinter.cpp - Convert an MCInst to target assembly syntax ----===//
   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/MCInstPrinter.h"
  10 #include "llvm/ADT/ArrayRef.h"
  11 #include "llvm/ADT/StringRef.h"
  12 #include "llvm/MC/MCAsmInfo.h"
  13 #include "llvm/MC/MCInst.h"
  14 #include "llvm/MC/MCInstrInfo.h"
  15 #include "llvm/MC/MCSubtargetInfo.h"
  16 #include "llvm/Support/ErrorHandling.h"
  17 #include "llvm/Support/Format.h"
  18 #include "llvm/Support/raw_ostream.h"
  19 #include <cinttypes>
  20 #include <cstdint>
  21
  22 using namespace llvm;
  23
  24 void llvm::dumpBytes(ArrayRef<uint8_t> bytes, raw_ostream &OS) {
  25   static const char hex_rep[] = "0123456789abcdef";
  26   bool First = true;
  27   for (char i: bytes) {
  28     if (First)
  29       First = false;
  30     else
  31       OS << ' ';
  32     OS << hex_rep[(i & 0xF0) >> 4];
  33     OS << hex_rep[i & 0xF];
  34   }
  35 }
  36
  37 MCInstPrinter::~MCInstPrinter() = default;
  38
  39 /// getOpcodeName - Return the name of the specified opcode enum (e.g.
  40 /// "MOV32ri") or empty if we can't resolve it.
  41 StringRef MCInstPrinter::getOpcodeName(unsigned Opcode) const {
  42   return MII.getName(Opcode);
  43 }
  44
  45 void MCInstPrinter::printRegName(raw_ostream &OS, unsigned RegNo) const {
  46   llvm_unreachable("Target should implement this");
  47 }
  48
  49 void MCInstPrinter::printAnnotation(raw_ostream &OS, StringRef Annot) {
  50   if (!Annot.empty()) {
  51     if (CommentStream) {
  52       (*CommentStream) << Annot;
  53       // By definition (see MCInstPrinter.h), CommentStream must end with
  54       // a newline after each comment.
  55       if (Annot.back() != '\n')
  56         (*CommentStream) << '\n';
  57     } else
  58       OS << " " << MAI.getCommentString() << " " << Annot;
  59   }
  60 }
  61
  62 static bool matchAliasCondition(const MCInst &MI, const MCSubtargetInfo *STI,
  63                                 const MCRegisterInfo &MRI, unsigned &OpIdx,
  64                                 const AliasMatchingData &M,
  65                                 const AliasPatternCond &C,
  66                                 bool &OrPredicateResult) {
  67   // Feature tests are special, they don't consume operands.
  68   if (C.Kind == AliasPatternCond::K_Feature)
  69     return STI->getFeatureBits().test(C.Value);
  70   if (C.Kind == AliasPatternCond::K_NegFeature)
  71     return !STI->getFeatureBits().test(C.Value);
  72   // For feature tests where just one feature is required in a list, set the
  73   // predicate result bit to whether the expression will return true, and only
  74   // return the real result at the end of list marker.
  75   if (C.Kind == AliasPatternCond::K_OrFeature) {
  76     OrPredicateResult |= STI->getFeatureBits().test(C.Value);
  77     return true;
  78   }
  79   if (C.Kind == AliasPatternCond::K_OrNegFeature) {
  80     OrPredicateResult |= !(STI->getFeatureBits().test(C.Value));
  81     return true;
  82   }
  83   if (C.Kind == AliasPatternCond::K_EndOrFeatures) {
  84     bool Res = OrPredicateResult;
  85     OrPredicateResult = false;
  86     return Res;
  87   }
  88
  89   // Get and consume an operand.
  90   const MCOperand &Opnd = MI.getOperand(OpIdx);
  91   ++OpIdx;
  92
  93   // Check the specific condition for the operand.
  94   switch (C.Kind) {
  95   case AliasPatternCond::K_Imm:
  96     // Operand must be a specific immediate.
  97     return Opnd.isImm() && Opnd.getImm() == int32_t(C.Value);
  98   case AliasPatternCond::K_Reg:
  99     // Operand must be a specific register.
 100     return Opnd.isReg() && Opnd.getReg() == C.Value;
 101   case AliasPatternCond::K_TiedReg:
 102     // Operand must match the register of another operand.
 103     return Opnd.isReg() && Opnd.getReg() == MI.getOperand(C.Value).getReg();
 104   case AliasPatternCond::K_RegClass:
 105     // Operand must be a register in this class. Value is a register class id.
 106     return Opnd.isReg() && MRI.getRegClass(C.Value).contains(Opnd.getReg());
 107   case AliasPatternCond::K_Custom:
 108     // Operand must match some custom criteria.
 109     return M.ValidateMCOperand(Opnd, *STI, C.Value);
 110   case AliasPatternCond::K_Ignore:
 111     // Operand can be anything.
 112     return true;
 113   case AliasPatternCond::K_Feature:
 114   case AliasPatternCond::K_NegFeature:
 115   case AliasPatternCond::K_OrFeature:
 116   case AliasPatternCond::K_OrNegFeature:
 117   case AliasPatternCond::K_EndOrFeatures:
 118     llvm_unreachable("handled earlier");
 119   }
 120   llvm_unreachable("invalid kind");
 121 }
 122
 123 const char *MCInstPrinter::matchAliasPatterns(const MCInst *MI,
 124                                               const MCSubtargetInfo *STI,
 125                                               const AliasMatchingData &M) {
 126   // Binary search by opcode. Return false if there are no aliases for this
 127   // opcode.
 128   auto It = lower_bound(M.OpToPatterns, MI->getOpcode(),
 129                         [](const PatternsForOpcode &L, unsigned Opcode) {
 130                           return L.Opcode < Opcode;
 131                         });
 132   if (It == M.OpToPatterns.end() || It->Opcode != MI->getOpcode())
 133     return nullptr;
 134
 135   // Try all patterns for this opcode.
 136   uint32_t AsmStrOffset = ~0U;
 137   ArrayRef<AliasPattern> Patterns =
 138       M.Patterns.slice(It->PatternStart, It->NumPatterns);
 139   for (const AliasPattern &P : Patterns) {
 140     // Check operand count first.
 141     if (MI->getNumOperands() != P.NumOperands)
 142       return nullptr;
 143
 144     // Test all conditions for this pattern.
 145     ArrayRef<AliasPatternCond> Conds =
 146         M.PatternConds.slice(P.AliasCondStart, P.NumConds);
 147     unsigned OpIdx = 0;
 148     bool OrPredicateResult = false;
 149     if (llvm::all_of(Conds, [&](const AliasPatternCond &C) {
 150           return matchAliasCondition(*MI, STI, MRI, OpIdx, M, C,
 151                                      OrPredicateResult);
 152         })) {
 153       // If all conditions matched, use this asm string.
 154       AsmStrOffset = P.AsmStrOffset;
 155       break;
 156     }
 157   }
 158
 159   // If no alias matched, don't print an alias.
 160   if (AsmStrOffset == ~0U)
 161     return nullptr;
 162
 163   // Go to offset AsmStrOffset and use the null terminated string there. The
 164   // offset should point to the beginning of an alias string, so it should
 165   // either be zero or be preceded by a null byte.
 166   assert(AsmStrOffset < M.AsmStrings.size() &&
 167          (AsmStrOffset == 0 || M.AsmStrings[AsmStrOffset - 1] == '\0') &&
 168          "bad asm string offset");
 169   return M.AsmStrings.data() + AsmStrOffset;
 170 }
 171
 172 /// Utility functions to make adding mark ups simpler.
 173 StringRef MCInstPrinter::markup(StringRef s) const {
 174   if (getUseMarkup())
 175     return s;
 176   else
 177     return "";
 178 }
 179
 180 // For asm-style hex (e.g. 0ffh) the first digit always has to be a number.
 181 static bool needsLeadingZero(uint64_t Value)
 182 {
 183   while (Value)
 184   {
 185     uint64_t digit = (Value >> 60) & 0xf;
 186     if (digit != 0)
 187       return (digit >= 0xa);
 188     Value <<= 4;
 189   }
 190   return false;
 191 }
 192
 193 format_object<int64_t> MCInstPrinter::formatDec(int64_t Value) const {
 194   return format("%" PRId64, Value);
 195 }
 196
 197 format_object<int64_t> MCInstPrinter::formatHex(int64_t Value) const {
 198   switch (PrintHexStyle) {
 199   case HexStyle::C:
 200     if (Value < 0) {
 201       if (Value == std::numeric_limits<int64_t>::min())
 202         return format<int64_t>("-0x8000000000000000", Value);
 203       return format("-0x%" PRIx64, -Value);
 204     }
 205     return format("0x%" PRIx64, Value);
 206   case HexStyle::Asm:
 207     if (Value < 0) {
 208       if (Value == std::numeric_limits<int64_t>::min())
 209         return format<int64_t>("-8000000000000000h", Value);
 210       if (needsLeadingZero(-(uint64_t)(Value)))
 211         return format("-0%" PRIx64 "h", -Value);
 212       return format("-%" PRIx64 "h", -Value);
 213     }
 214     if (needsLeadingZero((uint64_t)(Value)))
 215       return format("0%" PRIx64 "h", Value);
 216     return format("%" PRIx64 "h", Value);
 217   }
 218   llvm_unreachable("unsupported print style");
 219 }
 220
 221 format_object<uint64_t> MCInstPrinter::formatHex(uint64_t Value) const {
 222   switch(PrintHexStyle) {
 223   case HexStyle::C:
 224      return format("0x%" PRIx64, Value);
 225   case HexStyle::Asm:
 226     if (needsLeadingZero(Value))
 227       return format("0%" PRIx64 "h", Value);
 228     else
 229       return format("%" PRIx64 "h", Value);
 230   }
 231   llvm_unreachable("unsupported print style");
 232 }