MCInstPrinter.cpp Source File (original) (raw)

20#include

21#include

23using namespace llvm;

26 static const char hex_rep[] = "0123456789abcdef";

27 bool First = true;

28 for (char i: bytes) {

31 else

32 OS << ' ';

33 OS << hex_rep[(i & 0xF0) >> 4];

34 OS << hex_rep[i & 0xF];

35 }

36}

44}

48}

51 if (!Annot.empty()) {

53 (*CommentStream) << Annot;

56 if (Annot.back() != '\n')

57 (*CommentStream) << '\n';

58 } else

60 }

61}

67 bool &OrPredicateResult) {

78 return true;

79 }

82 return true;

83 }

85 bool Res = OrPredicateResult;

86 OrPredicateResult = false;

87 return Res;

88 }

91 const MCOperand &Opnd = MI.getOperand(OpIdx);

92 ++OpIdx;

95 switch (C.Kind) {

98 return Opnd.isImm() && Opnd.getImm() == int32_t(C.Value);

100

101 return Opnd.isReg() && Opnd.getReg() == C.Value;

103

104 return Opnd.isReg() && Opnd.getReg() == MI.getOperand(C.Value).getReg();

106

107 return Opnd.isReg() && MRI.getRegClass(C.Value).contains(Opnd.getReg());

109

110 return M.ValidateMCOperand(Opnd, *STI, C.Value);

112

113 return true;

120 }

122}

123

127

128

129 auto It = lower_bound(M.OpToPatterns, MI->getOpcode(),

131 return L.Opcode < Opcode;

132 });

133 if (It == M.OpToPatterns.end() || It->Opcode != MI->getOpcode())

134 return nullptr;

135

136

139 M.Patterns.slice(It->PatternStart, It->NumPatterns);

141

142 if (MI->getNumOperands() != P.NumOperands)

143 return nullptr;

144

145

147 M.PatternConds.slice(P.AliasCondStart, P.NumConds);

148 unsigned OpIdx = 0;

149 bool OrPredicateResult = false;

152 OrPredicateResult);

153 })) {

154

155 AsmStrOffset = P.AsmStrOffset;

156 break;

157 }

158 }

159

160

161 if (AsmStrOffset == ~0U)

162 return nullptr;

163

164

165

166

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

175{

177 {

179 if (digit != 0)

180 return (digit >= 0xa);

182 }

183 return false;

184}

185

188}

189

194 if (Value == std::numeric_limits<int64_t>::min())

195 return format<int64_t>("-0x8000000000000000", Value);

197 }

201 if (Value == std::numeric_limits<int64_t>::min())

202 return format<int64_t>("-8000000000000000h", Value);

206 }

210 }

212}

213

221 else

223 }

225}

226

229}

230

232 Markup M, bool EnableMarkup,

233 bool EnableColor)

234 : IP(IP), OS(OS), EnableMarkup(EnableMarkup), EnableColor(EnableColor) {

235 if (EnableColor) {

237 switch (M) {

240 break;

243 break;

246 break;

249 break;

250 }

253 }

254

255 if (EnableMarkup) {

256 switch (M) {

258 OS << "<imm:";

259 break;

261 OS << "<reg:";

262 break;

264 OS << "<target:";

265 break;

267 OS << "<mem:";

268 break;

269 }

270 }

271}

272

274 if (EnableMarkup)

275 OS << '>';

276 if (!EnableColor)

277 return;

278 IP.ColorStack.pop_back();

279 OS << IP.ColorStack.back();

280}

unsigned const MachineRegisterInfo * MRI

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)

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

constexpr bool test(unsigned I) const

StringRef getCommentString() const

LLVM_CTOR_NODISCARD WithMarkup(MCInstPrinter &IP, raw_ostream &OS, Markup M, bool EnableMarkup, bool EnableColor)

This is an instance of a target assembly language printer that converts an MCInst to valid target ass...

WithMarkup markup(raw_ostream &OS, Markup M)

format_object< int64_t > formatHex(int64_t Value) const

raw_ostream * CommentStream

A stream that comments can be emitted to if desired.

StringRef getOpcodeName(unsigned Opcode) const

Return the name of the specified opcode enum (e.g.

SmallVector< raw_ostream::Colors, 4 > ColorStack

format_object< int64_t > formatDec(int64_t Value) const

Utility functions to print decimal/hexadecimal values.

const MCRegisterInfo & MRI

void printAnnotation(raw_ostream &OS, StringRef Annot)

Utility function for printing annotations.

bool getUseMarkup() const

virtual void printRegName(raw_ostream &OS, MCRegister Reg)

Print the assembler register name.

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.

Instances of this class represent a single low-level machine instruction.

StringRef getName(unsigned Opcode) const

Returns the name for the instructions with the given opcode.

Instances of this class represent operands of the MCInst class.

MCRegister getReg() const

Returns the register number.

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.

Generic base class for all target subtargets.

const FeatureBitset & getFeatureBits() const

void push_back(const T &Elt)

StringRef - Represent a constant reference to a string, i.e.

constexpr bool empty() const

empty - Check if the string is empty.

LLVM Value Representation.

This class implements an extremely fast bulk output stream that can only output to a stream.

static constexpr Colors YELLOW

static constexpr Colors CYAN

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.

static constexpr Colors GREEN

static constexpr Colors RED

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

@ C

The default llvm calling convention, compatible with C.

This is an optimization pass for GlobalISel generic memory operations.

bool all_of(R &&range, UnaryPredicate P)

Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.

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.

@ 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...

Tablegenerated data structures needed to match alias patterns.

Data for each alias pattern.

Map from opcode to pattern list by binary search.