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