LLVM 19.0.0git
MCInstPrinter.cpp
Go to the documentation of this file.
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
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"
18#include "llvm/Support/Format.h"
20#include <cinttypes>
21#include <cstdint>
22
23using namespace llvm;
24
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
39
40/// getOpcodeName - Return the name of the specified opcode enum (e.g.
41/// "MOV32ri") or empty if we can't resolve it.
43 return MII.getName(Opcode);
44}
45
47 llvm_unreachable("Target should implement this");
48}
49
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
63static 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.
70 return STI->getFeatureBits().test(C.Value);
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 }
81 OrPredicateResult |= !(STI->getFeatureBits().test(C.Value));
82 return true;
83 }
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) {
97 // Operand must be a specific immediate.
98 return Opnd.isImm() && Opnd.getImm() == int32_t(C.Value);
100 // Operand must be a specific register.
101 return Opnd.isReg() && Opnd.getReg() == C.Value;
103 // Operand must match the register of another operand.
104 return Opnd.isReg() && Opnd.getReg() == MI.getOperand(C.Value).getReg();
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());
109 // Operand must match some custom criteria.
110 return M.ValidateMCOperand(Opnd, *STI, C.Value);
112 // Operand can be anything.
113 return true;
119 llvm_unreachable("handled earlier");
120 }
121 llvm_unreachable("invalid kind");
122}
123
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.
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// For asm-style hex (e.g. 0ffh) the first digit always has to be a number.
175{
176 while (Value)
177 {
178 uint64_t digit = (Value >> 60) & 0xf;
179 if (digit != 0)
180 return (digit >= 0xa);
181 Value <<= 4;
182 }
183 return false;
184}
185
187 return format("%" PRId64, Value);
188}
189
191 switch (PrintHexStyle) {
192 case HexStyle::C:
193 if (Value < 0) {
194 if (Value == std::numeric_limits<int64_t>::min())
195 return format<int64_t>("-0x8000000000000000", Value);
196 return format("-0x%" PRIx64, -Value);
197 }
198 return format("0x%" PRIx64, Value);
199 case HexStyle::Asm:
200 if (Value < 0) {
201 if (Value == std::numeric_limits<int64_t>::min())
202 return format<int64_t>("-8000000000000000h", Value);
204 return format("-0%" PRIx64 "h", -Value);
205 return format("-%" PRIx64 "h", -Value);
206 }
208 return format("0%" PRIx64 "h", Value);
209 return format("%" PRIx64 "h", Value);
210 }
211 llvm_unreachable("unsupported print style");
212}
213
215 switch(PrintHexStyle) {
216 case HexStyle::C:
217 return format("0x%" PRIx64, Value);
218 case HexStyle::Asm:
220 return format("0%" PRIx64 "h", Value);
221 else
222 return format("%" PRIx64 "h", Value);
223 }
224 llvm_unreachable("unsupported print style");
225}
226
228 Markup S) const {
229 return WithMarkup(OS, S, getUseMarkup(), getUseColor());
230}
231
233 bool EnableMarkup, bool EnableColor)
234 : OS(OS), EnableMarkup(EnableMarkup), EnableColor(EnableColor) {
235 if (EnableColor) {
236 switch (M) {
239 break;
240 case Markup::Register:
242 break;
243 case Markup::Target:
245 break;
246 case Markup::Memory:
248 break;
249 }
250 }
251
252 if (EnableMarkup) {
253 switch (M) {
255 OS << "<imm:";
256 break;
257 case Markup::Register:
258 OS << "<reg:";
259 break;
260 case Markup::Target:
261 OS << "<target:";
262 break;
263 case Markup::Memory:
264 OS << "<mem:";
265 break;
266 }
267 }
268}
269
271 if (EnableMarkup)
272 OS << '>';
273 if (EnableColor)
274 OS.resetColor();
275}
unsigned const MachineRegisterInfo * MRI
IRTranslator LLVM IR MI
static bool needsLeadingZero(uint64_t Value)
static bool matchAliasCondition(const MCInst &MI, const MCSubtargetInfo *STI, const MCRegisterInfo &MRI, unsigned &OpIdx, const AliasMatchingData &M, const AliasPatternCond &C, bool &OrPredicateResult)
#define P(N)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
constexpr bool test(unsigned I) const
StringRef getCommentString() const
Definition: MCAsmInfo.h:651
LLVM_CTOR_NODISCARD WithMarkup(raw_ostream &OS, Markup M, bool EnableMarkup, bool EnableColor)
format_object< int64_t > formatHex(int64_t Value) const
bool getUseColor() const
const MCInstrInfo & MII
Definition: MCInstPrinter.h:52
raw_ostream * CommentStream
A stream that comments can be emitted to if desired.
Definition: MCInstPrinter.h:50
virtual ~MCInstPrinter()
virtual void printRegName(raw_ostream &OS, MCRegister Reg) const
Print the assembler register name.
WithMarkup markup(raw_ostream &OS, Markup M) const
StringRef getOpcodeName(unsigned Opcode) const
Return the name of the specified opcode enum (e.g.
format_object< int64_t > formatDec(int64_t Value) const
Utility functions to print decimal/hexadecimal values.
const MCRegisterInfo & MRI
Definition: MCInstPrinter.h:53
void printAnnotation(raw_ostream &OS, StringRef Annot)
Utility function for printing annotations.
const MCAsmInfo & MAI
Definition: MCInstPrinter.h:51
bool getUseMarkup() const
const char * matchAliasPatterns(const MCInst *MI, const MCSubtargetInfo *STI, const AliasMatchingData &M)
Helper for matching MCInsts to alias patterns when printing instructions.
HexStyle::Style PrintHexStyle
Which style to use for printing hexadecimal values.
Definition: MCInstPrinter.h:69
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
StringRef getName(unsigned Opcode) const
Returns the name for the instructions with the given opcode.
Definition: MCInstrInfo.h:70
Instances of this class represent operands of the MCInst class.
Definition: MCInst.h:36
int64_t getImm() const
Definition: MCInst.h:80
bool isImm() const
Definition: MCInst.h:62
unsigned getReg() const
Returns the register number.
Definition: MCInst.h:69
bool isReg() const
Definition: MCInst.h:61
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
Wrapper class representing physical registers. Should be passed by value.
Definition: MCRegister.h:33
Generic base class for all target subtargets.
const FeatureBitset & getFeatureBits() const
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
LLVM Value Representation.
Definition: Value.h:74
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
static constexpr Colors YELLOW
Definition: raw_ostream.h:120
static constexpr Colors CYAN
Definition: raw_ostream.h:123
virtual raw_ostream & changeColor(enum Colors Color, bool Bold=false, bool BG=false)
Changes the foreground color of text that will be output from this point forward.
virtual raw_ostream & resetColor()
Resets the colors to terminal defaults.
static constexpr Colors GREEN
Definition: raw_ostream.h:119
static constexpr Colors RED
Definition: raw_ostream.h:118
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1731
void dumpBytes(ArrayRef< uint8_t > Bytes, raw_ostream &OS)
Convert ‘Bytes’ to a hex string and output to ‘OS’.
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:125
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
auto lower_bound(R &&Range, T &&Value)
Provide wrappers to std::lower_bound which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1963
Tablegenerated data structures needed to match alias patterns.
Data for each alias pattern.
Map from opcode to pattern list by binary search.