1 //===------------ FixedLenDecoderEmitter.cpp - Decoder Generator ----------===//
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
7 //===----------------------------------------------------------------------===//
9 // It contains the tablegen backend that emits the decoder functions for
10 // targets with fixed length instruction set.
12 //===----------------------------------------------------------------------===//
14 #include "CodeGenInstruction.h"
15 #include "CodeGenTarget.h"
16 #include "InfoByHwMode.h"
17 #include "llvm/ADT/APInt.h"
18 #include "llvm/ADT/ArrayRef.h"
19 #include "llvm/ADT/CachedHashString.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/SetVector.h"
22 #include "llvm/ADT/SmallString.h"
23 #include "llvm/ADT/Statistic.h"
24 #include "llvm/ADT/StringExtras.h"
25 #include "llvm/ADT/StringRef.h"
26 #include "llvm/MC/MCFixedLenDisassembler.h"
27 #include "llvm/Support/Casting.h"
28 #include "llvm/Support/Debug.h"
29 #include "llvm/Support/ErrorHandling.h"
30 #include "llvm/Support/FormattedStream.h"
31 #include "llvm/Support/LEB128.h"
32 #include "llvm/Support/raw_ostream.h"
33 #include "llvm/TableGen/Error.h"
34 #include "llvm/TableGen/Record.h"
48 #define DEBUG_TYPE "decoder-emitter"
52 STATISTIC(NumEncodings, "Number of encodings considered");
53 STATISTIC(NumEncodingsLackingDisasm, "Number of encodings without disassembler info");
54 STATISTIC(NumInstructions, "Number of instructions considered");
55 STATISTIC(NumEncodingsSupported, "Number of encodings supported");
56 STATISTIC(NumEncodingsOmitted, "Number of encodings omitted");
58 struct EncodingField {
59 unsigned Base, Width, Offset;
60 EncodingField(unsigned B, unsigned W, unsigned O)
61 : Base(B), Width(W), Offset(O) { }
65 std::vector<EncodingField> Fields;
67 bool HasCompleteDecoder;
70 OperandInfo(std::string D, bool HCD)
71 : Decoder(std::move(D)), HasCompleteDecoder(HCD), InitValue(0) {}
73 void addField(unsigned Base, unsigned Width, unsigned Offset) {
74 Fields.push_back(EncodingField(Base, Width, Offset));
77 unsigned numFields() const { return Fields.size(); }
79 typedef std::vector<EncodingField>::const_iterator const_iterator;
81 const_iterator begin() const { return Fields.begin(); }
82 const_iterator end() const { return Fields.end(); }
85 typedef std::vector<uint8_t> DecoderTable;
86 typedef uint32_t DecoderFixup;
87 typedef std::vector<DecoderFixup> FixupList;
88 typedef std::vector<FixupList> FixupScopeList;
89 typedef SmallSetVector<CachedHashString, 16> PredicateSet;
90 typedef SmallSetVector<CachedHashString, 16> DecoderSet;
91 struct DecoderTableInfo {
93 FixupScopeList FixupStack;
94 PredicateSet Predicates;
98 struct EncodingAndInst {
99 const Record *EncodingDef;
100 const CodeGenInstruction *Inst;
101 StringRef HwModeName;
103 EncodingAndInst(const Record *EncodingDef, const CodeGenInstruction *Inst,
104 StringRef HwModeName = "")
105 : EncodingDef(EncodingDef), Inst(Inst), HwModeName(HwModeName) {}
108 struct EncodingIDAndOpcode {
112 EncodingIDAndOpcode() : EncodingID(0), Opcode(0) {}
113 EncodingIDAndOpcode(unsigned EncodingID, unsigned Opcode)
114 : EncodingID(EncodingID), Opcode(Opcode) {}
117 raw_ostream &operator<<(raw_ostream &OS, const EncodingAndInst &Value) {
118 if (Value.EncodingDef != Value.Inst->TheDef)
119 OS << Value.EncodingDef->getName() << ":";
120 OS << Value.Inst->TheDef->getName();
124 class FixedLenDecoderEmitter {
126 std::vector<EncodingAndInst> NumberedEncodings;
129 // Defaults preserved here for documentation, even though they aren't
130 // strictly necessary given the way that this is currently being called.
131 FixedLenDecoderEmitter(RecordKeeper &R, std::string PredicateNamespace,
132 std::string GPrefix = "if (",
133 std::string GPostfix = " == MCDisassembler::Fail)",
134 std::string ROK = "MCDisassembler::Success",
135 std::string RFail = "MCDisassembler::Fail",
137 : RK(R), Target(R), PredicateNamespace(std::move(PredicateNamespace)),
138 GuardPrefix(std::move(GPrefix)), GuardPostfix(std::move(GPostfix)),
139 ReturnOK(std::move(ROK)), ReturnFail(std::move(RFail)),
140 Locals(std::move(L)) {}
142 // Emit the decoder state machine table.
143 void emitTable(formatted_raw_ostream &o, DecoderTable &Table,
144 unsigned Indentation, unsigned BitWidth,
145 StringRef Namespace) const;
146 void emitPredicateFunction(formatted_raw_ostream &OS,
147 PredicateSet &Predicates,
148 unsigned Indentation) const;
149 void emitDecoderFunction(formatted_raw_ostream &OS,
150 DecoderSet &Decoders,
151 unsigned Indentation) const;
153 // run - Output the code emitter
154 void run(raw_ostream &o);
157 CodeGenTarget Target;
160 std::string PredicateNamespace;
161 std::string GuardPrefix, GuardPostfix;
162 std::string ReturnOK, ReturnFail;
166 } // end anonymous namespace
168 // The set (BIT_TRUE, BIT_FALSE, BIT_UNSET) represents a ternary logic system
171 // BIT_UNFILTERED is used as the init value for a filter position. It is used
172 // only for filter processings.
177 BIT_UNFILTERED // unfiltered
180 static bool ValueSet(bit_value_t V) {
181 return (V == BIT_TRUE || V == BIT_FALSE);
184 static bool ValueNotSet(bit_value_t V) {
185 return (V == BIT_UNSET);
188 static int Value(bit_value_t V) {
189 return ValueNotSet(V) ? -1 : (V == BIT_FALSE ? 0 : 1);
192 static bit_value_t bitFromBits(const BitsInit &bits, unsigned index) {
193 if (BitInit *bit = dyn_cast<BitInit>(bits.getBit(index)))
194 return bit->getValue() ? BIT_TRUE : BIT_FALSE;
196 // The bit is uninitialized.
200 // Prints the bit value for each position.
201 static void dumpBits(raw_ostream &o, const BitsInit &bits) {
202 for (unsigned index = bits.getNumBits(); index > 0; --index) {
203 switch (bitFromBits(bits, index - 1)) {
214 llvm_unreachable("unexpected return value from bitFromBits");
219 static BitsInit &getBitsField(const Record &def, StringRef str) {
220 BitsInit *bits = def.getValueAsBitsInit(str);
224 // Representation of the instruction to work on.
225 typedef std::vector<bit_value_t> insn_t;
231 /// Filter - Filter works with FilterChooser to produce the decoding tree for
234 /// It is useful to think of a Filter as governing the switch stmts of the
235 /// decoding tree in a certain level. Each case stmt delegates to an inferior
236 /// FilterChooser to decide what further decoding logic to employ, or in another
237 /// words, what other remaining bits to look at. The FilterChooser eventually
238 /// chooses a best Filter to do its job.
240 /// This recursive scheme ends when the number of Opcodes assigned to the
241 /// FilterChooser becomes 1 or if there is a conflict. A conflict happens when
242 /// the Filter/FilterChooser combo does not know how to distinguish among the
243 /// Opcodes assigned.
245 /// An example of a conflict is
248 /// 111101000.00........00010000....
249 /// 111101000.00........0001........
250 /// 1111010...00........0001........
251 /// 1111010...00....................
252 /// 1111010.........................
253 /// 1111............................
254 /// ................................
255 /// VST4q8a 111101000_00________00010000____
256 /// VST4q8b 111101000_00________00010000____
258 /// The Debug output shows the path that the decoding tree follows to reach the
259 /// the conclusion that there is a conflict. VST4q8a is a vst4 to double-spaced
260 /// even registers, while VST4q8b is a vst4 to double-spaced odd registers.
262 /// The encoding info in the .td files does not specify this meta information,
263 /// which could have been used by the decoder to resolve the conflict. The
264 /// decoder could try to decode the even/odd register numbering and assign to
265 /// VST4q8a or VST4q8b, but for the time being, the decoder chooses the "a"
266 /// version and return the Opcode since the two have the same Asm format string.
269 const FilterChooser *Owner;// points to the FilterChooser who owns this filter
270 unsigned StartBit; // the starting bit position
271 unsigned NumBits; // number of bits to filter
272 bool Mixed; // a mixed region contains both set and unset bits
274 // Map of well-known segment value to the set of uid's with that value.
275 std::map<uint64_t, std::vector<EncodingIDAndOpcode>>
276 FilteredInstructions;
278 // Set of uid's with non-constant segment values.
279 std::vector<EncodingIDAndOpcode> VariableInstructions;
281 // Map of well-known segment value to its delegate.
282 std::map<unsigned, std::unique_ptr<const FilterChooser>> FilterChooserMap;
284 // Number of instructions which fall under FilteredInstructions category.
285 unsigned NumFiltered;
287 // Keeps track of the last opcode in the filtered bucket.
288 EncodingIDAndOpcode LastOpcFiltered;
292 Filter(FilterChooser &owner, unsigned startBit, unsigned numBits, bool mixed);
296 unsigned getNumFiltered() const { return NumFiltered; }
298 EncodingIDAndOpcode getSingletonOpc() const {
299 assert(NumFiltered == 1);
300 return LastOpcFiltered;
303 // Return the filter chooser for the group of instructions without constant
305 const FilterChooser &getVariableFC() const {
306 assert(NumFiltered == 1);
307 assert(FilterChooserMap.size() == 1);
308 return *(FilterChooserMap.find((unsigned)-1)->second);
311 // Divides the decoding task into sub tasks and delegates them to the
312 // inferior FilterChooser's.
314 // A special case arises when there's only one entry in the filtered
315 // instructions. In order to unambiguously decode the singleton, we need to
316 // match the remaining undecoded encoding bits against the singleton.
319 // Emit table entries to decode instructions given a segment or segments of
321 void emitTableEntry(DecoderTableInfo &TableInfo) const;
323 // Returns the number of fanout produced by the filter. More fanout implies
324 // the filter distinguishes more categories of instructions.
325 unsigned usefulness() const;
326 }; // end class Filter
328 } // end anonymous namespace
330 // These are states of our finite state machines used in FilterChooser's
331 // filterProcessor() which produces the filter candidates to use.
340 /// FilterChooser - FilterChooser chooses the best filter among a set of Filters
341 /// in order to perform the decoding of instructions at the current level.
343 /// Decoding proceeds from the top down. Based on the well-known encoding bits
344 /// of instructions available, FilterChooser builds up the possible Filters that
345 /// can further the task of decoding by distinguishing among the remaining
346 /// candidate instructions.
348 /// Once a filter has been chosen, it is called upon to divide the decoding task
349 /// into sub-tasks and delegates them to its inferior FilterChoosers for further
352 /// It is useful to think of a Filter as governing the switch stmts of the
353 /// decoding tree. And each case is delegated to an inferior FilterChooser to
354 /// decide what further remaining bits to look at.
357 class FilterChooser {
361 // Vector of codegen instructions to choose our filter.
362 ArrayRef<EncodingAndInst> AllInstructions;
364 // Vector of uid's for this filter chooser to work on.
365 // The first member of the pair is the opcode id being decoded, the second is
366 // the opcode id that should be emitted.
367 const std::vector<EncodingIDAndOpcode> &Opcodes;
369 // Lookup table for the operand decoding of instructions.
370 const std::map<unsigned, std::vector<OperandInfo>> &Operands;
372 // Vector of candidate filters.
373 std::vector<Filter> Filters;
375 // Array of bit values passed down from our parent.
376 // Set to all BIT_UNFILTERED's for Parent == NULL.
377 std::vector<bit_value_t> FilterBitValues;
379 // Links to the FilterChooser above us in the decoding tree.
380 const FilterChooser *Parent;
382 // Index of the best filter from Filters.
385 // Width of instructions
389 const FixedLenDecoderEmitter *Emitter;
392 FilterChooser(ArrayRef<EncodingAndInst> Insts,
393 const std::vector<EncodingIDAndOpcode> &IDs,
394 const std::map<unsigned, std::vector<OperandInfo>> &Ops,
395 unsigned BW, const FixedLenDecoderEmitter *E)
396 : AllInstructions(Insts), Opcodes(IDs), Operands(Ops),
397 FilterBitValues(BW, BIT_UNFILTERED), Parent(nullptr), BestIndex(-1),
398 BitWidth(BW), Emitter(E) {
402 FilterChooser(ArrayRef<EncodingAndInst> Insts,
403 const std::vector<EncodingIDAndOpcode> &IDs,
404 const std::map<unsigned, std::vector<OperandInfo>> &Ops,
405 const std::vector<bit_value_t> &ParentFilterBitValues,
406 const FilterChooser &parent)
407 : AllInstructions(Insts), Opcodes(IDs), Operands(Ops),
408 FilterBitValues(ParentFilterBitValues), Parent(&parent), BestIndex(-1),
409 BitWidth(parent.BitWidth), Emitter(parent.Emitter) {
413 FilterChooser(const FilterChooser &) = delete;
414 void operator=(const FilterChooser &) = delete;
416 unsigned getBitWidth() const { return BitWidth; }
419 // Populates the insn given the uid.
420 void insnWithID(insn_t &Insn, unsigned Opcode) const {
421 BitsInit &Bits = getBitsField(*AllInstructions[Opcode].EncodingDef, "Inst");
423 // We may have a SoftFail bitmask, which specifies a mask where an encoding
424 // may differ from the value in "Inst" and yet still be valid, but the
425 // disassembler should return SoftFail instead of Success.
427 // This is used for marking UNPREDICTABLE instructions in the ARM world.
429 AllInstructions[Opcode].EncodingDef->getValueAsBitsInit("SoftFail");
431 for (unsigned i = 0; i < BitWidth; ++i) {
432 if (SFBits && bitFromBits(*SFBits, i) == BIT_TRUE)
433 Insn.push_back(BIT_UNSET);
435 Insn.push_back(bitFromBits(Bits, i));
439 // Emit the name of the encoding/instruction pair.
440 void emitNameWithID(raw_ostream &OS, unsigned Opcode) const {
441 const Record *EncodingDef = AllInstructions[Opcode].EncodingDef;
442 const Record *InstDef = AllInstructions[Opcode].Inst->TheDef;
443 if (EncodingDef != InstDef)
444 OS << EncodingDef->getName() << ":";
445 OS << InstDef->getName();
448 // Populates the field of the insn given the start position and the number of
449 // consecutive bits to scan for.
451 // Returns false if there exists any uninitialized bit value in the range.
452 // Returns true, otherwise.
453 bool fieldFromInsn(uint64_t &Field, insn_t &Insn, unsigned StartBit,
454 unsigned NumBits) const;
456 /// dumpFilterArray - dumpFilterArray prints out debugging info for the given
457 /// filter array as a series of chars.
458 void dumpFilterArray(raw_ostream &o,
459 const std::vector<bit_value_t> & filter) const;
461 /// dumpStack - dumpStack traverses the filter chooser chain and calls
462 /// dumpFilterArray on each filter chooser up to the top level one.
463 void dumpStack(raw_ostream &o, const char *prefix) const;
465 Filter &bestFilter() {
466 assert(BestIndex != -1 && "BestIndex not set");
467 return Filters[BestIndex];
470 bool PositionFiltered(unsigned i) const {
471 return ValueSet(FilterBitValues[i]);
474 // Calculates the island(s) needed to decode the instruction.
475 // This returns a lit of undecoded bits of an instructions, for example,
476 // Inst{20} = 1 && Inst{3-0} == 0b1111 represents two islands of yet-to-be
477 // decoded bits in order to verify that the instruction matches the Opcode.
478 unsigned getIslands(std::vector<unsigned> &StartBits,
479 std::vector<unsigned> &EndBits,
480 std::vector<uint64_t> &FieldVals,
481 const insn_t &Insn) const;
483 // Emits code to check the Predicates member of an instruction are true.
484 // Returns true if predicate matches were emitted, false otherwise.
485 bool emitPredicateMatch(raw_ostream &o, unsigned &Indentation,
488 bool doesOpcodeNeedPredicate(unsigned Opc) const;
489 unsigned getPredicateIndex(DecoderTableInfo &TableInfo, StringRef P) const;
490 void emitPredicateTableEntry(DecoderTableInfo &TableInfo,
493 void emitSoftFailTableEntry(DecoderTableInfo &TableInfo,
496 // Emits table entries to decode the singleton.
497 void emitSingletonTableEntry(DecoderTableInfo &TableInfo,
498 EncodingIDAndOpcode Opc) const;
500 // Emits code to decode the singleton, and then to decode the rest.
501 void emitSingletonTableEntry(DecoderTableInfo &TableInfo,
502 const Filter &Best) const;
504 void emitBinaryParser(raw_ostream &o, unsigned &Indentation,
505 const OperandInfo &OpInfo,
506 bool &OpHasCompleteDecoder) const;
508 void emitDecoder(raw_ostream &OS, unsigned Indentation, unsigned Opc,
509 bool &HasCompleteDecoder) const;
510 unsigned getDecoderIndex(DecoderSet &Decoders, unsigned Opc,
511 bool &HasCompleteDecoder) const;
513 // Assign a single filter and run with it.
514 void runSingleFilter(unsigned startBit, unsigned numBit, bool mixed);
516 // reportRegion is a helper function for filterProcessor to mark a region as
517 // eligible for use as a filter region.
518 void reportRegion(bitAttr_t RA, unsigned StartBit, unsigned BitIndex,
521 // FilterProcessor scans the well-known encoding bits of the instructions and
522 // builds up a list of candidate filters. It chooses the best filter and
523 // recursively descends down the decoding tree.
524 bool filterProcessor(bool AllowMixed, bool Greedy = true);
526 // Decides on the best configuration of filter(s) to use in order to decode
527 // the instructions. A conflict of instructions may occur, in which case we
528 // dump the conflict set to the standard error.
532 // emitTableEntries - Emit state machine entries to decode our share of
534 void emitTableEntries(DecoderTableInfo &TableInfo) const;
537 } // end anonymous namespace
539 ///////////////////////////
541 // Filter Implementation //
543 ///////////////////////////
545 Filter::Filter(Filter &&f)
546 : Owner(f.Owner), StartBit(f.StartBit), NumBits(f.NumBits), Mixed(f.Mixed),
547 FilteredInstructions(std::move(f.FilteredInstructions)),
548 VariableInstructions(std::move(f.VariableInstructions)),
549 FilterChooserMap(std::move(f.FilterChooserMap)), NumFiltered(f.NumFiltered),
550 LastOpcFiltered(f.LastOpcFiltered) {
553 Filter::Filter(FilterChooser &owner, unsigned startBit, unsigned numBits,
555 : Owner(&owner), StartBit(startBit), NumBits(numBits), Mixed(mixed) {
556 assert(StartBit + NumBits - 1 < Owner->BitWidth);
559 LastOpcFiltered = {0, 0};
561 for (unsigned i = 0, e = Owner->Opcodes.size(); i != e; ++i) {
564 // Populates the insn given the uid.
565 Owner->insnWithID(Insn, Owner->Opcodes[i].EncodingID);
568 // Scans the segment for possibly well-specified encoding bits.
569 bool ok = Owner->fieldFromInsn(Field, Insn, StartBit, NumBits);
572 // The encoding bits are well-known. Lets add the uid of the
573 // instruction into the bucket keyed off the constant field value.
574 LastOpcFiltered = Owner->Opcodes[i];
575 FilteredInstructions[Field].push_back(LastOpcFiltered);
578 // Some of the encoding bit(s) are unspecified. This contributes to
579 // one additional member of "Variable" instructions.
580 VariableInstructions.push_back(Owner->Opcodes[i]);
584 assert((FilteredInstructions.size() + VariableInstructions.size() > 0)
585 && "Filter returns no instruction categories");
588 // Divides the decoding task into sub tasks and delegates them to the
589 // inferior FilterChooser's.
591 // A special case arises when there's only one entry in the filtered
592 // instructions. In order to unambiguously decode the singleton, we need to
593 // match the remaining undecoded encoding bits against the singleton.
594 void Filter::recurse() {
595 // Starts by inheriting our parent filter chooser's filter bit values.
596 std::vector<bit_value_t> BitValueArray(Owner->FilterBitValues);
598 if (!VariableInstructions.empty()) {
599 // Conservatively marks each segment position as BIT_UNSET.
600 for (unsigned bitIndex = 0; bitIndex < NumBits; ++bitIndex)
601 BitValueArray[StartBit + bitIndex] = BIT_UNSET;
603 // Delegates to an inferior filter chooser for further processing on this
604 // group of instructions whose segment values are variable.
605 FilterChooserMap.insert(
606 std::make_pair(-1U, std::make_unique<FilterChooser>(
607 Owner->AllInstructions, VariableInstructions,
608 Owner->Operands, BitValueArray, *Owner)));
611 // No need to recurse for a singleton filtered instruction.
612 // See also Filter::emit*().
613 if (getNumFiltered() == 1) {
614 assert(FilterChooserMap.size() == 1);
618 // Otherwise, create sub choosers.
619 for (const auto &Inst : FilteredInstructions) {
621 // Marks all the segment positions with either BIT_TRUE or BIT_FALSE.
622 for (unsigned bitIndex = 0; bitIndex < NumBits; ++bitIndex) {
623 if (Inst.first & (1ULL << bitIndex))
624 BitValueArray[StartBit + bitIndex] = BIT_TRUE;
626 BitValueArray[StartBit + bitIndex] = BIT_FALSE;
629 // Delegates to an inferior filter chooser for further processing on this
630 // category of instructions.
631 FilterChooserMap.insert(std::make_pair(
632 Inst.first, std::make_unique<FilterChooser>(
633 Owner->AllInstructions, Inst.second,
634 Owner->Operands, BitValueArray, *Owner)));
638 static void resolveTableFixups(DecoderTable &Table, const FixupList &Fixups,
640 // Any NumToSkip fixups in the current scope can resolve to the
642 for (FixupList::const_reverse_iterator I = Fixups.rbegin(),
645 // Calculate the distance from the byte following the fixup entry byte
646 // to the destination. The Target is calculated from after the 16-bit
647 // NumToSkip entry itself, so subtract two from the displacement here
648 // to account for that.
649 uint32_t FixupIdx = *I;
650 uint32_t Delta = DestIdx - FixupIdx - 3;
651 // Our NumToSkip entries are 24-bits. Make sure our table isn't too
653 assert(Delta < (1u << 24));
654 Table[FixupIdx] = (uint8_t)Delta;
655 Table[FixupIdx + 1] = (uint8_t)(Delta >> 8);
656 Table[FixupIdx + 2] = (uint8_t)(Delta >> 16);
660 // Emit table entries to decode instructions given a segment or segments
662 void Filter::emitTableEntry(DecoderTableInfo &TableInfo) const {
663 TableInfo.Table.push_back(MCD::OPC_ExtractField);
664 TableInfo.Table.push_back(StartBit);
665 TableInfo.Table.push_back(NumBits);
667 // A new filter entry begins a new scope for fixup resolution.
668 TableInfo.FixupStack.emplace_back();
670 DecoderTable &Table = TableInfo.Table;
672 size_t PrevFilter = 0;
673 bool HasFallthrough = false;
674 for (auto &Filter : FilterChooserMap) {
675 // Field value -1 implies a non-empty set of variable instructions.
676 // See also recurse().
677 if (Filter.first == (unsigned)-1) {
678 HasFallthrough = true;
680 // Each scope should always have at least one filter value to check
682 assert(PrevFilter != 0 && "empty filter set!");
683 FixupList &CurScope = TableInfo.FixupStack.back();
684 // Resolve any NumToSkip fixups in the current scope.
685 resolveTableFixups(Table, CurScope, Table.size());
687 PrevFilter = 0; // Don't re-process the filter's fallthrough.
689 Table.push_back(MCD::OPC_FilterValue);
690 // Encode and emit the value to filter against.
692 unsigned Len = encodeULEB128(Filter.first, Buffer);
693 Table.insert(Table.end(), Buffer, Buffer + Len);
694 // Reserve space for the NumToSkip entry. We'll backpatch the value
696 PrevFilter = Table.size();
702 // We arrive at a category of instructions with the same segment value.
703 // Now delegate to the sub filter chooser for further decodings.
704 // The case may fallthrough, which happens if the remaining well-known
705 // encoding bits do not match exactly.
706 Filter.second->emitTableEntries(TableInfo);
708 // Now that we've emitted the body of the handler, update the NumToSkip
709 // of the filter itself to be able to skip forward when false. Subtract
710 // two as to account for the width of the NumToSkip field itself.
712 uint32_t NumToSkip = Table.size() - PrevFilter - 3;
713 assert(NumToSkip < (1u << 24) && "disassembler decoding table too large!");
714 Table[PrevFilter] = (uint8_t)NumToSkip;
715 Table[PrevFilter + 1] = (uint8_t)(NumToSkip >> 8);
716 Table[PrevFilter + 2] = (uint8_t)(NumToSkip >> 16);
720 // Any remaining unresolved fixups bubble up to the parent fixup scope.
721 assert(TableInfo.FixupStack.size() > 1 && "fixup stack underflow!");
722 FixupScopeList::iterator Source = TableInfo.FixupStack.end() - 1;
723 FixupScopeList::iterator Dest = Source - 1;
724 Dest->insert(Dest->end(), Source->begin(), Source->end());
725 TableInfo.FixupStack.pop_back();
727 // If there is no fallthrough, then the final filter should get fixed
728 // up according to the enclosing scope rather than the current position.
730 TableInfo.FixupStack.back().push_back(PrevFilter);
733 // Returns the number of fanout produced by the filter. More fanout implies
734 // the filter distinguishes more categories of instructions.
735 unsigned Filter::usefulness() const {
736 if (!VariableInstructions.empty())
737 return FilteredInstructions.size();
739 return FilteredInstructions.size() + 1;
742 //////////////////////////////////
744 // Filterchooser Implementation //
746 //////////////////////////////////
748 // Emit the decoder state machine table.
749 void FixedLenDecoderEmitter::emitTable(formatted_raw_ostream &OS,
751 unsigned Indentation,
753 StringRef Namespace) const {
754 OS.indent(Indentation) << "static const uint8_t DecoderTable" << Namespace
755 << BitWidth << "[] = {\n";
759 // FIXME: We may be able to use the NumToSkip values to recover
760 // appropriate indentation levels.
761 DecoderTable::const_iterator I = Table.begin();
762 DecoderTable::const_iterator E = Table.end();
764 assert (I < E && "incomplete decode table entry!");
766 uint64_t Pos = I - Table.begin();
767 OS << "/* " << Pos << " */";
772 PrintFatalError("invalid decode table opcode");
773 case MCD::OPC_ExtractField: {
775 unsigned Start = *I++;
777 OS.indent(Indentation) << "MCD::OPC_ExtractField, " << Start << ", "
778 << Len << ", // Inst{";
780 OS << (Start + Len - 1) << "-";
781 OS << Start << "} ...\n";
784 case MCD::OPC_FilterValue: {
786 OS.indent(Indentation) << "MCD::OPC_FilterValue, ";
787 // The filter value is ULEB128 encoded.
789 OS << (unsigned)*I++ << ", ";
790 OS << (unsigned)*I++ << ", ";
792 // 24-bit numtoskip value.
794 uint32_t NumToSkip = Byte;
795 OS << (unsigned)Byte << ", ";
797 OS << (unsigned)Byte << ", ";
798 NumToSkip |= Byte << 8;
800 OS << utostr(Byte) << ", ";
801 NumToSkip |= Byte << 16;
802 OS << "// Skip to: " << ((I - Table.begin()) + NumToSkip) << "\n";
805 case MCD::OPC_CheckField: {
807 unsigned Start = *I++;
809 OS.indent(Indentation) << "MCD::OPC_CheckField, " << Start << ", "
810 << Len << ", ";// << Val << ", " << NumToSkip << ",\n";
811 // ULEB128 encoded field value.
812 for (; *I >= 128; ++I)
813 OS << (unsigned)*I << ", ";
814 OS << (unsigned)*I++ << ", ";
815 // 24-bit numtoskip value.
817 uint32_t NumToSkip = Byte;
818 OS << (unsigned)Byte << ", ";
820 OS << (unsigned)Byte << ", ";
821 NumToSkip |= Byte << 8;
823 OS << utostr(Byte) << ", ";
824 NumToSkip |= Byte << 16;
825 OS << "// Skip to: " << ((I - Table.begin()) + NumToSkip) << "\n";
828 case MCD::OPC_CheckPredicate: {
830 OS.indent(Indentation) << "MCD::OPC_CheckPredicate, ";
831 for (; *I >= 128; ++I)
832 OS << (unsigned)*I << ", ";
833 OS << (unsigned)*I++ << ", ";
835 // 24-bit numtoskip value.
837 uint32_t NumToSkip = Byte;
838 OS << (unsigned)Byte << ", ";
840 OS << (unsigned)Byte << ", ";
841 NumToSkip |= Byte << 8;
843 OS << utostr(Byte) << ", ";
844 NumToSkip |= Byte << 16;
845 OS << "// Skip to: " << ((I - Table.begin()) + NumToSkip) << "\n";
848 case MCD::OPC_Decode:
849 case MCD::OPC_TryDecode: {
850 bool IsTry = *I == MCD::OPC_TryDecode;
852 // Extract the ULEB128 encoded Opcode to a buffer.
853 uint8_t Buffer[16], *p = Buffer;
854 while ((*p++ = *I++) >= 128)
855 assert((p - Buffer) <= (ptrdiff_t)sizeof(Buffer)
856 && "ULEB128 value too large!");
857 // Decode the Opcode value.
858 unsigned Opc = decodeULEB128(Buffer);
859 OS.indent(Indentation) << "MCD::OPC_" << (IsTry ? "Try" : "")
861 for (p = Buffer; *p >= 128; ++p)
862 OS << (unsigned)*p << ", ";
863 OS << (unsigned)*p << ", ";
866 for (; *I >= 128; ++I)
867 OS << (unsigned)*I << ", ";
868 OS << (unsigned)*I++ << ", ";
871 OS << "// Opcode: " << NumberedEncodings[Opc] << "\n";
875 // Fallthrough for OPC_TryDecode.
877 // 24-bit numtoskip value.
879 uint32_t NumToSkip = Byte;
880 OS << (unsigned)Byte << ", ";
882 OS << (unsigned)Byte << ", ";
883 NumToSkip |= Byte << 8;
885 OS << utostr(Byte) << ", ";
886 NumToSkip |= Byte << 16;
888 OS << "// Opcode: " << NumberedEncodings[Opc]
889 << ", skip to: " << ((I - Table.begin()) + NumToSkip) << "\n";
892 case MCD::OPC_SoftFail: {
894 OS.indent(Indentation) << "MCD::OPC_SoftFail";
899 OS << ", " << (unsigned)*I;
900 Value += (*I & 0x7f) << Shift;
902 } while (*I++ >= 128);
912 OS << ", " << (unsigned)*I;
913 Value += (*I & 0x7f) << Shift;
915 } while (*I++ >= 128);
924 case MCD::OPC_Fail: {
926 OS.indent(Indentation) << "MCD::OPC_Fail,\n";
931 OS.indent(Indentation) << "0\n";
935 OS.indent(Indentation) << "};\n\n";
938 void FixedLenDecoderEmitter::
939 emitPredicateFunction(formatted_raw_ostream &OS, PredicateSet &Predicates,
940 unsigned Indentation) const {
941 // The predicate function is just a big switch statement based on the
942 // input predicate index.
943 OS.indent(Indentation) << "static bool checkDecoderPredicate(unsigned Idx, "
944 << "const FeatureBitset& Bits) {\n";
946 if (!Predicates.empty()) {
947 OS.indent(Indentation) << "switch (Idx) {\n";
948 OS.indent(Indentation) << "default: llvm_unreachable(\"Invalid index!\");\n";
950 for (const auto &Predicate : Predicates) {
951 OS.indent(Indentation) << "case " << Index++ << ":\n";
952 OS.indent(Indentation+2) << "return (" << Predicate << ");\n";
954 OS.indent(Indentation) << "}\n";
956 // No case statement to emit
957 OS.indent(Indentation) << "llvm_unreachable(\"Invalid index!\");\n";
960 OS.indent(Indentation) << "}\n\n";
963 void FixedLenDecoderEmitter::
964 emitDecoderFunction(formatted_raw_ostream &OS, DecoderSet &Decoders,
965 unsigned Indentation) const {
966 // The decoder function is just a big switch statement based on the
967 // input decoder index.
968 OS.indent(Indentation) << "template<typename InsnType>\n";
969 OS.indent(Indentation) << "static DecodeStatus decodeToMCInst(DecodeStatus S,"
970 << " unsigned Idx, InsnType insn, MCInst &MI,\n";
971 OS.indent(Indentation) << " uint64_t "
972 << "Address, const void *Decoder, bool &DecodeComplete) {\n";
974 OS.indent(Indentation) << "DecodeComplete = true;\n";
975 OS.indent(Indentation) << "InsnType tmp;\n";
976 OS.indent(Indentation) << "switch (Idx) {\n";
977 OS.indent(Indentation) << "default: llvm_unreachable(\"Invalid index!\");\n";
979 for (const auto &Decoder : Decoders) {
980 OS.indent(Indentation) << "case " << Index++ << ":\n";
982 OS.indent(Indentation+2) << "return S;\n";
984 OS.indent(Indentation) << "}\n";
986 OS.indent(Indentation) << "}\n\n";
989 // Populates the field of the insn given the start position and the number of
990 // consecutive bits to scan for.
992 // Returns false if and on the first uninitialized bit value encountered.
993 // Returns true, otherwise.
994 bool FilterChooser::fieldFromInsn(uint64_t &Field, insn_t &Insn,
995 unsigned StartBit, unsigned NumBits) const {
998 for (unsigned i = 0; i < NumBits; ++i) {
999 if (Insn[StartBit + i] == BIT_UNSET)
1002 if (Insn[StartBit + i] == BIT_TRUE)
1003 Field = Field | (1ULL << i);
1009 /// dumpFilterArray - dumpFilterArray prints out debugging info for the given
1010 /// filter array as a series of chars.
1011 void FilterChooser::dumpFilterArray(raw_ostream &o,
1012 const std::vector<bit_value_t> &filter) const {
1013 for (unsigned bitIndex = BitWidth; bitIndex > 0; bitIndex--) {
1014 switch (filter[bitIndex - 1]) {
1015 case BIT_UNFILTERED:
1031 /// dumpStack - dumpStack traverses the filter chooser chain and calls
1032 /// dumpFilterArray on each filter chooser up to the top level one.
1033 void FilterChooser::dumpStack(raw_ostream &o, const char *prefix) const {
1034 const FilterChooser *current = this;
1038 dumpFilterArray(o, current->FilterBitValues);
1040 current = current->Parent;
1044 // Calculates the island(s) needed to decode the instruction.
1045 // This returns a list of undecoded bits of an instructions, for example,
1046 // Inst{20} = 1 && Inst{3-0} == 0b1111 represents two islands of yet-to-be
1047 // decoded bits in order to verify that the instruction matches the Opcode.
1048 unsigned FilterChooser::getIslands(std::vector<unsigned> &StartBits,
1049 std::vector<unsigned> &EndBits,
1050 std::vector<uint64_t> &FieldVals,
1051 const insn_t &Insn) const {
1052 unsigned Num, BitNo;
1055 uint64_t FieldVal = 0;
1058 // 1: Water (the bit value does not affect decoding)
1059 // 2: Island (well-known bit value needed for decoding)
1062 for (unsigned i = 0; i < BitWidth; ++i) {
1063 int64_t Val = Value(Insn[i]);
1064 bool Filtered = PositionFiltered(i);
1066 default: llvm_unreachable("Unreachable code!");
1069 if (Filtered || Val == -1)
1070 State = 1; // Still in Water
1072 State = 2; // Into the Island
1074 StartBits.push_back(i);
1079 if (Filtered || Val == -1) {
1080 State = 1; // Into the Water
1081 EndBits.push_back(i - 1);
1082 FieldVals.push_back(FieldVal);
1085 State = 2; // Still in Island
1087 FieldVal = FieldVal | Val << BitNo;
1092 // If we are still in Island after the loop, do some housekeeping.
1094 EndBits.push_back(BitWidth - 1);
1095 FieldVals.push_back(FieldVal);
1099 assert(StartBits.size() == Num && EndBits.size() == Num &&
1100 FieldVals.size() == Num);
1104 void FilterChooser::emitBinaryParser(raw_ostream &o, unsigned &Indentation,
1105 const OperandInfo &OpInfo,
1106 bool &OpHasCompleteDecoder) const {
1107 const std::string &Decoder = OpInfo.Decoder;
1109 if (OpInfo.numFields() != 1 || OpInfo.InitValue != 0) {
1110 o.indent(Indentation) << "tmp = 0x";
1111 o.write_hex(OpInfo.InitValue);
1115 for (const EncodingField &EF : OpInfo) {
1116 o.indent(Indentation) << "tmp ";
1117 if (OpInfo.numFields() != 1 || OpInfo.InitValue != 0) o << '|';
1118 o << "= fieldFromInstruction"
1119 << "(insn, " << EF.Base << ", " << EF.Width << ')';
1120 if (OpInfo.numFields() != 1 || EF.Offset != 0)
1121 o << " << " << EF.Offset;
1125 if (Decoder != "") {
1126 OpHasCompleteDecoder = OpInfo.HasCompleteDecoder;
1127 o.indent(Indentation) << Emitter->GuardPrefix << Decoder
1128 << "(MI, tmp, Address, Decoder)"
1129 << Emitter->GuardPostfix
1130 << " { " << (OpHasCompleteDecoder ? "" : "DecodeComplete = false; ")
1131 << "return MCDisassembler::Fail; }\n";
1133 OpHasCompleteDecoder = true;
1134 o.indent(Indentation) << "MI.addOperand(MCOperand::createImm(tmp));\n";
1138 void FilterChooser::emitDecoder(raw_ostream &OS, unsigned Indentation,
1139 unsigned Opc, bool &HasCompleteDecoder) const {
1140 HasCompleteDecoder = true;
1142 for (const auto &Op : Operands.find(Opc)->second) {
1143 // If a custom instruction decoder was specified, use that.
1144 if (Op.numFields() == 0 && !Op.Decoder.empty()) {
1145 HasCompleteDecoder = Op.HasCompleteDecoder;
1146 OS.indent(Indentation) << Emitter->GuardPrefix << Op.Decoder
1147 << "(MI, insn, Address, Decoder)"
1148 << Emitter->GuardPostfix
1149 << " { " << (HasCompleteDecoder ? "" : "DecodeComplete = false; ")
1150 << "return MCDisassembler::Fail; }\n";
1154 bool OpHasCompleteDecoder;
1155 emitBinaryParser(OS, Indentation, Op, OpHasCompleteDecoder);
1156 if (!OpHasCompleteDecoder)
1157 HasCompleteDecoder = false;
1161 unsigned FilterChooser::getDecoderIndex(DecoderSet &Decoders,
1163 bool &HasCompleteDecoder) const {
1164 // Build up the predicate string.
1165 SmallString<256> Decoder;
1166 // FIXME: emitDecoder() function can take a buffer directly rather than
1168 raw_svector_ostream S(Decoder);
1170 emitDecoder(S, I, Opc, HasCompleteDecoder);
1172 // Using the full decoder string as the key value here is a bit
1173 // heavyweight, but is effective. If the string comparisons become a
1174 // performance concern, we can implement a mangling of the predicate
1175 // data easily enough with a map back to the actual string. That's
1176 // overkill for now, though.
1178 // Make sure the predicate is in the table.
1179 Decoders.insert(CachedHashString(Decoder));
1180 // Now figure out the index for when we write out the table.
1181 DecoderSet::const_iterator P = find(Decoders, Decoder.str());
1182 return (unsigned)(P - Decoders.begin());
1185 static void emitSinglePredicateMatch(raw_ostream &o, StringRef str,
1186 const std::string &PredicateNamespace) {
1188 o << "!Bits[" << PredicateNamespace << "::"
1189 << str.slice(1,str.size()) << "]";
1191 o << "Bits[" << PredicateNamespace << "::" << str << "]";
1194 bool FilterChooser::emitPredicateMatch(raw_ostream &o, unsigned &Indentation,
1195 unsigned Opc) const {
1196 ListInit *Predicates =
1197 AllInstructions[Opc].EncodingDef->getValueAsListInit("Predicates");
1198 bool IsFirstEmission = true;
1199 for (unsigned i = 0; i < Predicates->size(); ++i) {
1200 Record *Pred = Predicates->getElementAsRecord(i);
1201 if (!Pred->getValue("AssemblerMatcherPredicate"))
1204 StringRef P = Pred->getValueAsString("AssemblerCondString");
1209 if (!IsFirstEmission)
1212 std::pair<StringRef, StringRef> pairs = P.split(',');
1213 while (!pairs.second.empty()) {
1214 emitSinglePredicateMatch(o, pairs.first, Emitter->PredicateNamespace);
1216 pairs = pairs.second.split(',');
1218 emitSinglePredicateMatch(o, pairs.first, Emitter->PredicateNamespace);
1219 IsFirstEmission = false;
1221 return !Predicates->empty();
1224 bool FilterChooser::doesOpcodeNeedPredicate(unsigned Opc) const {
1225 ListInit *Predicates =
1226 AllInstructions[Opc].EncodingDef->getValueAsListInit("Predicates");
1227 for (unsigned i = 0; i < Predicates->size(); ++i) {
1228 Record *Pred = Predicates->getElementAsRecord(i);
1229 if (!Pred->getValue("AssemblerMatcherPredicate"))
1232 StringRef P = Pred->getValueAsString("AssemblerCondString");
1242 unsigned FilterChooser::getPredicateIndex(DecoderTableInfo &TableInfo,
1243 StringRef Predicate) const {
1244 // Using the full predicate string as the key value here is a bit
1245 // heavyweight, but is effective. If the string comparisons become a
1246 // performance concern, we can implement a mangling of the predicate
1247 // data easily enough with a map back to the actual string. That's
1248 // overkill for now, though.
1250 // Make sure the predicate is in the table.
1251 TableInfo.Predicates.insert(CachedHashString(Predicate));
1252 // Now figure out the index for when we write out the table.
1253 PredicateSet::const_iterator P = find(TableInfo.Predicates, Predicate);
1254 return (unsigned)(P - TableInfo.Predicates.begin());
1257 void FilterChooser::emitPredicateTableEntry(DecoderTableInfo &TableInfo,
1258 unsigned Opc) const {
1259 if (!doesOpcodeNeedPredicate(Opc))
1262 // Build up the predicate string.
1263 SmallString<256> Predicate;
1264 // FIXME: emitPredicateMatch() functions can take a buffer directly rather
1266 raw_svector_ostream PS(Predicate);
1268 emitPredicateMatch(PS, I, Opc);
1270 // Figure out the index into the predicate table for the predicate just
1272 unsigned PIdx = getPredicateIndex(TableInfo, PS.str());
1273 SmallString<16> PBytes;
1274 raw_svector_ostream S(PBytes);
1275 encodeULEB128(PIdx, S);
1277 TableInfo.Table.push_back(MCD::OPC_CheckPredicate);
1279 for (unsigned i = 0, e = PBytes.size(); i != e; ++i)
1280 TableInfo.Table.push_back(PBytes[i]);
1281 // Push location for NumToSkip backpatching.
1282 TableInfo.FixupStack.back().push_back(TableInfo.Table.size());
1283 TableInfo.Table.push_back(0);
1284 TableInfo.Table.push_back(0);
1285 TableInfo.Table.push_back(0);
1288 void FilterChooser::emitSoftFailTableEntry(DecoderTableInfo &TableInfo,
1289 unsigned Opc) const {
1291 AllInstructions[Opc].EncodingDef->getValueAsBitsInit("SoftFail");
1292 if (!SFBits) return;
1293 BitsInit *InstBits =
1294 AllInstructions[Opc].EncodingDef->getValueAsBitsInit("Inst");
1296 APInt PositiveMask(BitWidth, 0ULL);
1297 APInt NegativeMask(BitWidth, 0ULL);
1298 for (unsigned i = 0; i < BitWidth; ++i) {
1299 bit_value_t B = bitFromBits(*SFBits, i);
1300 bit_value_t IB = bitFromBits(*InstBits, i);
1302 if (B != BIT_TRUE) continue;
1306 // The bit is meant to be false, so emit a check to see if it is true.
1307 PositiveMask.setBit(i);
1310 // The bit is meant to be true, so emit a check to see if it is false.
1311 NegativeMask.setBit(i);
1314 // The bit is not set; this must be an error!
1315 errs() << "SoftFail Conflict: bit SoftFail{" << i << "} in "
1316 << AllInstructions[Opc] << " is set but Inst{" << i
1318 << " - You can only mark a bit as SoftFail if it is fully defined"
1319 << " (1/0 - not '?') in Inst\n";
1324 bool NeedPositiveMask = PositiveMask.getBoolValue();
1325 bool NeedNegativeMask = NegativeMask.getBoolValue();
1327 if (!NeedPositiveMask && !NeedNegativeMask)
1330 TableInfo.Table.push_back(MCD::OPC_SoftFail);
1332 SmallString<16> MaskBytes;
1333 raw_svector_ostream S(MaskBytes);
1334 if (NeedPositiveMask) {
1335 encodeULEB128(PositiveMask.getZExtValue(), S);
1336 for (unsigned i = 0, e = MaskBytes.size(); i != e; ++i)
1337 TableInfo.Table.push_back(MaskBytes[i]);
1339 TableInfo.Table.push_back(0);
1340 if (NeedNegativeMask) {
1342 encodeULEB128(NegativeMask.getZExtValue(), S);
1343 for (unsigned i = 0, e = MaskBytes.size(); i != e; ++i)
1344 TableInfo.Table.push_back(MaskBytes[i]);
1346 TableInfo.Table.push_back(0);
1349 // Emits table entries to decode the singleton.
1350 void FilterChooser::emitSingletonTableEntry(DecoderTableInfo &TableInfo,
1351 EncodingIDAndOpcode Opc) const {
1352 std::vector<unsigned> StartBits;
1353 std::vector<unsigned> EndBits;
1354 std::vector<uint64_t> FieldVals;
1356 insnWithID(Insn, Opc.EncodingID);
1358 // Look for islands of undecoded bits of the singleton.
1359 getIslands(StartBits, EndBits, FieldVals, Insn);
1361 unsigned Size = StartBits.size();
1363 // Emit the predicate table entry if one is needed.
1364 emitPredicateTableEntry(TableInfo, Opc.EncodingID);
1366 // Check any additional encoding fields needed.
1367 for (unsigned I = Size; I != 0; --I) {
1368 unsigned NumBits = EndBits[I-1] - StartBits[I-1] + 1;
1369 TableInfo.Table.push_back(MCD::OPC_CheckField);
1370 TableInfo.Table.push_back(StartBits[I-1]);
1371 TableInfo.Table.push_back(NumBits);
1372 uint8_t Buffer[16], *p;
1373 encodeULEB128(FieldVals[I-1], Buffer);
1374 for (p = Buffer; *p >= 128 ; ++p)
1375 TableInfo.Table.push_back(*p);
1376 TableInfo.Table.push_back(*p);
1377 // Push location for NumToSkip backpatching.
1378 TableInfo.FixupStack.back().push_back(TableInfo.Table.size());
1379 // The fixup is always 24-bits, so go ahead and allocate the space
1380 // in the table so all our relative position calculations work OK even
1381 // before we fully resolve the real value here.
1382 TableInfo.Table.push_back(0);
1383 TableInfo.Table.push_back(0);
1384 TableInfo.Table.push_back(0);
1387 // Check for soft failure of the match.
1388 emitSoftFailTableEntry(TableInfo, Opc.EncodingID);
1390 bool HasCompleteDecoder;
1392 getDecoderIndex(TableInfo.Decoders, Opc.EncodingID, HasCompleteDecoder);
1394 // Produce OPC_Decode or OPC_TryDecode opcode based on the information
1395 // whether the instruction decoder is complete or not. If it is complete
1396 // then it handles all possible values of remaining variable/unfiltered bits
1397 // and for any value can determine if the bitpattern is a valid instruction
1398 // or not. This means OPC_Decode will be the final step in the decoding
1399 // process. If it is not complete, then the Fail return code from the
1400 // decoder method indicates that additional processing should be done to see
1401 // if there is any other instruction that also matches the bitpattern and
1403 TableInfo.Table.push_back(HasCompleteDecoder ? MCD::OPC_Decode :
1404 MCD::OPC_TryDecode);
1405 NumEncodingsSupported++;
1406 uint8_t Buffer[16], *p;
1407 encodeULEB128(Opc.Opcode, Buffer);
1408 for (p = Buffer; *p >= 128 ; ++p)
1409 TableInfo.Table.push_back(*p);
1410 TableInfo.Table.push_back(*p);
1412 SmallString<16> Bytes;
1413 raw_svector_ostream S(Bytes);
1414 encodeULEB128(DIdx, S);
1417 for (unsigned i = 0, e = Bytes.size(); i != e; ++i)
1418 TableInfo.Table.push_back(Bytes[i]);
1420 if (!HasCompleteDecoder) {
1421 // Push location for NumToSkip backpatching.
1422 TableInfo.FixupStack.back().push_back(TableInfo.Table.size());
1423 // Allocate the space for the fixup.
1424 TableInfo.Table.push_back(0);
1425 TableInfo.Table.push_back(0);
1426 TableInfo.Table.push_back(0);
1430 // Emits table entries to decode the singleton, and then to decode the rest.
1431 void FilterChooser::emitSingletonTableEntry(DecoderTableInfo &TableInfo,
1432 const Filter &Best) const {
1433 EncodingIDAndOpcode Opc = Best.getSingletonOpc();
1435 // complex singletons need predicate checks from the first singleton
1436 // to refer forward to the variable filterchooser that follows.
1437 TableInfo.FixupStack.emplace_back();
1439 emitSingletonTableEntry(TableInfo, Opc);
1441 resolveTableFixups(TableInfo.Table, TableInfo.FixupStack.back(),
1442 TableInfo.Table.size());
1443 TableInfo.FixupStack.pop_back();
1445 Best.getVariableFC().emitTableEntries(TableInfo);
1448 // Assign a single filter and run with it. Top level API client can initialize
1449 // with a single filter to start the filtering process.
1450 void FilterChooser::runSingleFilter(unsigned startBit, unsigned numBit,
1453 Filters.emplace_back(*this, startBit, numBit, true);
1454 BestIndex = 0; // Sole Filter instance to choose from.
1455 bestFilter().recurse();
1458 // reportRegion is a helper function for filterProcessor to mark a region as
1459 // eligible for use as a filter region.
1460 void FilterChooser::reportRegion(bitAttr_t RA, unsigned StartBit,
1461 unsigned BitIndex, bool AllowMixed) {
1462 if (RA == ATTR_MIXED && AllowMixed)
1463 Filters.emplace_back(*this, StartBit, BitIndex - StartBit, true);
1464 else if (RA == ATTR_ALL_SET && !AllowMixed)
1465 Filters.emplace_back(*this, StartBit, BitIndex - StartBit, false);
1468 // FilterProcessor scans the well-known encoding bits of the instructions and
1469 // builds up a list of candidate filters. It chooses the best filter and
1470 // recursively descends down the decoding tree.
1471 bool FilterChooser::filterProcessor(bool AllowMixed, bool Greedy) {
1474 unsigned numInstructions = Opcodes.size();
1476 assert(numInstructions && "Filter created with no instructions");
1478 // No further filtering is necessary.
1479 if (numInstructions == 1)
1482 // Heuristics. See also doFilter()'s "Heuristics" comment when num of
1483 // instructions is 3.
1484 if (AllowMixed && !Greedy) {
1485 assert(numInstructions == 3);
1487 for (unsigned i = 0; i < Opcodes.size(); ++i) {
1488 std::vector<unsigned> StartBits;
1489 std::vector<unsigned> EndBits;
1490 std::vector<uint64_t> FieldVals;
1493 insnWithID(Insn, Opcodes[i].EncodingID);
1495 // Look for islands of undecoded bits of any instruction.
1496 if (getIslands(StartBits, EndBits, FieldVals, Insn) > 0) {
1497 // Found an instruction with island(s). Now just assign a filter.
1498 runSingleFilter(StartBits[0], EndBits[0] - StartBits[0] + 1, true);
1506 // We maintain BIT_WIDTH copies of the bitAttrs automaton.
1507 // The automaton consumes the corresponding bit from each
1510 // Input symbols: 0, 1, and _ (unset).
1511 // States: NONE, FILTERED, ALL_SET, ALL_UNSET, and MIXED.
1512 // Initial state: NONE.
1514 // (NONE) ------- [01] -> (ALL_SET)
1515 // (NONE) ------- _ ----> (ALL_UNSET)
1516 // (ALL_SET) ---- [01] -> (ALL_SET)
1517 // (ALL_SET) ---- _ ----> (MIXED)
1518 // (ALL_UNSET) -- [01] -> (MIXED)
1519 // (ALL_UNSET) -- _ ----> (ALL_UNSET)
1520 // (MIXED) ------ . ----> (MIXED)
1521 // (FILTERED)---- . ----> (FILTERED)
1523 std::vector<bitAttr_t> bitAttrs;
1525 // FILTERED bit positions provide no entropy and are not worthy of pursuing.
1526 // Filter::recurse() set either BIT_TRUE or BIT_FALSE for each position.
1527 for (BitIndex = 0; BitIndex < BitWidth; ++BitIndex)
1528 if (FilterBitValues[BitIndex] == BIT_TRUE ||
1529 FilterBitValues[BitIndex] == BIT_FALSE)
1530 bitAttrs.push_back(ATTR_FILTERED);
1532 bitAttrs.push_back(ATTR_NONE);
1534 for (unsigned InsnIndex = 0; InsnIndex < numInstructions; ++InsnIndex) {
1537 insnWithID(insn, Opcodes[InsnIndex].EncodingID);
1539 for (BitIndex = 0; BitIndex < BitWidth; ++BitIndex) {
1540 switch (bitAttrs[BitIndex]) {
1542 if (insn[BitIndex] == BIT_UNSET)
1543 bitAttrs[BitIndex] = ATTR_ALL_UNSET;
1545 bitAttrs[BitIndex] = ATTR_ALL_SET;
1548 if (insn[BitIndex] == BIT_UNSET)
1549 bitAttrs[BitIndex] = ATTR_MIXED;
1551 case ATTR_ALL_UNSET:
1552 if (insn[BitIndex] != BIT_UNSET)
1553 bitAttrs[BitIndex] = ATTR_MIXED;
1562 // The regionAttr automaton consumes the bitAttrs automatons' state,
1563 // lowest-to-highest.
1565 // Input symbols: F(iltered), (all_)S(et), (all_)U(nset), M(ixed)
1566 // States: NONE, ALL_SET, MIXED
1567 // Initial state: NONE
1569 // (NONE) ----- F --> (NONE)
1570 // (NONE) ----- S --> (ALL_SET) ; and set region start
1571 // (NONE) ----- U --> (NONE)
1572 // (NONE) ----- M --> (MIXED) ; and set region start
1573 // (ALL_SET) -- F --> (NONE) ; and report an ALL_SET region
1574 // (ALL_SET) -- S --> (ALL_SET)
1575 // (ALL_SET) -- U --> (NONE) ; and report an ALL_SET region
1576 // (ALL_SET) -- M --> (MIXED) ; and report an ALL_SET region
1577 // (MIXED) ---- F --> (NONE) ; and report a MIXED region
1578 // (MIXED) ---- S --> (ALL_SET) ; and report a MIXED region
1579 // (MIXED) ---- U --> (NONE) ; and report a MIXED region
1580 // (MIXED) ---- M --> (MIXED)
1582 bitAttr_t RA = ATTR_NONE;
1583 unsigned StartBit = 0;
1585 for (BitIndex = 0; BitIndex < BitWidth; ++BitIndex) {
1586 bitAttr_t bitAttr = bitAttrs[BitIndex];
1588 assert(bitAttr != ATTR_NONE && "Bit without attributes");
1596 StartBit = BitIndex;
1599 case ATTR_ALL_UNSET:
1602 StartBit = BitIndex;
1606 llvm_unreachable("Unexpected bitAttr!");
1612 reportRegion(RA, StartBit, BitIndex, AllowMixed);
1617 case ATTR_ALL_UNSET:
1618 reportRegion(RA, StartBit, BitIndex, AllowMixed);
1622 reportRegion(RA, StartBit, BitIndex, AllowMixed);
1623 StartBit = BitIndex;
1627 llvm_unreachable("Unexpected bitAttr!");
1633 reportRegion(RA, StartBit, BitIndex, AllowMixed);
1634 StartBit = BitIndex;
1638 reportRegion(RA, StartBit, BitIndex, AllowMixed);
1639 StartBit = BitIndex;
1642 case ATTR_ALL_UNSET:
1643 reportRegion(RA, StartBit, BitIndex, AllowMixed);
1649 llvm_unreachable("Unexpected bitAttr!");
1652 case ATTR_ALL_UNSET:
1653 llvm_unreachable("regionAttr state machine has no ATTR_UNSET state");
1655 llvm_unreachable("regionAttr state machine has no ATTR_FILTERED state");
1659 // At the end, if we're still in ALL_SET or MIXED states, report a region
1666 reportRegion(RA, StartBit, BitIndex, AllowMixed);
1668 case ATTR_ALL_UNSET:
1671 reportRegion(RA, StartBit, BitIndex, AllowMixed);
1675 // We have finished with the filter processings. Now it's time to choose
1676 // the best performing filter.
1678 bool AllUseless = true;
1679 unsigned BestScore = 0;
1681 for (unsigned i = 0, e = Filters.size(); i != e; ++i) {
1682 unsigned Usefulness = Filters[i].usefulness();
1687 if (Usefulness > BestScore) {
1689 BestScore = Usefulness;
1694 bestFilter().recurse();
1697 } // end of FilterChooser::filterProcessor(bool)
1699 // Decides on the best configuration of filter(s) to use in order to decode
1700 // the instructions. A conflict of instructions may occur, in which case we
1701 // dump the conflict set to the standard error.
1702 void FilterChooser::doFilter() {
1703 unsigned Num = Opcodes.size();
1704 assert(Num && "FilterChooser created with no instructions");
1706 // Try regions of consecutive known bit values first.
1707 if (filterProcessor(false))
1710 // Then regions of mixed bits (both known and unitialized bit values allowed).
1711 if (filterProcessor(true))
1714 // Heuristics to cope with conflict set {t2CMPrs, t2SUBSrr, t2SUBSrs} where
1715 // no single instruction for the maximum ATTR_MIXED region Inst{14-4} has a
1716 // well-known encoding pattern. In such case, we backtrack and scan for the
1717 // the very first consecutive ATTR_ALL_SET region and assign a filter to it.
1718 if (Num == 3 && filterProcessor(true, false))
1721 // If we come to here, the instruction decoding has failed.
1722 // Set the BestIndex to -1 to indicate so.
1726 // emitTableEntries - Emit state machine entries to decode our share of
1728 void FilterChooser::emitTableEntries(DecoderTableInfo &TableInfo) const {
1729 if (Opcodes.size() == 1) {
1730 // There is only one instruction in the set, which is great!
1731 // Call emitSingletonDecoder() to see whether there are any remaining
1733 emitSingletonTableEntry(TableInfo, Opcodes[0]);
1737 // Choose the best filter to do the decodings!
1738 if (BestIndex != -1) {
1739 const Filter &Best = Filters[BestIndex];
1740 if (Best.getNumFiltered() == 1)
1741 emitSingletonTableEntry(TableInfo, Best);
1743 Best.emitTableEntry(TableInfo);
1747 // We don't know how to decode these instructions! Dump the
1748 // conflict set and bail.
1750 // Print out useful conflict information for postmortem analysis.
1751 errs() << "Decoding Conflict:\n";
1753 dumpStack(errs(), "\t\t");
1755 for (unsigned i = 0; i < Opcodes.size(); ++i) {
1757 emitNameWithID(errs(), Opcodes[i].EncodingID);
1761 getBitsField(*AllInstructions[Opcodes[i].EncodingID].EncodingDef, "Inst"));
1766 static std::string findOperandDecoderMethod(TypedInit *TI) {
1767 std::string Decoder;
1769 Record *Record = cast<DefInit>(TI)->getDef();
1771 RecordVal *DecoderString = Record->getValue("DecoderMethod");
1772 StringInit *String = DecoderString ?
1773 dyn_cast<StringInit>(DecoderString->getValue()) : nullptr;
1775 Decoder = String->getValue();
1776 if (!Decoder.empty())
1780 if (Record->isSubClassOf("RegisterOperand"))
1781 Record = Record->getValueAsDef("RegClass");
1783 if (Record->isSubClassOf("RegisterClass")) {
1784 Decoder = "Decode" + Record->getName().str() + "RegisterClass";
1785 } else if (Record->isSubClassOf("PointerLikeRegClass")) {
1786 Decoder = "DecodePointerLikeRegClass" +
1787 utostr(Record->getValueAsInt("RegClassKind"));
1794 populateInstruction(CodeGenTarget &Target, const Record &EncodingDef,
1795 const CodeGenInstruction &CGI, unsigned Opc,
1796 std::map<unsigned, std::vector<OperandInfo>> &Operands) {
1797 const Record &Def = *CGI.TheDef;
1798 // If all the bit positions are not specified; do not decode this instruction.
1799 // We are bound to fail! For proper disassembly, the well-known encoding bits
1800 // of the instruction must be fully specified.
1802 BitsInit &Bits = getBitsField(EncodingDef, "Inst");
1803 if (Bits.allInComplete()) return false;
1805 std::vector<OperandInfo> InsnOperands;
1807 // If the instruction has specified a custom decoding hook, use that instead
1808 // of trying to auto-generate the decoder.
1809 StringRef InstDecoder = EncodingDef.getValueAsString("DecoderMethod");
1810 if (InstDecoder != "") {
1811 bool HasCompleteInstDecoder = EncodingDef.getValueAsBit("hasCompleteDecoder");
1812 InsnOperands.push_back(OperandInfo(InstDecoder, HasCompleteInstDecoder));
1813 Operands[Opc] = InsnOperands;
1817 // Generate a description of the operand of the instruction that we know
1818 // how to decode automatically.
1819 // FIXME: We'll need to have a way to manually override this as needed.
1821 // Gather the outputs/inputs of the instruction, so we can find their
1822 // positions in the encoding. This assumes for now that they appear in the
1823 // MCInst in the order that they're listed.
1824 std::vector<std::pair<Init*, StringRef>> InOutOperands;
1825 DagInit *Out = Def.getValueAsDag("OutOperandList");
1826 DagInit *In = Def.getValueAsDag("InOperandList");
1827 for (unsigned i = 0; i < Out->getNumArgs(); ++i)
1828 InOutOperands.push_back(std::make_pair(Out->getArg(i),
1829 Out->getArgNameStr(i)));
1830 for (unsigned i = 0; i < In->getNumArgs(); ++i)
1831 InOutOperands.push_back(std::make_pair(In->getArg(i),
1832 In->getArgNameStr(i)));
1834 // Search for tied operands, so that we can correctly instantiate
1835 // operands that are not explicitly represented in the encoding.
1836 std::map<std::string, std::string> TiedNames;
1837 for (unsigned i = 0; i < CGI.Operands.size(); ++i) {
1838 int tiedTo = CGI.Operands[i].getTiedRegister();
1840 std::pair<unsigned, unsigned> SO =
1841 CGI.Operands.getSubOperandNumber(tiedTo);
1842 TiedNames[InOutOperands[i].second] = InOutOperands[SO.first].second;
1843 TiedNames[InOutOperands[SO.first].second] = InOutOperands[i].second;
1847 std::map<std::string, std::vector<OperandInfo>> NumberedInsnOperands;
1848 std::set<std::string> NumberedInsnOperandsNoTie;
1849 if (Target.getInstructionSet()->
1850 getValueAsBit("decodePositionallyEncodedOperands")) {
1851 const std::vector<RecordVal> &Vals = Def.getValues();
1852 unsigned NumberedOp = 0;
1854 std::set<unsigned> NamedOpIndices;
1855 if (Target.getInstructionSet()->
1856 getValueAsBit("noNamedPositionallyEncodedOperands"))
1857 // Collect the set of operand indices that might correspond to named
1858 // operand, and skip these when assigning operands based on position.
1859 for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
1861 if (!CGI.Operands.hasOperandNamed(Vals[i].getName(), OpIdx))
1864 NamedOpIndices.insert(OpIdx);
1867 for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
1868 // Ignore fixed fields in the record, we're looking for values like:
1869 // bits<5> RST = { ?, ?, ?, ?, ? };
1870 if (Vals[i].getPrefix() || Vals[i].getValue()->isComplete())
1873 // Determine if Vals[i] actually contributes to the Inst encoding.
1875 for (; bi < Bits.getNumBits(); ++bi) {
1876 VarInit *Var = nullptr;
1877 VarBitInit *BI = dyn_cast<VarBitInit>(Bits.getBit(bi));
1879 Var = dyn_cast<VarInit>(BI->getBitVar());
1881 Var = dyn_cast<VarInit>(Bits.getBit(bi));
1883 if (Var && Var->getName() == Vals[i].getName())
1887 if (bi == Bits.getNumBits())
1890 // Skip variables that correspond to explicitly-named operands.
1892 if (CGI.Operands.hasOperandNamed(Vals[i].getName(), OpIdx))
1895 // Get the bit range for this operand:
1896 unsigned bitStart = bi++, bitWidth = 1;
1897 for (; bi < Bits.getNumBits(); ++bi) {
1898 VarInit *Var = nullptr;
1899 VarBitInit *BI = dyn_cast<VarBitInit>(Bits.getBit(bi));
1901 Var = dyn_cast<VarInit>(BI->getBitVar());
1903 Var = dyn_cast<VarInit>(Bits.getBit(bi));
1908 if (Var->getName() != Vals[i].getName())
1914 unsigned NumberOps = CGI.Operands.size();
1915 while (NumberedOp < NumberOps &&
1916 (CGI.Operands.isFlatOperandNotEmitted(NumberedOp) ||
1917 (!NamedOpIndices.empty() && NamedOpIndices.count(
1918 CGI.Operands.getSubOperandNumber(NumberedOp).first))))
1921 OpIdx = NumberedOp++;
1923 // OpIdx now holds the ordered operand number of Vals[i].
1924 std::pair<unsigned, unsigned> SO =
1925 CGI.Operands.getSubOperandNumber(OpIdx);
1926 const std::string &Name = CGI.Operands[SO.first].Name;
1928 LLVM_DEBUG(dbgs() << "Numbered operand mapping for " << Def.getName()
1929 << ": " << Name << "(" << SO.first << ", " << SO.second
1930 << ") => " << Vals[i].getName() << "\n");
1932 std::string Decoder;
1933 Record *TypeRecord = CGI.Operands[SO.first].Rec;
1935 RecordVal *DecoderString = TypeRecord->getValue("DecoderMethod");
1936 StringInit *String = DecoderString ?
1937 dyn_cast<StringInit>(DecoderString->getValue()) : nullptr;
1938 if (String && String->getValue() != "")
1939 Decoder = String->getValue();
1941 if (Decoder == "" &&
1942 CGI.Operands[SO.first].MIOperandInfo &&
1943 CGI.Operands[SO.first].MIOperandInfo->getNumArgs()) {
1944 Init *Arg = CGI.Operands[SO.first].MIOperandInfo->
1946 if (DefInit *DI = cast<DefInit>(Arg))
1947 TypeRecord = DI->getDef();
1951 if (TypeRecord->isSubClassOf("RegisterOperand"))
1952 TypeRecord = TypeRecord->getValueAsDef("RegClass");
1953 if (TypeRecord->isSubClassOf("RegisterClass")) {
1954 Decoder = "Decode" + TypeRecord->getName().str() + "RegisterClass";
1956 } else if (TypeRecord->isSubClassOf("PointerLikeRegClass")) {
1957 Decoder = "DecodePointerLikeRegClass" +
1958 utostr(TypeRecord->getValueAsInt("RegClassKind"));
1962 DecoderString = TypeRecord->getValue("DecoderMethod");
1963 String = DecoderString ?
1964 dyn_cast<StringInit>(DecoderString->getValue()) : nullptr;
1965 if (!isReg && String && String->getValue() != "")
1966 Decoder = String->getValue();
1968 RecordVal *HasCompleteDecoderVal =
1969 TypeRecord->getValue("hasCompleteDecoder");
1970 BitInit *HasCompleteDecoderBit = HasCompleteDecoderVal ?
1971 dyn_cast<BitInit>(HasCompleteDecoderVal->getValue()) : nullptr;
1972 bool HasCompleteDecoder = HasCompleteDecoderBit ?
1973 HasCompleteDecoderBit->getValue() : true;
1975 OperandInfo OpInfo(Decoder, HasCompleteDecoder);
1976 OpInfo.addField(bitStart, bitWidth, 0);
1978 NumberedInsnOperands[Name].push_back(OpInfo);
1980 // FIXME: For complex operands with custom decoders we can't handle tied
1981 // sub-operands automatically. Skip those here and assume that this is
1982 // fixed up elsewhere.
1983 if (CGI.Operands[SO.first].MIOperandInfo &&
1984 CGI.Operands[SO.first].MIOperandInfo->getNumArgs() > 1 &&
1985 String && String->getValue() != "")
1986 NumberedInsnOperandsNoTie.insert(Name);
1990 // For each operand, see if we can figure out where it is encoded.
1991 for (const auto &Op : InOutOperands) {
1992 if (!NumberedInsnOperands[Op.second].empty()) {
1993 InsnOperands.insert(InsnOperands.end(),
1994 NumberedInsnOperands[Op.second].begin(),
1995 NumberedInsnOperands[Op.second].end());
1998 if (!NumberedInsnOperands[TiedNames[Op.second]].empty()) {
1999 if (!NumberedInsnOperandsNoTie.count(TiedNames[Op.second])) {
2000 // Figure out to which (sub)operand we're tied.
2001 unsigned i = CGI.Operands.getOperandNamed(TiedNames[Op.second]);
2002 int tiedTo = CGI.Operands[i].getTiedRegister();
2004 i = CGI.Operands.getOperandNamed(Op.second);
2005 tiedTo = CGI.Operands[i].getTiedRegister();
2009 std::pair<unsigned, unsigned> SO =
2010 CGI.Operands.getSubOperandNumber(tiedTo);
2012 InsnOperands.push_back(NumberedInsnOperands[TiedNames[Op.second]]
2019 TypedInit *TI = cast<TypedInit>(Op.first);
2021 // At this point, we can locate the decoder field, but we need to know how
2022 // to interpret it. As a first step, require the target to provide
2023 // callbacks for decoding register classes.
2024 std::string Decoder = findOperandDecoderMethod(TI);
2025 Record *TypeRecord = cast<DefInit>(TI)->getDef();
2027 RecordVal *HasCompleteDecoderVal =
2028 TypeRecord->getValue("hasCompleteDecoder");
2029 BitInit *HasCompleteDecoderBit = HasCompleteDecoderVal ?
2030 dyn_cast<BitInit>(HasCompleteDecoderVal->getValue()) : nullptr;
2031 bool HasCompleteDecoder = HasCompleteDecoderBit ?
2032 HasCompleteDecoderBit->getValue() : true;
2034 OperandInfo OpInfo(Decoder, HasCompleteDecoder);
2036 // Some bits of the operand may be required to be 1 depending on the
2037 // instruction's encoding. Collect those bits.
2038 if (const RecordVal *EncodedValue = EncodingDef.getValue(Op.second))
2039 if (const BitsInit *OpBits = dyn_cast<BitsInit>(EncodedValue->getValue()))
2040 for (unsigned I = 0; I < OpBits->getNumBits(); ++I)
2041 if (const BitInit *OpBit = dyn_cast<BitInit>(OpBits->getBit(I)))
2042 if (OpBit->getValue())
2043 OpInfo.InitValue |= 1ULL << I;
2045 unsigned Base = ~0U;
2047 unsigned Offset = 0;
2049 for (unsigned bi = 0; bi < Bits.getNumBits(); ++bi) {
2050 VarInit *Var = nullptr;
2051 VarBitInit *BI = dyn_cast<VarBitInit>(Bits.getBit(bi));
2053 Var = dyn_cast<VarInit>(BI->getBitVar());
2055 Var = dyn_cast<VarInit>(Bits.getBit(bi));
2059 OpInfo.addField(Base, Width, Offset);
2067 if (Var->getName() != Op.second &&
2068 Var->getName() != TiedNames[Op.second]) {
2070 OpInfo.addField(Base, Width, Offset);
2081 Offset = BI ? BI->getBitNum() : 0;
2082 } else if (BI && BI->getBitNum() != Offset + Width) {
2083 OpInfo.addField(Base, Width, Offset);
2086 Offset = BI->getBitNum();
2093 OpInfo.addField(Base, Width, Offset);
2095 if (OpInfo.numFields() > 0)
2096 InsnOperands.push_back(OpInfo);
2099 Operands[Opc] = InsnOperands;
2103 // Dumps the instruction encoding bits.
2104 dumpBits(errs(), Bits);
2108 // Dumps the list of operand info.
2109 for (unsigned i = 0, e = CGI.Operands.size(); i != e; ++i) {
2110 const CGIOperandList::OperandInfo &Info = CGI.Operands[i];
2111 const std::string &OperandName = Info.Name;
2112 const Record &OperandDef = *Info.Rec;
2114 errs() << "\t" << OperandName << " (" << OperandDef.getName() << ")\n";
2122 // emitFieldFromInstruction - Emit the templated helper function
2123 // fieldFromInstruction().
2124 // On Windows we make sure that this function is not inlined when
2125 // using the VS compiler. It has a bug which causes the function
2126 // to be optimized out in some circustances. See llvm.org/pr38292
2127 static void emitFieldFromInstruction(formatted_raw_ostream &OS) {
2128 OS << "// Helper functions for extracting fields from encoded instructions.\n"
2129 << "// InsnType must either be integral or an APInt-like object that "
2131 << "// * Have a static const max_size_in_bits equal to the number of bits "
2134 << "// * be default-constructible and copy-constructible\n"
2135 << "// * be constructible from a uint64_t\n"
2136 << "// * be constructible from an APInt (this can be private)\n"
2137 << "// * Support getBitsSet(loBit, hiBit)\n"
2138 << "// * be convertible to uint64_t\n"
2139 << "// * Support the ~, &, ==, !=, and |= operators with other objects of "
2141 << "// * Support shift (<<, >>) with signed and unsigned integers on the "
2143 << "// * Support put (<<) to raw_ostream&\n"
2144 << "template<typename InsnType>\n"
2145 << "#if defined(_MSC_VER) && !defined(__clang__)\n"
2146 << "__declspec(noinline)\n"
2148 << "static InsnType fieldFromInstruction(InsnType insn, unsigned "
2150 << " unsigned numBits, "
2151 "std::true_type) {\n"
2152 << " assert(startBit + numBits <= 64 && \"Cannot support >64-bit "
2153 "extractions!\");\n"
2154 << " assert(startBit + numBits <= (sizeof(InsnType) * 8) &&\n"
2155 << " \"Instruction field out of bounds!\");\n"
2156 << " InsnType fieldMask;\n"
2157 << " if (numBits == sizeof(InsnType) * 8)\n"
2158 << " fieldMask = (InsnType)(-1LL);\n"
2160 << " fieldMask = (((InsnType)1 << numBits) - 1) << startBit;\n"
2161 << " return (insn & fieldMask) >> startBit;\n"
2164 << "template<typename InsnType>\n"
2165 << "static InsnType fieldFromInstruction(InsnType insn, unsigned "
2167 << " unsigned numBits, "
2168 "std::false_type) {\n"
2169 << " assert(startBit + numBits <= InsnType::max_size_in_bits && "
2170 "\"Instruction field out of bounds!\");\n"
2171 << " InsnType fieldMask = InsnType::getBitsSet(0, numBits);\n"
2172 << " return (insn >> startBit) & fieldMask;\n"
2175 << "template<typename InsnType>\n"
2176 << "static InsnType fieldFromInstruction(InsnType insn, unsigned "
2178 << " unsigned numBits) {\n"
2179 << " return fieldFromInstruction(insn, startBit, numBits, "
2180 "std::is_integral<InsnType>());\n"
2184 // emitDecodeInstruction - Emit the templated helper function
2185 // decodeInstruction().
2186 static void emitDecodeInstruction(formatted_raw_ostream &OS) {
2187 OS << "template<typename InsnType>\n"
2188 << "static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], "
2190 << " InsnType insn, uint64_t "
2192 << " const void *DisAsm,\n"
2193 << " const MCSubtargetInfo &STI) {\n"
2194 << " const FeatureBitset& Bits = STI.getFeatureBits();\n"
2196 << " const uint8_t *Ptr = DecodeTable;\n"
2197 << " InsnType CurFieldValue = 0;\n"
2198 << " DecodeStatus S = MCDisassembler::Success;\n"
2199 << " while (true) {\n"
2200 << " ptrdiff_t Loc = Ptr - DecodeTable;\n"
2201 << " switch (*Ptr) {\n"
2203 << " errs() << Loc << \": Unexpected decode table opcode!\\n\";\n"
2204 << " return MCDisassembler::Fail;\n"
2205 << " case MCD::OPC_ExtractField: {\n"
2206 << " unsigned Start = *++Ptr;\n"
2207 << " unsigned Len = *++Ptr;\n"
2209 << " CurFieldValue = fieldFromInstruction(insn, Start, Len);\n"
2210 << " LLVM_DEBUG(dbgs() << Loc << \": OPC_ExtractField(\" << Start << "
2212 << " << Len << \"): \" << CurFieldValue << \"\\n\");\n"
2215 << " case MCD::OPC_FilterValue: {\n"
2216 << " // Decode the field value.\n"
2217 << " unsigned Len;\n"
2218 << " InsnType Val = decodeULEB128(++Ptr, &Len);\n"
2220 << " // NumToSkip is a plain 24-bit integer.\n"
2221 << " unsigned NumToSkip = *Ptr++;\n"
2222 << " NumToSkip |= (*Ptr++) << 8;\n"
2223 << " NumToSkip |= (*Ptr++) << 16;\n"
2225 << " // Perform the filter operation.\n"
2226 << " if (Val != CurFieldValue)\n"
2227 << " Ptr += NumToSkip;\n"
2228 << " LLVM_DEBUG(dbgs() << Loc << \": OPC_FilterValue(\" << Val << "
2229 "\", \" << NumToSkip\n"
2230 << " << \"): \" << ((Val != CurFieldValue) ? \"FAIL:\" "
2232 << " << \" continuing at \" << (Ptr - DecodeTable) << "
2237 << " case MCD::OPC_CheckField: {\n"
2238 << " unsigned Start = *++Ptr;\n"
2239 << " unsigned Len = *++Ptr;\n"
2240 << " InsnType FieldValue = fieldFromInstruction(insn, Start, Len);\n"
2241 << " // Decode the field value.\n"
2242 << " InsnType ExpectedValue = decodeULEB128(++Ptr, &Len);\n"
2244 << " // NumToSkip is a plain 24-bit integer.\n"
2245 << " unsigned NumToSkip = *Ptr++;\n"
2246 << " NumToSkip |= (*Ptr++) << 8;\n"
2247 << " NumToSkip |= (*Ptr++) << 16;\n"
2249 << " // If the actual and expected values don't match, skip.\n"
2250 << " if (ExpectedValue != FieldValue)\n"
2251 << " Ptr += NumToSkip;\n"
2252 << " LLVM_DEBUG(dbgs() << Loc << \": OPC_CheckField(\" << Start << "
2254 << " << Len << \", \" << ExpectedValue << \", \" << "
2256 << " << \"): FieldValue = \" << FieldValue << \", "
2257 "ExpectedValue = \"\n"
2258 << " << ExpectedValue << \": \"\n"
2259 << " << ((ExpectedValue == FieldValue) ? \"PASS\\n\" : "
2263 << " case MCD::OPC_CheckPredicate: {\n"
2264 << " unsigned Len;\n"
2265 << " // Decode the Predicate Index value.\n"
2266 << " unsigned PIdx = decodeULEB128(++Ptr, &Len);\n"
2268 << " // NumToSkip is a plain 24-bit integer.\n"
2269 << " unsigned NumToSkip = *Ptr++;\n"
2270 << " NumToSkip |= (*Ptr++) << 8;\n"
2271 << " NumToSkip |= (*Ptr++) << 16;\n"
2272 << " // Check the predicate.\n"
2274 << " if (!(Pred = checkDecoderPredicate(PIdx, Bits)))\n"
2275 << " Ptr += NumToSkip;\n"
2277 << " LLVM_DEBUG(dbgs() << Loc << \": OPC_CheckPredicate(\" << PIdx "
2279 << " << (Pred ? \"PASS\\n\" : \"FAIL\\n\"));\n"
2283 << " case MCD::OPC_Decode: {\n"
2284 << " unsigned Len;\n"
2285 << " // Decode the Opcode value.\n"
2286 << " unsigned Opc = decodeULEB128(++Ptr, &Len);\n"
2288 << " unsigned DecodeIdx = decodeULEB128(Ptr, &Len);\n"
2292 << " MI.setOpcode(Opc);\n"
2293 << " bool DecodeComplete;\n"
2294 << " S = decodeToMCInst(S, DecodeIdx, insn, MI, Address, DisAsm, "
2295 "DecodeComplete);\n"
2296 << " assert(DecodeComplete);\n"
2298 << " LLVM_DEBUG(dbgs() << Loc << \": OPC_Decode: opcode \" << Opc\n"
2299 << " << \", using decoder \" << DecodeIdx << \": \"\n"
2300 << " << (S != MCDisassembler::Fail ? \"PASS\" : "
2301 "\"FAIL\") << \"\\n\");\n"
2304 << " case MCD::OPC_TryDecode: {\n"
2305 << " unsigned Len;\n"
2306 << " // Decode the Opcode value.\n"
2307 << " unsigned Opc = decodeULEB128(++Ptr, &Len);\n"
2309 << " unsigned DecodeIdx = decodeULEB128(Ptr, &Len);\n"
2311 << " // NumToSkip is a plain 24-bit integer.\n"
2312 << " unsigned NumToSkip = *Ptr++;\n"
2313 << " NumToSkip |= (*Ptr++) << 8;\n"
2314 << " NumToSkip |= (*Ptr++) << 16;\n"
2316 << " // Perform the decode operation.\n"
2317 << " MCInst TmpMI;\n"
2318 << " TmpMI.setOpcode(Opc);\n"
2319 << " bool DecodeComplete;\n"
2320 << " S = decodeToMCInst(S, DecodeIdx, insn, TmpMI, Address, DisAsm, "
2321 "DecodeComplete);\n"
2322 << " LLVM_DEBUG(dbgs() << Loc << \": OPC_TryDecode: opcode \" << "
2324 << " << \", using decoder \" << DecodeIdx << \": \");\n"
2326 << " if (DecodeComplete) {\n"
2327 << " // Decoding complete.\n"
2328 << " LLVM_DEBUG(dbgs() << (S != MCDisassembler::Fail ? \"PASS\" : "
2329 "\"FAIL\") << \"\\n\");\n"
2333 << " assert(S == MCDisassembler::Fail);\n"
2334 << " // If the decoding was incomplete, skip.\n"
2335 << " Ptr += NumToSkip;\n"
2336 << " LLVM_DEBUG(dbgs() << \"FAIL: continuing at \" << (Ptr - "
2337 "DecodeTable) << \"\\n\");\n"
2338 << " // Reset decode status. This also drops a SoftFail status "
2340 << " // set before the decode attempt.\n"
2341 << " S = MCDisassembler::Success;\n"
2345 << " case MCD::OPC_SoftFail: {\n"
2346 << " // Decode the mask values.\n"
2347 << " unsigned Len;\n"
2348 << " InsnType PositiveMask = decodeULEB128(++Ptr, &Len);\n"
2350 << " InsnType NegativeMask = decodeULEB128(Ptr, &Len);\n"
2352 << " bool Fail = (insn & PositiveMask) || (~insn & NegativeMask);\n"
2354 << " S = MCDisassembler::SoftFail;\n"
2355 << " LLVM_DEBUG(dbgs() << Loc << \": OPC_SoftFail: \" << (Fail ? "
2356 "\"FAIL\\n\":\"PASS\\n\"));\n"
2359 << " case MCD::OPC_Fail: {\n"
2360 << " LLVM_DEBUG(dbgs() << Loc << \": OPC_Fail\\n\");\n"
2361 << " return MCDisassembler::Fail;\n"
2365 << " llvm_unreachable(\"bogosity detected in disassembler state "
2370 // Emits disassembler code for instruction decoding.
2371 void FixedLenDecoderEmitter::run(raw_ostream &o) {
2372 formatted_raw_ostream OS(o);
2373 OS << "#include \"llvm/MC/MCInst.h\"\n";
2374 OS << "#include \"llvm/Support/Debug.h\"\n";
2375 OS << "#include \"llvm/Support/DataTypes.h\"\n";
2376 OS << "#include \"llvm/Support/LEB128.h\"\n";
2377 OS << "#include \"llvm/Support/raw_ostream.h\"\n";
2378 OS << "#include <assert.h>\n";
2380 OS << "namespace llvm {\n\n";
2382 emitFieldFromInstruction(OS);
2384 Target.reverseBitsForLittleEndianEncoding();
2386 // Parameterize the decoders based on namespace and instruction width.
2387 std::set<StringRef> HwModeNames;
2388 const auto &NumberedInstructions = Target.getInstructionsByEnumValue();
2389 NumberedEncodings.reserve(NumberedInstructions.size());
2390 DenseMap<Record *, unsigned> IndexOfInstruction;
2391 // First, collect all HwModes referenced by the target.
2392 for (const auto &NumberedInstruction : NumberedInstructions) {
2393 IndexOfInstruction[NumberedInstruction->TheDef] = NumberedEncodings.size();
2395 if (const RecordVal *RV =
2396 NumberedInstruction->TheDef->getValue("EncodingInfos")) {
2397 if (auto *DI = dyn_cast_or_null<DefInit>(RV->getValue())) {
2398 const CodeGenHwModes &HWM = Target.getHwModes();
2399 EncodingInfoByHwMode EBM(DI->getDef(), HWM);
2400 for (auto &KV : EBM.Map)
2401 HwModeNames.insert(HWM.getMode(KV.first).Name);
2406 // If HwModeNames is empty, add the empty string so we always have one HwMode.
2407 if (HwModeNames.empty())
2408 HwModeNames.insert("");
2410 for (const auto &NumberedInstruction : NumberedInstructions) {
2411 IndexOfInstruction[NumberedInstruction->TheDef] = NumberedEncodings.size();
2413 if (const RecordVal *RV =
2414 NumberedInstruction->TheDef->getValue("EncodingInfos")) {
2415 if (DefInit *DI = dyn_cast_or_null<DefInit>(RV->getValue())) {
2416 const CodeGenHwModes &HWM = Target.getHwModes();
2417 EncodingInfoByHwMode EBM(DI->getDef(), HWM);
2418 for (auto &KV : EBM.Map) {
2419 NumberedEncodings.emplace_back(KV.second, NumberedInstruction,
2420 HWM.getMode(KV.first).Name);
2421 HwModeNames.insert(HWM.getMode(KV.first).Name);
2426 // This instruction is encoded the same on all HwModes. Emit it for all
2428 for (StringRef HwModeName : HwModeNames)
2429 NumberedEncodings.emplace_back(NumberedInstruction->TheDef,
2430 NumberedInstruction, HwModeName);
2432 for (const auto &NumberedAlias : RK.getAllDerivedDefinitions("AdditionalEncoding"))
2433 NumberedEncodings.emplace_back(
2435 &Target.getInstruction(NumberedAlias->getValueAsDef("AliasOf")));
2437 std::map<std::pair<std::string, unsigned>, std::vector<EncodingIDAndOpcode>>
2439 std::map<unsigned, std::vector<OperandInfo>> Operands;
2441 for (unsigned i = 0; i < NumberedEncodings.size(); ++i) {
2442 const Record *EncodingDef = NumberedEncodings[i].EncodingDef;
2443 const CodeGenInstruction *Inst = NumberedEncodings[i].Inst;
2444 const Record *Def = Inst->TheDef;
2445 unsigned Size = EncodingDef->getValueAsInt("Size");
2446 if (Def->getValueAsString("Namespace") == "TargetOpcode" ||
2447 Def->getValueAsBit("isPseudo") ||
2448 Def->getValueAsBit("isAsmParserOnly") ||
2449 Def->getValueAsBit("isCodeGenOnly")) {
2450 NumEncodingsLackingDisasm++;
2454 if (i < NumberedInstructions.size())
2461 if (populateInstruction(Target, *EncodingDef, *Inst, i, Operands)) {
2462 std::string DecoderNamespace =
2463 EncodingDef->getValueAsString("DecoderNamespace");
2464 if (!NumberedEncodings[i].HwModeName.empty())
2466 std::string("_") + NumberedEncodings[i].HwModeName.str();
2467 OpcMap[std::make_pair(DecoderNamespace, Size)].emplace_back(
2468 i, IndexOfInstruction.find(Def)->second);
2470 NumEncodingsOmitted++;
2474 DecoderTableInfo TableInfo;
2475 for (const auto &Opc : OpcMap) {
2476 // Emit the decoder for this namespace+width combination.
2477 ArrayRef<EncodingAndInst> NumberedEncodingsRef(
2478 NumberedEncodings.data(), NumberedEncodings.size());
2479 FilterChooser FC(NumberedEncodingsRef, Opc.second, Operands,
2480 8 * Opc.first.second, this);
2482 // The decode table is cleared for each top level decoder function. The
2483 // predicates and decoders themselves, however, are shared across all
2484 // decoders to give more opportunities for uniqueing.
2485 TableInfo.Table.clear();
2486 TableInfo.FixupStack.clear();
2487 TableInfo.Table.reserve(16384);
2488 TableInfo.FixupStack.emplace_back();
2489 FC.emitTableEntries(TableInfo);
2490 // Any NumToSkip fixups in the top level scope can resolve to the
2491 // OPC_Fail at the end of the table.
2492 assert(TableInfo.FixupStack.size() == 1 && "fixup stack phasing error!");
2493 // Resolve any NumToSkip fixups in the current scope.
2494 resolveTableFixups(TableInfo.Table, TableInfo.FixupStack.back(),
2495 TableInfo.Table.size());
2496 TableInfo.FixupStack.clear();
2498 TableInfo.Table.push_back(MCD::OPC_Fail);
2500 // Print the table to the output stream.
2501 emitTable(OS, TableInfo.Table, 0, FC.getBitWidth(), Opc.first.first);
2505 // Emit the predicate function.
2506 emitPredicateFunction(OS, TableInfo.Predicates, 0);
2508 // Emit the decoder function.
2509 emitDecoderFunction(OS, TableInfo.Decoders, 0);
2511 // Emit the main entry point for the decoder, decodeInstruction().
2512 emitDecodeInstruction(OS);
2514 OS << "\n} // end namespace llvm\n";
2519 void EmitFixedLenDecoder(RecordKeeper &RK, raw_ostream &OS,
2520 const std::string &PredicateNamespace,
2521 const std::string &GPrefix,
2522 const std::string &GPostfix, const std::string &ROK,
2523 const std::string &RFail, const std::string &L) {
2524 FixedLenDecoderEmitter(RK, PredicateNamespace, GPrefix, GPostfix,
2525 ROK, RFail, L).run(OS);
2528 } // end namespace llvm