1 //===------------ FixedLenDecoderEmitter.cpp - Decoder Generator ----------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // It contains the tablegen backend that emits the decoder functions for
11 // targets with fixed length instruction set.
13 //===----------------------------------------------------------------------===//
15 #include "CodeGenTarget.h"
16 #include "llvm/ADT/APInt.h"
17 #include "llvm/ADT/SmallString.h"
18 #include "llvm/ADT/StringExtras.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/ADT/Twine.h"
21 #include "llvm/MC/MCFixedLenDisassembler.h"
22 #include "llvm/Support/DataTypes.h"
23 #include "llvm/Support/Debug.h"
24 #include "llvm/Support/FormattedStream.h"
25 #include "llvm/Support/LEB128.h"
26 #include "llvm/Support/raw_ostream.h"
27 #include "llvm/TableGen/Error.h"
28 #include "llvm/TableGen/Record.h"
35 #define DEBUG_TYPE "decoder-emitter"
38 struct EncodingField
{
39 unsigned Base
, Width
, Offset
;
40 EncodingField(unsigned B
, unsigned W
, unsigned O
)
41 : Base(B
), Width(W
), Offset(O
) { }
45 std::vector
<EncodingField
> Fields
;
48 OperandInfo(std::string D
)
51 void addField(unsigned Base
, unsigned Width
, unsigned Offset
) {
52 Fields
.push_back(EncodingField(Base
, Width
, Offset
));
55 unsigned numFields() const { return Fields
.size(); }
57 typedef std::vector
<EncodingField
>::const_iterator const_iterator
;
59 const_iterator
begin() const { return Fields
.begin(); }
60 const_iterator
end() const { return Fields
.end(); }
63 typedef std::vector
<uint8_t> DecoderTable
;
64 typedef uint32_t DecoderFixup
;
65 typedef std::vector
<DecoderFixup
> FixupList
;
66 typedef std::vector
<FixupList
> FixupScopeList
;
67 typedef SetVector
<std::string
> PredicateSet
;
68 typedef SetVector
<std::string
> DecoderSet
;
69 struct DecoderTableInfo
{
71 FixupScopeList FixupStack
;
72 PredicateSet Predicates
;
76 } // End anonymous namespace
79 class FixedLenDecoderEmitter
{
80 const std::vector
<const CodeGenInstruction
*> *NumberedInstructions
;
83 // Defaults preserved here for documentation, even though they aren't
84 // strictly necessary given the way that this is currently being called.
85 FixedLenDecoderEmitter(RecordKeeper
&R
,
86 std::string PredicateNamespace
,
87 std::string GPrefix
= "if (",
88 std::string GPostfix
= " == MCDisassembler::Fail)"
89 " return MCDisassembler::Fail;",
90 std::string ROK
= "MCDisassembler::Success",
91 std::string RFail
= "MCDisassembler::Fail",
94 PredicateNamespace(PredicateNamespace
),
95 GuardPrefix(GPrefix
), GuardPostfix(GPostfix
),
96 ReturnOK(ROK
), ReturnFail(RFail
), Locals(L
) {}
98 // Emit the decoder state machine table.
99 void emitTable(formatted_raw_ostream
&o
, DecoderTable
&Table
,
100 unsigned Indentation
, unsigned BitWidth
,
101 StringRef Namespace
) const;
102 void emitPredicateFunction(formatted_raw_ostream
&OS
,
103 PredicateSet
&Predicates
,
104 unsigned Indentation
) const;
105 void emitDecoderFunction(formatted_raw_ostream
&OS
,
106 DecoderSet
&Decoders
,
107 unsigned Indentation
) const;
109 // run - Output the code emitter
110 void run(raw_ostream
&o
);
113 CodeGenTarget Target
;
115 std::string PredicateNamespace
;
116 std::string GuardPrefix
, GuardPostfix
;
117 std::string ReturnOK
, ReturnFail
;
120 } // End anonymous namespace
122 // The set (BIT_TRUE, BIT_FALSE, BIT_UNSET) represents a ternary logic system
125 // BIT_UNFILTERED is used as the init value for a filter position. It is used
126 // only for filter processings.
131 BIT_UNFILTERED
// unfiltered
134 static bool ValueSet(bit_value_t V
) {
135 return (V
== BIT_TRUE
|| V
== BIT_FALSE
);
137 static bool ValueNotSet(bit_value_t V
) {
138 return (V
== BIT_UNSET
);
140 static int Value(bit_value_t V
) {
141 return ValueNotSet(V
) ? -1 : (V
== BIT_FALSE
? 0 : 1);
143 static bit_value_t
bitFromBits(const BitsInit
&bits
, unsigned index
) {
144 if (BitInit
*bit
= dyn_cast
<BitInit
>(bits
.getBit(index
)))
145 return bit
->getValue() ? BIT_TRUE
: BIT_FALSE
;
147 // The bit is uninitialized.
150 // Prints the bit value for each position.
151 static void dumpBits(raw_ostream
&o
, const BitsInit
&bits
) {
152 for (unsigned index
= bits
.getNumBits(); index
> 0; --index
) {
153 switch (bitFromBits(bits
, index
- 1)) {
164 llvm_unreachable("unexpected return value from bitFromBits");
169 static BitsInit
&getBitsField(const Record
&def
, const char *str
) {
170 BitsInit
*bits
= def
.getValueAsBitsInit(str
);
174 // Forward declaration.
177 } // End anonymous namespace
179 // Representation of the instruction to work on.
180 typedef std::vector
<bit_value_t
> insn_t
;
182 /// Filter - Filter works with FilterChooser to produce the decoding tree for
185 /// It is useful to think of a Filter as governing the switch stmts of the
186 /// decoding tree in a certain level. Each case stmt delegates to an inferior
187 /// FilterChooser to decide what further decoding logic to employ, or in another
188 /// words, what other remaining bits to look at. The FilterChooser eventually
189 /// chooses a best Filter to do its job.
191 /// This recursive scheme ends when the number of Opcodes assigned to the
192 /// FilterChooser becomes 1 or if there is a conflict. A conflict happens when
193 /// the Filter/FilterChooser combo does not know how to distinguish among the
194 /// Opcodes assigned.
196 /// An example of a conflict is
199 /// 111101000.00........00010000....
200 /// 111101000.00........0001........
201 /// 1111010...00........0001........
202 /// 1111010...00....................
203 /// 1111010.........................
204 /// 1111............................
205 /// ................................
206 /// VST4q8a 111101000_00________00010000____
207 /// VST4q8b 111101000_00________00010000____
209 /// The Debug output shows the path that the decoding tree follows to reach the
210 /// the conclusion that there is a conflict. VST4q8a is a vst4 to double-spaced
211 /// even registers, while VST4q8b is a vst4 to double-spaced odd regsisters.
213 /// The encoding info in the .td files does not specify this meta information,
214 /// which could have been used by the decoder to resolve the conflict. The
215 /// decoder could try to decode the even/odd register numbering and assign to
216 /// VST4q8a or VST4q8b, but for the time being, the decoder chooses the "a"
217 /// version and return the Opcode since the two have the same Asm format string.
221 const FilterChooser
*Owner
;// points to the FilterChooser who owns this filter
222 unsigned StartBit
; // the starting bit position
223 unsigned NumBits
; // number of bits to filter
224 bool Mixed
; // a mixed region contains both set and unset bits
226 // Map of well-known segment value to the set of uid's with that value.
227 std::map
<uint64_t, std::vector
<unsigned> > FilteredInstructions
;
229 // Set of uid's with non-constant segment values.
230 std::vector
<unsigned> VariableInstructions
;
232 // Map of well-known segment value to its delegate.
233 std::map
<unsigned, std::unique_ptr
<const FilterChooser
>> FilterChooserMap
;
235 // Number of instructions which fall under FilteredInstructions category.
236 unsigned NumFiltered
;
238 // Keeps track of the last opcode in the filtered bucket.
239 unsigned LastOpcFiltered
;
242 unsigned getNumFiltered() const { return NumFiltered
; }
243 unsigned getSingletonOpc() const {
244 assert(NumFiltered
== 1);
245 return LastOpcFiltered
;
247 // Return the filter chooser for the group of instructions without constant
249 const FilterChooser
&getVariableFC() const {
250 assert(NumFiltered
== 1);
251 assert(FilterChooserMap
.size() == 1);
252 return *(FilterChooserMap
.find((unsigned)-1)->second
);
256 Filter(FilterChooser
&owner
, unsigned startBit
, unsigned numBits
, bool mixed
);
260 // Divides the decoding task into sub tasks and delegates them to the
261 // inferior FilterChooser's.
263 // A special case arises when there's only one entry in the filtered
264 // instructions. In order to unambiguously decode the singleton, we need to
265 // match the remaining undecoded encoding bits against the singleton.
268 // Emit table entries to decode instructions given a segment or segments of
270 void emitTableEntry(DecoderTableInfo
&TableInfo
) const;
272 // Returns the number of fanout produced by the filter. More fanout implies
273 // the filter distinguishes more categories of instructions.
274 unsigned usefulness() const;
275 }; // End of class Filter
276 } // End anonymous namespace
278 // These are states of our finite state machines used in FilterChooser's
279 // filterProcessor() which produces the filter candidates to use.
288 /// FilterChooser - FilterChooser chooses the best filter among a set of Filters
289 /// in order to perform the decoding of instructions at the current level.
291 /// Decoding proceeds from the top down. Based on the well-known encoding bits
292 /// of instructions available, FilterChooser builds up the possible Filters that
293 /// can further the task of decoding by distinguishing among the remaining
294 /// candidate instructions.
296 /// Once a filter has been chosen, it is called upon to divide the decoding task
297 /// into sub-tasks and delegates them to its inferior FilterChoosers for further
300 /// It is useful to think of a Filter as governing the switch stmts of the
301 /// decoding tree. And each case is delegated to an inferior FilterChooser to
302 /// decide what further remaining bits to look at.
304 class FilterChooser
{
308 // Vector of codegen instructions to choose our filter.
309 const std::vector
<const CodeGenInstruction
*> &AllInstructions
;
311 // Vector of uid's for this filter chooser to work on.
312 const std::vector
<unsigned> &Opcodes
;
314 // Lookup table for the operand decoding of instructions.
315 const std::map
<unsigned, std::vector
<OperandInfo
> > &Operands
;
317 // Vector of candidate filters.
318 std::vector
<Filter
> Filters
;
320 // Array of bit values passed down from our parent.
321 // Set to all BIT_UNFILTERED's for Parent == NULL.
322 std::vector
<bit_value_t
> FilterBitValues
;
324 // Links to the FilterChooser above us in the decoding tree.
325 const FilterChooser
*Parent
;
327 // Index of the best filter from Filters.
330 // Width of instructions
334 const FixedLenDecoderEmitter
*Emitter
;
336 FilterChooser(const FilterChooser
&) LLVM_DELETED_FUNCTION
;
337 void operator=(const FilterChooser
&) LLVM_DELETED_FUNCTION
;
340 FilterChooser(const std::vector
<const CodeGenInstruction
*> &Insts
,
341 const std::vector
<unsigned> &IDs
,
342 const std::map
<unsigned, std::vector
<OperandInfo
> > &Ops
,
344 const FixedLenDecoderEmitter
*E
)
345 : AllInstructions(Insts
), Opcodes(IDs
), Operands(Ops
), Filters(),
346 FilterBitValues(BW
, BIT_UNFILTERED
), Parent(nullptr), BestIndex(-1),
347 BitWidth(BW
), Emitter(E
) {
351 FilterChooser(const std::vector
<const CodeGenInstruction
*> &Insts
,
352 const std::vector
<unsigned> &IDs
,
353 const std::map
<unsigned, std::vector
<OperandInfo
> > &Ops
,
354 const std::vector
<bit_value_t
> &ParentFilterBitValues
,
355 const FilterChooser
&parent
)
356 : AllInstructions(Insts
), Opcodes(IDs
), Operands(Ops
),
357 Filters(), FilterBitValues(ParentFilterBitValues
),
358 Parent(&parent
), BestIndex(-1), BitWidth(parent
.BitWidth
),
359 Emitter(parent
.Emitter
) {
363 unsigned getBitWidth() const { return BitWidth
; }
366 // Populates the insn given the uid.
367 void insnWithID(insn_t
&Insn
, unsigned Opcode
) const {
368 BitsInit
&Bits
= getBitsField(*AllInstructions
[Opcode
]->TheDef
, "Inst");
370 // We may have a SoftFail bitmask, which specifies a mask where an encoding
371 // may differ from the value in "Inst" and yet still be valid, but the
372 // disassembler should return SoftFail instead of Success.
374 // This is used for marking UNPREDICTABLE instructions in the ARM world.
376 AllInstructions
[Opcode
]->TheDef
->getValueAsBitsInit("SoftFail");
378 for (unsigned i
= 0; i
< BitWidth
; ++i
) {
379 if (SFBits
&& bitFromBits(*SFBits
, i
) == BIT_TRUE
)
380 Insn
.push_back(BIT_UNSET
);
382 Insn
.push_back(bitFromBits(Bits
, i
));
386 // Returns the record name.
387 const std::string
&nameWithID(unsigned Opcode
) const {
388 return AllInstructions
[Opcode
]->TheDef
->getName();
391 // Populates the field of the insn given the start position and the number of
392 // consecutive bits to scan for.
394 // Returns false if there exists any uninitialized bit value in the range.
395 // Returns true, otherwise.
396 bool fieldFromInsn(uint64_t &Field
, insn_t
&Insn
, unsigned StartBit
,
397 unsigned NumBits
) const;
399 /// dumpFilterArray - dumpFilterArray prints out debugging info for the given
400 /// filter array as a series of chars.
401 void dumpFilterArray(raw_ostream
&o
,
402 const std::vector
<bit_value_t
> & filter
) const;
404 /// dumpStack - dumpStack traverses the filter chooser chain and calls
405 /// dumpFilterArray on each filter chooser up to the top level one.
406 void dumpStack(raw_ostream
&o
, const char *prefix
) const;
408 Filter
&bestFilter() {
409 assert(BestIndex
!= -1 && "BestIndex not set");
410 return Filters
[BestIndex
];
413 // Called from Filter::recurse() when singleton exists. For debug purpose.
414 void SingletonExists(unsigned Opc
) const;
416 bool PositionFiltered(unsigned i
) const {
417 return ValueSet(FilterBitValues
[i
]);
420 // Calculates the island(s) needed to decode the instruction.
421 // This returns a lit of undecoded bits of an instructions, for example,
422 // Inst{20} = 1 && Inst{3-0} == 0b1111 represents two islands of yet-to-be
423 // decoded bits in order to verify that the instruction matches the Opcode.
424 unsigned getIslands(std::vector
<unsigned> &StartBits
,
425 std::vector
<unsigned> &EndBits
,
426 std::vector
<uint64_t> &FieldVals
,
427 const insn_t
&Insn
) const;
429 // Emits code to check the Predicates member of an instruction are true.
430 // Returns true if predicate matches were emitted, false otherwise.
431 bool emitPredicateMatch(raw_ostream
&o
, unsigned &Indentation
,
434 bool doesOpcodeNeedPredicate(unsigned Opc
) const;
435 unsigned getPredicateIndex(DecoderTableInfo
&TableInfo
, StringRef P
) const;
436 void emitPredicateTableEntry(DecoderTableInfo
&TableInfo
,
439 void emitSoftFailTableEntry(DecoderTableInfo
&TableInfo
,
442 // Emits table entries to decode the singleton.
443 void emitSingletonTableEntry(DecoderTableInfo
&TableInfo
,
446 // Emits code to decode the singleton, and then to decode the rest.
447 void emitSingletonTableEntry(DecoderTableInfo
&TableInfo
,
448 const Filter
&Best
) const;
450 void emitBinaryParser(raw_ostream
&o
, unsigned &Indentation
,
451 const OperandInfo
&OpInfo
) const;
453 void emitDecoder(raw_ostream
&OS
, unsigned Indentation
, unsigned Opc
) const;
454 unsigned getDecoderIndex(DecoderSet
&Decoders
, unsigned Opc
) const;
456 // Assign a single filter and run with it.
457 void runSingleFilter(unsigned startBit
, unsigned numBit
, bool mixed
);
459 // reportRegion is a helper function for filterProcessor to mark a region as
460 // eligible for use as a filter region.
461 void reportRegion(bitAttr_t RA
, unsigned StartBit
, unsigned BitIndex
,
464 // FilterProcessor scans the well-known encoding bits of the instructions and
465 // builds up a list of candidate filters. It chooses the best filter and
466 // recursively descends down the decoding tree.
467 bool filterProcessor(bool AllowMixed
, bool Greedy
= true);
469 // Decides on the best configuration of filter(s) to use in order to decode
470 // the instructions. A conflict of instructions may occur, in which case we
471 // dump the conflict set to the standard error.
475 // emitTableEntries - Emit state machine entries to decode our share of
477 void emitTableEntries(DecoderTableInfo
&TableInfo
) const;
479 } // End anonymous namespace
481 ///////////////////////////
483 // Filter Implementation //
485 ///////////////////////////
487 Filter::Filter(Filter
&&f
)
488 : Owner(f
.Owner
), StartBit(f
.StartBit
), NumBits(f
.NumBits
), Mixed(f
.Mixed
),
489 FilteredInstructions(std::move(f
.FilteredInstructions
)),
490 VariableInstructions(std::move(f
.VariableInstructions
)),
491 FilterChooserMap(std::move(f
.FilterChooserMap
)), NumFiltered(f
.NumFiltered
),
492 LastOpcFiltered(f
.LastOpcFiltered
) {
495 Filter::Filter(FilterChooser
&owner
, unsigned startBit
, unsigned numBits
,
497 : Owner(&owner
), StartBit(startBit
), NumBits(numBits
), Mixed(mixed
) {
498 assert(StartBit
+ NumBits
- 1 < Owner
->BitWidth
);
503 for (unsigned i
= 0, e
= Owner
->Opcodes
.size(); i
!= e
; ++i
) {
506 // Populates the insn given the uid.
507 Owner
->insnWithID(Insn
, Owner
->Opcodes
[i
]);
510 // Scans the segment for possibly well-specified encoding bits.
511 bool ok
= Owner
->fieldFromInsn(Field
, Insn
, StartBit
, NumBits
);
514 // The encoding bits are well-known. Lets add the uid of the
515 // instruction into the bucket keyed off the constant field value.
516 LastOpcFiltered
= Owner
->Opcodes
[i
];
517 FilteredInstructions
[Field
].push_back(LastOpcFiltered
);
520 // Some of the encoding bit(s) are unspecified. This contributes to
521 // one additional member of "Variable" instructions.
522 VariableInstructions
.push_back(Owner
->Opcodes
[i
]);
526 assert((FilteredInstructions
.size() + VariableInstructions
.size() > 0)
527 && "Filter returns no instruction categories");
533 // Divides the decoding task into sub tasks and delegates them to the
534 // inferior FilterChooser's.
536 // A special case arises when there's only one entry in the filtered
537 // instructions. In order to unambiguously decode the singleton, we need to
538 // match the remaining undecoded encoding bits against the singleton.
539 void Filter::recurse() {
540 // Starts by inheriting our parent filter chooser's filter bit values.
541 std::vector
<bit_value_t
> BitValueArray(Owner
->FilterBitValues
);
543 if (VariableInstructions
.size()) {
544 // Conservatively marks each segment position as BIT_UNSET.
545 for (unsigned bitIndex
= 0; bitIndex
< NumBits
; ++bitIndex
)
546 BitValueArray
[StartBit
+ bitIndex
] = BIT_UNSET
;
548 // Delegates to an inferior filter chooser for further processing on this
549 // group of instructions whose segment values are variable.
550 FilterChooserMap
.insert(
551 std::make_pair(-1U, llvm::make_unique
<FilterChooser
>(
552 Owner
->AllInstructions
, VariableInstructions
,
553 Owner
->Operands
, BitValueArray
, *Owner
)));
556 // No need to recurse for a singleton filtered instruction.
557 // See also Filter::emit*().
558 if (getNumFiltered() == 1) {
559 //Owner->SingletonExists(LastOpcFiltered);
560 assert(FilterChooserMap
.size() == 1);
564 // Otherwise, create sub choosers.
565 for (const auto &Inst
: FilteredInstructions
) {
567 // Marks all the segment positions with either BIT_TRUE or BIT_FALSE.
568 for (unsigned bitIndex
= 0; bitIndex
< NumBits
; ++bitIndex
) {
569 if (Inst
.first
& (1ULL << bitIndex
))
570 BitValueArray
[StartBit
+ bitIndex
] = BIT_TRUE
;
572 BitValueArray
[StartBit
+ bitIndex
] = BIT_FALSE
;
575 // Delegates to an inferior filter chooser for further processing on this
576 // category of instructions.
577 FilterChooserMap
.insert(std::make_pair(
578 Inst
.first
, llvm::make_unique
<FilterChooser
>(
579 Owner
->AllInstructions
, Inst
.second
,
580 Owner
->Operands
, BitValueArray
, *Owner
)));
584 static void resolveTableFixups(DecoderTable
&Table
, const FixupList
&Fixups
,
586 // Any NumToSkip fixups in the current scope can resolve to the
588 for (FixupList::const_reverse_iterator I
= Fixups
.rbegin(),
591 // Calculate the distance from the byte following the fixup entry byte
592 // to the destination. The Target is calculated from after the 16-bit
593 // NumToSkip entry itself, so subtract two from the displacement here
594 // to account for that.
595 uint32_t FixupIdx
= *I
;
596 uint32_t Delta
= DestIdx
- FixupIdx
- 2;
597 // Our NumToSkip entries are 16-bits. Make sure our table isn't too
599 assert(Delta
< 65536U && "disassembler decoding table too large!");
600 Table
[FixupIdx
] = (uint8_t)Delta
;
601 Table
[FixupIdx
+ 1] = (uint8_t)(Delta
>> 8);
605 // Emit table entries to decode instructions given a segment or segments
607 void Filter::emitTableEntry(DecoderTableInfo
&TableInfo
) const {
608 TableInfo
.Table
.push_back(MCD::OPC_ExtractField
);
609 TableInfo
.Table
.push_back(StartBit
);
610 TableInfo
.Table
.push_back(NumBits
);
612 // A new filter entry begins a new scope for fixup resolution.
613 TableInfo
.FixupStack
.push_back(FixupList());
615 DecoderTable
&Table
= TableInfo
.Table
;
617 size_t PrevFilter
= 0;
618 bool HasFallthrough
= false;
619 for (auto &Filter
: FilterChooserMap
) {
620 // Field value -1 implies a non-empty set of variable instructions.
621 // See also recurse().
622 if (Filter
.first
== (unsigned)-1) {
623 HasFallthrough
= true;
625 // Each scope should always have at least one filter value to check
627 assert(PrevFilter
!= 0 && "empty filter set!");
628 FixupList
&CurScope
= TableInfo
.FixupStack
.back();
629 // Resolve any NumToSkip fixups in the current scope.
630 resolveTableFixups(Table
, CurScope
, Table
.size());
632 PrevFilter
= 0; // Don't re-process the filter's fallthrough.
634 Table
.push_back(MCD::OPC_FilterValue
);
635 // Encode and emit the value to filter against.
637 unsigned Len
= encodeULEB128(Filter
.first
, Buffer
);
638 Table
.insert(Table
.end(), Buffer
, Buffer
+ Len
);
639 // Reserve space for the NumToSkip entry. We'll backpatch the value
641 PrevFilter
= Table
.size();
646 // We arrive at a category of instructions with the same segment value.
647 // Now delegate to the sub filter chooser for further decodings.
648 // The case may fallthrough, which happens if the remaining well-known
649 // encoding bits do not match exactly.
650 Filter
.second
->emitTableEntries(TableInfo
);
652 // Now that we've emitted the body of the handler, update the NumToSkip
653 // of the filter itself to be able to skip forward when false. Subtract
654 // two as to account for the width of the NumToSkip field itself.
656 uint32_t NumToSkip
= Table
.size() - PrevFilter
- 2;
657 assert(NumToSkip
< 65536U && "disassembler decoding table too large!");
658 Table
[PrevFilter
] = (uint8_t)NumToSkip
;
659 Table
[PrevFilter
+ 1] = (uint8_t)(NumToSkip
>> 8);
663 // Any remaining unresolved fixups bubble up to the parent fixup scope.
664 assert(TableInfo
.FixupStack
.size() > 1 && "fixup stack underflow!");
665 FixupScopeList::iterator Source
= TableInfo
.FixupStack
.end() - 1;
666 FixupScopeList::iterator Dest
= Source
- 1;
667 Dest
->insert(Dest
->end(), Source
->begin(), Source
->end());
668 TableInfo
.FixupStack
.pop_back();
670 // If there is no fallthrough, then the final filter should get fixed
671 // up according to the enclosing scope rather than the current position.
673 TableInfo
.FixupStack
.back().push_back(PrevFilter
);
676 // Returns the number of fanout produced by the filter. More fanout implies
677 // the filter distinguishes more categories of instructions.
678 unsigned Filter::usefulness() const {
679 if (VariableInstructions
.size())
680 return FilteredInstructions
.size();
682 return FilteredInstructions
.size() + 1;
685 //////////////////////////////////
687 // Filterchooser Implementation //
689 //////////////////////////////////
691 // Emit the decoder state machine table.
692 void FixedLenDecoderEmitter::emitTable(formatted_raw_ostream
&OS
,
694 unsigned Indentation
,
696 StringRef Namespace
) const {
697 OS
.indent(Indentation
) << "static const uint8_t DecoderTable" << Namespace
698 << BitWidth
<< "[] = {\n";
702 // FIXME: We may be able to use the NumToSkip values to recover
703 // appropriate indentation levels.
704 DecoderTable::const_iterator I
= Table
.begin();
705 DecoderTable::const_iterator E
= Table
.end();
707 assert (I
< E
&& "incomplete decode table entry!");
709 uint64_t Pos
= I
- Table
.begin();
710 OS
<< "/* " << Pos
<< " */";
715 PrintFatalError("invalid decode table opcode");
716 case MCD::OPC_ExtractField
: {
718 unsigned Start
= *I
++;
720 OS
.indent(Indentation
) << "MCD::OPC_ExtractField, " << Start
<< ", "
721 << Len
<< ", // Inst{";
723 OS
<< (Start
+ Len
- 1) << "-";
724 OS
<< Start
<< "} ...\n";
727 case MCD::OPC_FilterValue
: {
729 OS
.indent(Indentation
) << "MCD::OPC_FilterValue, ";
730 // The filter value is ULEB128 encoded.
732 OS
<< utostr(*I
++) << ", ";
733 OS
<< utostr(*I
++) << ", ";
735 // 16-bit numtoskip value.
737 uint32_t NumToSkip
= Byte
;
738 OS
<< utostr(Byte
) << ", ";
740 OS
<< utostr(Byte
) << ", ";
741 NumToSkip
|= Byte
<< 8;
742 OS
<< "// Skip to: " << ((I
- Table
.begin()) + NumToSkip
) << "\n";
745 case MCD::OPC_CheckField
: {
747 unsigned Start
= *I
++;
749 OS
.indent(Indentation
) << "MCD::OPC_CheckField, " << Start
<< ", "
750 << Len
<< ", ";// << Val << ", " << NumToSkip << ",\n";
751 // ULEB128 encoded field value.
752 for (; *I
>= 128; ++I
)
753 OS
<< utostr(*I
) << ", ";
754 OS
<< utostr(*I
++) << ", ";
755 // 16-bit numtoskip value.
757 uint32_t NumToSkip
= Byte
;
758 OS
<< utostr(Byte
) << ", ";
760 OS
<< utostr(Byte
) << ", ";
761 NumToSkip
|= Byte
<< 8;
762 OS
<< "// Skip to: " << ((I
- Table
.begin()) + NumToSkip
) << "\n";
765 case MCD::OPC_CheckPredicate
: {
767 OS
.indent(Indentation
) << "MCD::OPC_CheckPredicate, ";
768 for (; *I
>= 128; ++I
)
769 OS
<< utostr(*I
) << ", ";
770 OS
<< utostr(*I
++) << ", ";
772 // 16-bit numtoskip value.
774 uint32_t NumToSkip
= Byte
;
775 OS
<< utostr(Byte
) << ", ";
777 OS
<< utostr(Byte
) << ", ";
778 NumToSkip
|= Byte
<< 8;
779 OS
<< "// Skip to: " << ((I
- Table
.begin()) + NumToSkip
) << "\n";
782 case MCD::OPC_Decode
: {
784 // Extract the ULEB128 encoded Opcode to a buffer.
785 uint8_t Buffer
[8], *p
= Buffer
;
786 while ((*p
++ = *I
++) >= 128)
787 assert((p
- Buffer
) <= (ptrdiff_t)sizeof(Buffer
)
788 && "ULEB128 value too large!");
789 // Decode the Opcode value.
790 unsigned Opc
= decodeULEB128(Buffer
);
791 OS
.indent(Indentation
) << "MCD::OPC_Decode, ";
792 for (p
= Buffer
; *p
>= 128; ++p
)
793 OS
<< utostr(*p
) << ", ";
794 OS
<< utostr(*p
) << ", ";
797 for (; *I
>= 128; ++I
)
798 OS
<< utostr(*I
) << ", ";
799 OS
<< utostr(*I
++) << ", ";
802 << NumberedInstructions
->at(Opc
)->TheDef
->getName() << "\n";
805 case MCD::OPC_SoftFail
: {
807 OS
.indent(Indentation
) << "MCD::OPC_SoftFail";
812 OS
<< ", " << utostr(*I
);
813 Value
+= (*I
& 0x7f) << Shift
;
815 } while (*I
++ >= 128);
817 OS
<< " /* 0x" << utohexstr(Value
) << " */";
822 OS
<< ", " << utostr(*I
);
823 Value
+= (*I
& 0x7f) << Shift
;
825 } while (*I
++ >= 128);
827 OS
<< " /* 0x" << utohexstr(Value
) << " */";
831 case MCD::OPC_Fail
: {
833 OS
.indent(Indentation
) << "MCD::OPC_Fail,\n";
838 OS
.indent(Indentation
) << "0\n";
842 OS
.indent(Indentation
) << "};\n\n";
845 void FixedLenDecoderEmitter::
846 emitPredicateFunction(formatted_raw_ostream
&OS
, PredicateSet
&Predicates
,
847 unsigned Indentation
) const {
848 // The predicate function is just a big switch statement based on the
849 // input predicate index.
850 OS
.indent(Indentation
) << "static bool checkDecoderPredicate(unsigned Idx, "
851 << "uint64_t Bits) {\n";
853 if (!Predicates
.empty()) {
854 OS
.indent(Indentation
) << "switch (Idx) {\n";
855 OS
.indent(Indentation
) << "default: llvm_unreachable(\"Invalid index!\");\n";
857 for (const auto &Predicate
: Predicates
) {
858 OS
.indent(Indentation
) << "case " << Index
++ << ":\n";
859 OS
.indent(Indentation
+2) << "return (" << Predicate
<< ");\n";
861 OS
.indent(Indentation
) << "}\n";
863 // No case statement to emit
864 OS
.indent(Indentation
) << "llvm_unreachable(\"Invalid index!\");\n";
867 OS
.indent(Indentation
) << "}\n\n";
870 void FixedLenDecoderEmitter::
871 emitDecoderFunction(formatted_raw_ostream
&OS
, DecoderSet
&Decoders
,
872 unsigned Indentation
) const {
873 // The decoder function is just a big switch statement based on the
874 // input decoder index.
875 OS
.indent(Indentation
) << "template<typename InsnType>\n";
876 OS
.indent(Indentation
) << "static DecodeStatus decodeToMCInst(DecodeStatus S,"
877 << " unsigned Idx, InsnType insn, MCInst &MI,\n";
878 OS
.indent(Indentation
) << " uint64_t "
879 << "Address, const void *Decoder) {\n";
881 OS
.indent(Indentation
) << "InsnType tmp;\n";
882 OS
.indent(Indentation
) << "switch (Idx) {\n";
883 OS
.indent(Indentation
) << "default: llvm_unreachable(\"Invalid index!\");\n";
885 for (const auto &Decoder
: Decoders
) {
886 OS
.indent(Indentation
) << "case " << Index
++ << ":\n";
888 OS
.indent(Indentation
+2) << "return S;\n";
890 OS
.indent(Indentation
) << "}\n";
892 OS
.indent(Indentation
) << "}\n\n";
895 // Populates the field of the insn given the start position and the number of
896 // consecutive bits to scan for.
898 // Returns false if and on the first uninitialized bit value encountered.
899 // Returns true, otherwise.
900 bool FilterChooser::fieldFromInsn(uint64_t &Field
, insn_t
&Insn
,
901 unsigned StartBit
, unsigned NumBits
) const {
904 for (unsigned i
= 0; i
< NumBits
; ++i
) {
905 if (Insn
[StartBit
+ i
] == BIT_UNSET
)
908 if (Insn
[StartBit
+ i
] == BIT_TRUE
)
909 Field
= Field
| (1ULL << i
);
915 /// dumpFilterArray - dumpFilterArray prints out debugging info for the given
916 /// filter array as a series of chars.
917 void FilterChooser::dumpFilterArray(raw_ostream
&o
,
918 const std::vector
<bit_value_t
> &filter
) const {
919 for (unsigned bitIndex
= BitWidth
; bitIndex
> 0; bitIndex
--) {
920 switch (filter
[bitIndex
- 1]) {
937 /// dumpStack - dumpStack traverses the filter chooser chain and calls
938 /// dumpFilterArray on each filter chooser up to the top level one.
939 void FilterChooser::dumpStack(raw_ostream
&o
, const char *prefix
) const {
940 const FilterChooser
*current
= this;
944 dumpFilterArray(o
, current
->FilterBitValues
);
946 current
= current
->Parent
;
950 // Called from Filter::recurse() when singleton exists. For debug purpose.
951 void FilterChooser::SingletonExists(unsigned Opc
) const {
953 insnWithID(Insn0
, Opc
);
955 errs() << "Singleton exists: " << nameWithID(Opc
)
956 << " with its decoding dominating ";
957 for (unsigned i
= 0; i
< Opcodes
.size(); ++i
) {
958 if (Opcodes
[i
] == Opc
) continue;
959 errs() << nameWithID(Opcodes
[i
]) << ' ';
963 dumpStack(errs(), "\t\t");
964 for (unsigned i
= 0; i
< Opcodes
.size(); ++i
) {
965 const std::string
&Name
= nameWithID(Opcodes
[i
]);
967 errs() << '\t' << Name
<< " ";
969 getBitsField(*AllInstructions
[Opcodes
[i
]]->TheDef
, "Inst"));
974 // Calculates the island(s) needed to decode the instruction.
975 // This returns a list of undecoded bits of an instructions, for example,
976 // Inst{20} = 1 && Inst{3-0} == 0b1111 represents two islands of yet-to-be
977 // decoded bits in order to verify that the instruction matches the Opcode.
978 unsigned FilterChooser::getIslands(std::vector
<unsigned> &StartBits
,
979 std::vector
<unsigned> &EndBits
,
980 std::vector
<uint64_t> &FieldVals
,
981 const insn_t
&Insn
) const {
985 uint64_t FieldVal
= 0;
988 // 1: Water (the bit value does not affect decoding)
989 // 2: Island (well-known bit value needed for decoding)
993 for (unsigned i
= 0; i
< BitWidth
; ++i
) {
994 Val
= Value(Insn
[i
]);
995 bool Filtered
= PositionFiltered(i
);
997 default: llvm_unreachable("Unreachable code!");
1000 if (Filtered
|| Val
== -1)
1001 State
= 1; // Still in Water
1003 State
= 2; // Into the Island
1005 StartBits
.push_back(i
);
1010 if (Filtered
|| Val
== -1) {
1011 State
= 1; // Into the Water
1012 EndBits
.push_back(i
- 1);
1013 FieldVals
.push_back(FieldVal
);
1016 State
= 2; // Still in Island
1018 FieldVal
= FieldVal
| Val
<< BitNo
;
1023 // If we are still in Island after the loop, do some housekeeping.
1025 EndBits
.push_back(BitWidth
- 1);
1026 FieldVals
.push_back(FieldVal
);
1030 assert(StartBits
.size() == Num
&& EndBits
.size() == Num
&&
1031 FieldVals
.size() == Num
);
1035 void FilterChooser::emitBinaryParser(raw_ostream
&o
, unsigned &Indentation
,
1036 const OperandInfo
&OpInfo
) const {
1037 const std::string
&Decoder
= OpInfo
.Decoder
;
1039 if (OpInfo
.numFields() != 1)
1040 o
.indent(Indentation
) << "tmp = 0;\n";
1042 for (const EncodingField
&EF
: OpInfo
) {
1043 o
.indent(Indentation
) << "tmp ";
1044 if (OpInfo
.numFields() != 1) o
<< '|';
1045 o
<< "= fieldFromInstruction"
1046 << "(insn, " << EF
.Base
<< ", " << EF
.Width
<< ')';
1047 if (OpInfo
.numFields() != 1 || EF
.Offset
!= 0)
1048 o
<< " << " << EF
.Offset
;
1053 o
.indent(Indentation
) << Emitter
->GuardPrefix
<< Decoder
1054 << "(MI, tmp, Address, Decoder)"
1055 << Emitter
->GuardPostfix
<< "\n";
1057 o
.indent(Indentation
) << "MI.addOperand(MCOperand::CreateImm(tmp));\n";
1061 void FilterChooser::emitDecoder(raw_ostream
&OS
, unsigned Indentation
,
1062 unsigned Opc
) const {
1063 for (const auto &Op
: Operands
.find(Opc
)->second
) {
1064 // If a custom instruction decoder was specified, use that.
1065 if (Op
.numFields() == 0 && Op
.Decoder
.size()) {
1066 OS
.indent(Indentation
) << Emitter
->GuardPrefix
<< Op
.Decoder
1067 << "(MI, insn, Address, Decoder)"
1068 << Emitter
->GuardPostfix
<< "\n";
1072 emitBinaryParser(OS
, Indentation
, Op
);
1076 unsigned FilterChooser::getDecoderIndex(DecoderSet
&Decoders
,
1077 unsigned Opc
) const {
1078 // Build up the predicate string.
1079 SmallString
<256> Decoder
;
1080 // FIXME: emitDecoder() function can take a buffer directly rather than
1082 raw_svector_ostream
S(Decoder
);
1084 emitDecoder(S
, I
, Opc
);
1087 // Using the full decoder string as the key value here is a bit
1088 // heavyweight, but is effective. If the string comparisons become a
1089 // performance concern, we can implement a mangling of the predicate
1090 // data easilly enough with a map back to the actual string. That's
1091 // overkill for now, though.
1093 // Make sure the predicate is in the table.
1094 Decoders
.insert(Decoder
.str());
1095 // Now figure out the index for when we write out the table.
1096 DecoderSet::const_iterator P
= std::find(Decoders
.begin(),
1099 return (unsigned)(P
- Decoders
.begin());
1102 static void emitSinglePredicateMatch(raw_ostream
&o
, StringRef str
,
1103 const std::string
&PredicateNamespace
) {
1105 o
<< "!(Bits & " << PredicateNamespace
<< "::"
1106 << str
.slice(1,str
.size()) << ")";
1108 o
<< "(Bits & " << PredicateNamespace
<< "::" << str
<< ")";
1111 bool FilterChooser::emitPredicateMatch(raw_ostream
&o
, unsigned &Indentation
,
1112 unsigned Opc
) const {
1113 ListInit
*Predicates
=
1114 AllInstructions
[Opc
]->TheDef
->getValueAsListInit("Predicates");
1115 for (unsigned i
= 0; i
< Predicates
->getSize(); ++i
) {
1116 Record
*Pred
= Predicates
->getElementAsRecord(i
);
1117 if (!Pred
->getValue("AssemblerMatcherPredicate"))
1120 std::string P
= Pred
->getValueAsString("AssemblerCondString");
1129 std::pair
<StringRef
, StringRef
> pairs
= SR
.split(',');
1130 while (pairs
.second
.size()) {
1131 emitSinglePredicateMatch(o
, pairs
.first
, Emitter
->PredicateNamespace
);
1133 pairs
= pairs
.second
.split(',');
1135 emitSinglePredicateMatch(o
, pairs
.first
, Emitter
->PredicateNamespace
);
1137 return Predicates
->getSize() > 0;
1140 bool FilterChooser::doesOpcodeNeedPredicate(unsigned Opc
) const {
1141 ListInit
*Predicates
=
1142 AllInstructions
[Opc
]->TheDef
->getValueAsListInit("Predicates");
1143 for (unsigned i
= 0; i
< Predicates
->getSize(); ++i
) {
1144 Record
*Pred
= Predicates
->getElementAsRecord(i
);
1145 if (!Pred
->getValue("AssemblerMatcherPredicate"))
1148 std::string P
= Pred
->getValueAsString("AssemblerCondString");
1158 unsigned FilterChooser::getPredicateIndex(DecoderTableInfo
&TableInfo
,
1159 StringRef Predicate
) const {
1160 // Using the full predicate string as the key value here is a bit
1161 // heavyweight, but is effective. If the string comparisons become a
1162 // performance concern, we can implement a mangling of the predicate
1163 // data easilly enough with a map back to the actual string. That's
1164 // overkill for now, though.
1166 // Make sure the predicate is in the table.
1167 TableInfo
.Predicates
.insert(Predicate
.str());
1168 // Now figure out the index for when we write out the table.
1169 PredicateSet::const_iterator P
= std::find(TableInfo
.Predicates
.begin(),
1170 TableInfo
.Predicates
.end(),
1172 return (unsigned)(P
- TableInfo
.Predicates
.begin());
1175 void FilterChooser::emitPredicateTableEntry(DecoderTableInfo
&TableInfo
,
1176 unsigned Opc
) const {
1177 if (!doesOpcodeNeedPredicate(Opc
))
1180 // Build up the predicate string.
1181 SmallString
<256> Predicate
;
1182 // FIXME: emitPredicateMatch() functions can take a buffer directly rather
1184 raw_svector_ostream
PS(Predicate
);
1186 emitPredicateMatch(PS
, I
, Opc
);
1188 // Figure out the index into the predicate table for the predicate just
1190 unsigned PIdx
= getPredicateIndex(TableInfo
, PS
.str());
1191 SmallString
<16> PBytes
;
1192 raw_svector_ostream
S(PBytes
);
1193 encodeULEB128(PIdx
, S
);
1196 TableInfo
.Table
.push_back(MCD::OPC_CheckPredicate
);
1198 for (unsigned i
= 0, e
= PBytes
.size(); i
!= e
; ++i
)
1199 TableInfo
.Table
.push_back(PBytes
[i
]);
1200 // Push location for NumToSkip backpatching.
1201 TableInfo
.FixupStack
.back().push_back(TableInfo
.Table
.size());
1202 TableInfo
.Table
.push_back(0);
1203 TableInfo
.Table
.push_back(0);
1206 void FilterChooser::emitSoftFailTableEntry(DecoderTableInfo
&TableInfo
,
1207 unsigned Opc
) const {
1209 AllInstructions
[Opc
]->TheDef
->getValueAsBitsInit("SoftFail");
1210 if (!SFBits
) return;
1211 BitsInit
*InstBits
= AllInstructions
[Opc
]->TheDef
->getValueAsBitsInit("Inst");
1213 APInt
PositiveMask(BitWidth
, 0ULL);
1214 APInt
NegativeMask(BitWidth
, 0ULL);
1215 for (unsigned i
= 0; i
< BitWidth
; ++i
) {
1216 bit_value_t B
= bitFromBits(*SFBits
, i
);
1217 bit_value_t IB
= bitFromBits(*InstBits
, i
);
1219 if (B
!= BIT_TRUE
) continue;
1223 // The bit is meant to be false, so emit a check to see if it is true.
1224 PositiveMask
.setBit(i
);
1227 // The bit is meant to be true, so emit a check to see if it is false.
1228 NegativeMask
.setBit(i
);
1231 // The bit is not set; this must be an error!
1232 StringRef Name
= AllInstructions
[Opc
]->TheDef
->getName();
1233 errs() << "SoftFail Conflict: bit SoftFail{" << i
<< "} in " << Name
1234 << " is set but Inst{" << i
<< "} is unset!\n"
1235 << " - You can only mark a bit as SoftFail if it is fully defined"
1236 << " (1/0 - not '?') in Inst\n";
1241 bool NeedPositiveMask
= PositiveMask
.getBoolValue();
1242 bool NeedNegativeMask
= NegativeMask
.getBoolValue();
1244 if (!NeedPositiveMask
&& !NeedNegativeMask
)
1247 TableInfo
.Table
.push_back(MCD::OPC_SoftFail
);
1249 SmallString
<16> MaskBytes
;
1250 raw_svector_ostream
S(MaskBytes
);
1251 if (NeedPositiveMask
) {
1252 encodeULEB128(PositiveMask
.getZExtValue(), S
);
1254 for (unsigned i
= 0, e
= MaskBytes
.size(); i
!= e
; ++i
)
1255 TableInfo
.Table
.push_back(MaskBytes
[i
]);
1257 TableInfo
.Table
.push_back(0);
1258 if (NeedNegativeMask
) {
1261 encodeULEB128(NegativeMask
.getZExtValue(), S
);
1263 for (unsigned i
= 0, e
= MaskBytes
.size(); i
!= e
; ++i
)
1264 TableInfo
.Table
.push_back(MaskBytes
[i
]);
1266 TableInfo
.Table
.push_back(0);
1269 // Emits table entries to decode the singleton.
1270 void FilterChooser::emitSingletonTableEntry(DecoderTableInfo
&TableInfo
,
1271 unsigned Opc
) const {
1272 std::vector
<unsigned> StartBits
;
1273 std::vector
<unsigned> EndBits
;
1274 std::vector
<uint64_t> FieldVals
;
1276 insnWithID(Insn
, Opc
);
1278 // Look for islands of undecoded bits of the singleton.
1279 getIslands(StartBits
, EndBits
, FieldVals
, Insn
);
1281 unsigned Size
= StartBits
.size();
1283 // Emit the predicate table entry if one is needed.
1284 emitPredicateTableEntry(TableInfo
, Opc
);
1286 // Check any additional encoding fields needed.
1287 for (unsigned I
= Size
; I
!= 0; --I
) {
1288 unsigned NumBits
= EndBits
[I
-1] - StartBits
[I
-1] + 1;
1289 TableInfo
.Table
.push_back(MCD::OPC_CheckField
);
1290 TableInfo
.Table
.push_back(StartBits
[I
-1]);
1291 TableInfo
.Table
.push_back(NumBits
);
1292 uint8_t Buffer
[8], *p
;
1293 encodeULEB128(FieldVals
[I
-1], Buffer
);
1294 for (p
= Buffer
; *p
>= 128 ; ++p
)
1295 TableInfo
.Table
.push_back(*p
);
1296 TableInfo
.Table
.push_back(*p
);
1297 // Push location for NumToSkip backpatching.
1298 TableInfo
.FixupStack
.back().push_back(TableInfo
.Table
.size());
1299 // The fixup is always 16-bits, so go ahead and allocate the space
1300 // in the table so all our relative position calculations work OK even
1301 // before we fully resolve the real value here.
1302 TableInfo
.Table
.push_back(0);
1303 TableInfo
.Table
.push_back(0);
1306 // Check for soft failure of the match.
1307 emitSoftFailTableEntry(TableInfo
, Opc
);
1309 TableInfo
.Table
.push_back(MCD::OPC_Decode
);
1310 uint8_t Buffer
[8], *p
;
1311 encodeULEB128(Opc
, Buffer
);
1312 for (p
= Buffer
; *p
>= 128 ; ++p
)
1313 TableInfo
.Table
.push_back(*p
);
1314 TableInfo
.Table
.push_back(*p
);
1316 unsigned DIdx
= getDecoderIndex(TableInfo
.Decoders
, Opc
);
1317 SmallString
<16> Bytes
;
1318 raw_svector_ostream
S(Bytes
);
1319 encodeULEB128(DIdx
, S
);
1323 for (unsigned i
= 0, e
= Bytes
.size(); i
!= e
; ++i
)
1324 TableInfo
.Table
.push_back(Bytes
[i
]);
1327 // Emits table entries to decode the singleton, and then to decode the rest.
1328 void FilterChooser::emitSingletonTableEntry(DecoderTableInfo
&TableInfo
,
1329 const Filter
&Best
) const {
1330 unsigned Opc
= Best
.getSingletonOpc();
1332 // complex singletons need predicate checks from the first singleton
1333 // to refer forward to the variable filterchooser that follows.
1334 TableInfo
.FixupStack
.push_back(FixupList());
1336 emitSingletonTableEntry(TableInfo
, Opc
);
1338 resolveTableFixups(TableInfo
.Table
, TableInfo
.FixupStack
.back(),
1339 TableInfo
.Table
.size());
1340 TableInfo
.FixupStack
.pop_back();
1342 Best
.getVariableFC().emitTableEntries(TableInfo
);
1346 // Assign a single filter and run with it. Top level API client can initialize
1347 // with a single filter to start the filtering process.
1348 void FilterChooser::runSingleFilter(unsigned startBit
, unsigned numBit
,
1351 Filters
.push_back(Filter(*this, startBit
, numBit
, true));
1352 BestIndex
= 0; // Sole Filter instance to choose from.
1353 bestFilter().recurse();
1356 // reportRegion is a helper function for filterProcessor to mark a region as
1357 // eligible for use as a filter region.
1358 void FilterChooser::reportRegion(bitAttr_t RA
, unsigned StartBit
,
1359 unsigned BitIndex
, bool AllowMixed
) {
1360 if (RA
== ATTR_MIXED
&& AllowMixed
)
1361 Filters
.push_back(Filter(*this, StartBit
, BitIndex
- StartBit
, true));
1362 else if (RA
== ATTR_ALL_SET
&& !AllowMixed
)
1363 Filters
.push_back(Filter(*this, StartBit
, BitIndex
- StartBit
, false));
1366 // FilterProcessor scans the well-known encoding bits of the instructions and
1367 // builds up a list of candidate filters. It chooses the best filter and
1368 // recursively descends down the decoding tree.
1369 bool FilterChooser::filterProcessor(bool AllowMixed
, bool Greedy
) {
1372 unsigned numInstructions
= Opcodes
.size();
1374 assert(numInstructions
&& "Filter created with no instructions");
1376 // No further filtering is necessary.
1377 if (numInstructions
== 1)
1380 // Heuristics. See also doFilter()'s "Heuristics" comment when num of
1381 // instructions is 3.
1382 if (AllowMixed
&& !Greedy
) {
1383 assert(numInstructions
== 3);
1385 for (unsigned i
= 0; i
< Opcodes
.size(); ++i
) {
1386 std::vector
<unsigned> StartBits
;
1387 std::vector
<unsigned> EndBits
;
1388 std::vector
<uint64_t> FieldVals
;
1391 insnWithID(Insn
, Opcodes
[i
]);
1393 // Look for islands of undecoded bits of any instruction.
1394 if (getIslands(StartBits
, EndBits
, FieldVals
, Insn
) > 0) {
1395 // Found an instruction with island(s). Now just assign a filter.
1396 runSingleFilter(StartBits
[0], EndBits
[0] - StartBits
[0] + 1, true);
1404 // We maintain BIT_WIDTH copies of the bitAttrs automaton.
1405 // The automaton consumes the corresponding bit from each
1408 // Input symbols: 0, 1, and _ (unset).
1409 // States: NONE, FILTERED, ALL_SET, ALL_UNSET, and MIXED.
1410 // Initial state: NONE.
1412 // (NONE) ------- [01] -> (ALL_SET)
1413 // (NONE) ------- _ ----> (ALL_UNSET)
1414 // (ALL_SET) ---- [01] -> (ALL_SET)
1415 // (ALL_SET) ---- _ ----> (MIXED)
1416 // (ALL_UNSET) -- [01] -> (MIXED)
1417 // (ALL_UNSET) -- _ ----> (ALL_UNSET)
1418 // (MIXED) ------ . ----> (MIXED)
1419 // (FILTERED)---- . ----> (FILTERED)
1421 std::vector
<bitAttr_t
> bitAttrs
;
1423 // FILTERED bit positions provide no entropy and are not worthy of pursuing.
1424 // Filter::recurse() set either BIT_TRUE or BIT_FALSE for each position.
1425 for (BitIndex
= 0; BitIndex
< BitWidth
; ++BitIndex
)
1426 if (FilterBitValues
[BitIndex
] == BIT_TRUE
||
1427 FilterBitValues
[BitIndex
] == BIT_FALSE
)
1428 bitAttrs
.push_back(ATTR_FILTERED
);
1430 bitAttrs
.push_back(ATTR_NONE
);
1432 for (unsigned InsnIndex
= 0; InsnIndex
< numInstructions
; ++InsnIndex
) {
1435 insnWithID(insn
, Opcodes
[InsnIndex
]);
1437 for (BitIndex
= 0; BitIndex
< BitWidth
; ++BitIndex
) {
1438 switch (bitAttrs
[BitIndex
]) {
1440 if (insn
[BitIndex
] == BIT_UNSET
)
1441 bitAttrs
[BitIndex
] = ATTR_ALL_UNSET
;
1443 bitAttrs
[BitIndex
] = ATTR_ALL_SET
;
1446 if (insn
[BitIndex
] == BIT_UNSET
)
1447 bitAttrs
[BitIndex
] = ATTR_MIXED
;
1449 case ATTR_ALL_UNSET
:
1450 if (insn
[BitIndex
] != BIT_UNSET
)
1451 bitAttrs
[BitIndex
] = ATTR_MIXED
;
1460 // The regionAttr automaton consumes the bitAttrs automatons' state,
1461 // lowest-to-highest.
1463 // Input symbols: F(iltered), (all_)S(et), (all_)U(nset), M(ixed)
1464 // States: NONE, ALL_SET, MIXED
1465 // Initial state: NONE
1467 // (NONE) ----- F --> (NONE)
1468 // (NONE) ----- S --> (ALL_SET) ; and set region start
1469 // (NONE) ----- U --> (NONE)
1470 // (NONE) ----- M --> (MIXED) ; and set region start
1471 // (ALL_SET) -- F --> (NONE) ; and report an ALL_SET region
1472 // (ALL_SET) -- S --> (ALL_SET)
1473 // (ALL_SET) -- U --> (NONE) ; and report an ALL_SET region
1474 // (ALL_SET) -- M --> (MIXED) ; and report an ALL_SET region
1475 // (MIXED) ---- F --> (NONE) ; and report a MIXED region
1476 // (MIXED) ---- S --> (ALL_SET) ; and report a MIXED region
1477 // (MIXED) ---- U --> (NONE) ; and report a MIXED region
1478 // (MIXED) ---- M --> (MIXED)
1480 bitAttr_t RA
= ATTR_NONE
;
1481 unsigned StartBit
= 0;
1483 for (BitIndex
= 0; BitIndex
< BitWidth
; ++BitIndex
) {
1484 bitAttr_t bitAttr
= bitAttrs
[BitIndex
];
1486 assert(bitAttr
!= ATTR_NONE
&& "Bit without attributes");
1494 StartBit
= BitIndex
;
1497 case ATTR_ALL_UNSET
:
1500 StartBit
= BitIndex
;
1504 llvm_unreachable("Unexpected bitAttr!");
1510 reportRegion(RA
, StartBit
, BitIndex
, AllowMixed
);
1515 case ATTR_ALL_UNSET
:
1516 reportRegion(RA
, StartBit
, BitIndex
, AllowMixed
);
1520 reportRegion(RA
, StartBit
, BitIndex
, AllowMixed
);
1521 StartBit
= BitIndex
;
1525 llvm_unreachable("Unexpected bitAttr!");
1531 reportRegion(RA
, StartBit
, BitIndex
, AllowMixed
);
1532 StartBit
= BitIndex
;
1536 reportRegion(RA
, StartBit
, BitIndex
, AllowMixed
);
1537 StartBit
= BitIndex
;
1540 case ATTR_ALL_UNSET
:
1541 reportRegion(RA
, StartBit
, BitIndex
, AllowMixed
);
1547 llvm_unreachable("Unexpected bitAttr!");
1550 case ATTR_ALL_UNSET
:
1551 llvm_unreachable("regionAttr state machine has no ATTR_UNSET state");
1553 llvm_unreachable("regionAttr state machine has no ATTR_FILTERED state");
1557 // At the end, if we're still in ALL_SET or MIXED states, report a region
1564 reportRegion(RA
, StartBit
, BitIndex
, AllowMixed
);
1566 case ATTR_ALL_UNSET
:
1569 reportRegion(RA
, StartBit
, BitIndex
, AllowMixed
);
1573 // We have finished with the filter processings. Now it's time to choose
1574 // the best performing filter.
1576 bool AllUseless
= true;
1577 unsigned BestScore
= 0;
1579 for (unsigned i
= 0, e
= Filters
.size(); i
!= e
; ++i
) {
1580 unsigned Usefulness
= Filters
[i
].usefulness();
1585 if (Usefulness
> BestScore
) {
1587 BestScore
= Usefulness
;
1592 bestFilter().recurse();
1595 } // end of FilterChooser::filterProcessor(bool)
1597 // Decides on the best configuration of filter(s) to use in order to decode
1598 // the instructions. A conflict of instructions may occur, in which case we
1599 // dump the conflict set to the standard error.
1600 void FilterChooser::doFilter() {
1601 unsigned Num
= Opcodes
.size();
1602 assert(Num
&& "FilterChooser created with no instructions");
1604 // Try regions of consecutive known bit values first.
1605 if (filterProcessor(false))
1608 // Then regions of mixed bits (both known and unitialized bit values allowed).
1609 if (filterProcessor(true))
1612 // Heuristics to cope with conflict set {t2CMPrs, t2SUBSrr, t2SUBSrs} where
1613 // no single instruction for the maximum ATTR_MIXED region Inst{14-4} has a
1614 // well-known encoding pattern. In such case, we backtrack and scan for the
1615 // the very first consecutive ATTR_ALL_SET region and assign a filter to it.
1616 if (Num
== 3 && filterProcessor(true, false))
1619 // If we come to here, the instruction decoding has failed.
1620 // Set the BestIndex to -1 to indicate so.
1624 // emitTableEntries - Emit state machine entries to decode our share of
1626 void FilterChooser::emitTableEntries(DecoderTableInfo
&TableInfo
) const {
1627 if (Opcodes
.size() == 1) {
1628 // There is only one instruction in the set, which is great!
1629 // Call emitSingletonDecoder() to see whether there are any remaining
1631 emitSingletonTableEntry(TableInfo
, Opcodes
[0]);
1635 // Choose the best filter to do the decodings!
1636 if (BestIndex
!= -1) {
1637 const Filter
&Best
= Filters
[BestIndex
];
1638 if (Best
.getNumFiltered() == 1)
1639 emitSingletonTableEntry(TableInfo
, Best
);
1641 Best
.emitTableEntry(TableInfo
);
1645 // We don't know how to decode these instructions! Dump the
1646 // conflict set and bail.
1648 // Print out useful conflict information for postmortem analysis.
1649 errs() << "Decoding Conflict:\n";
1651 dumpStack(errs(), "\t\t");
1653 for (unsigned i
= 0; i
< Opcodes
.size(); ++i
) {
1654 const std::string
&Name
= nameWithID(Opcodes
[i
]);
1656 errs() << '\t' << Name
<< " ";
1658 getBitsField(*AllInstructions
[Opcodes
[i
]]->TheDef
, "Inst"));
1663 static bool populateInstruction(CodeGenTarget
&Target
,
1664 const CodeGenInstruction
&CGI
, unsigned Opc
,
1665 std::map
<unsigned, std::vector
<OperandInfo
> > &Operands
){
1666 const Record
&Def
= *CGI
.TheDef
;
1667 // If all the bit positions are not specified; do not decode this instruction.
1668 // We are bound to fail! For proper disassembly, the well-known encoding bits
1669 // of the instruction must be fully specified.
1671 BitsInit
&Bits
= getBitsField(Def
, "Inst");
1672 if (Bits
.allInComplete()) return false;
1674 std::vector
<OperandInfo
> InsnOperands
;
1676 // If the instruction has specified a custom decoding hook, use that instead
1677 // of trying to auto-generate the decoder.
1678 std::string InstDecoder
= Def
.getValueAsString("DecoderMethod");
1679 if (InstDecoder
!= "") {
1680 InsnOperands
.push_back(OperandInfo(InstDecoder
));
1681 Operands
[Opc
] = InsnOperands
;
1685 // Generate a description of the operand of the instruction that we know
1686 // how to decode automatically.
1687 // FIXME: We'll need to have a way to manually override this as needed.
1689 // Gather the outputs/inputs of the instruction, so we can find their
1690 // positions in the encoding. This assumes for now that they appear in the
1691 // MCInst in the order that they're listed.
1692 std::vector
<std::pair
<Init
*, std::string
> > InOutOperands
;
1693 DagInit
*Out
= Def
.getValueAsDag("OutOperandList");
1694 DagInit
*In
= Def
.getValueAsDag("InOperandList");
1695 for (unsigned i
= 0; i
< Out
->getNumArgs(); ++i
)
1696 InOutOperands
.push_back(std::make_pair(Out
->getArg(i
), Out
->getArgName(i
)));
1697 for (unsigned i
= 0; i
< In
->getNumArgs(); ++i
)
1698 InOutOperands
.push_back(std::make_pair(In
->getArg(i
), In
->getArgName(i
)));
1700 // Search for tied operands, so that we can correctly instantiate
1701 // operands that are not explicitly represented in the encoding.
1702 std::map
<std::string
, std::string
> TiedNames
;
1703 for (unsigned i
= 0; i
< CGI
.Operands
.size(); ++i
) {
1704 int tiedTo
= CGI
.Operands
[i
].getTiedRegister();
1706 std::pair
<unsigned, unsigned> SO
=
1707 CGI
.Operands
.getSubOperandNumber(tiedTo
);
1708 TiedNames
[InOutOperands
[i
].second
] = InOutOperands
[SO
.first
].second
;
1709 TiedNames
[InOutOperands
[SO
.first
].second
] = InOutOperands
[i
].second
;
1713 std::map
<std::string
, std::vector
<OperandInfo
> > NumberedInsnOperands
;
1714 std::set
<std::string
> NumberedInsnOperandsNoTie
;
1715 if (Target
.getInstructionSet()->
1716 getValueAsBit("decodePositionallyEncodedOperands")) {
1717 const std::vector
<RecordVal
> &Vals
= Def
.getValues();
1718 unsigned NumberedOp
= 0;
1720 std::set
<unsigned> NamedOpIndices
;
1721 if (Target
.getInstructionSet()->
1722 getValueAsBit("noNamedPositionallyEncodedOperands"))
1723 // Collect the set of operand indices that might correspond to named
1724 // operand, and skip these when assigning operands based on position.
1725 for (unsigned i
= 0, e
= Vals
.size(); i
!= e
; ++i
) {
1727 if (!CGI
.Operands
.hasOperandNamed(Vals
[i
].getName(), OpIdx
))
1730 NamedOpIndices
.insert(OpIdx
);
1733 for (unsigned i
= 0, e
= Vals
.size(); i
!= e
; ++i
) {
1734 // Ignore fixed fields in the record, we're looking for values like:
1735 // bits<5> RST = { ?, ?, ?, ?, ? };
1736 if (Vals
[i
].getPrefix() || Vals
[i
].getValue()->isComplete())
1739 // Determine if Vals[i] actually contributes to the Inst encoding.
1741 for (; bi
< Bits
.getNumBits(); ++bi
) {
1742 VarInit
*Var
= nullptr;
1743 VarBitInit
*BI
= dyn_cast
<VarBitInit
>(Bits
.getBit(bi
));
1745 Var
= dyn_cast
<VarInit
>(BI
->getBitVar());
1747 Var
= dyn_cast
<VarInit
>(Bits
.getBit(bi
));
1749 if (Var
&& Var
->getName() == Vals
[i
].getName())
1753 if (bi
== Bits
.getNumBits())
1756 // Skip variables that correspond to explicitly-named operands.
1758 if (CGI
.Operands
.hasOperandNamed(Vals
[i
].getName(), OpIdx
))
1761 // Get the bit range for this operand:
1762 unsigned bitStart
= bi
++, bitWidth
= 1;
1763 for (; bi
< Bits
.getNumBits(); ++bi
) {
1764 VarInit
*Var
= nullptr;
1765 VarBitInit
*BI
= dyn_cast
<VarBitInit
>(Bits
.getBit(bi
));
1767 Var
= dyn_cast
<VarInit
>(BI
->getBitVar());
1769 Var
= dyn_cast
<VarInit
>(Bits
.getBit(bi
));
1774 if (Var
->getName() != Vals
[i
].getName())
1780 unsigned NumberOps
= CGI
.Operands
.size();
1781 while (NumberedOp
< NumberOps
&&
1782 (CGI
.Operands
.isFlatOperandNotEmitted(NumberedOp
) ||
1783 (NamedOpIndices
.size() && NamedOpIndices
.count(
1784 CGI
.Operands
.getSubOperandNumber(NumberedOp
).first
))))
1787 OpIdx
= NumberedOp
++;
1789 // OpIdx now holds the ordered operand number of Vals[i].
1790 std::pair
<unsigned, unsigned> SO
=
1791 CGI
.Operands
.getSubOperandNumber(OpIdx
);
1792 const std::string
&Name
= CGI
.Operands
[SO
.first
].Name
;
1794 DEBUG(dbgs() << "Numbered operand mapping for " << Def
.getName() << ": " <<
1795 Name
<< "(" << SO
.first
<< ", " << SO
.second
<< ") => " <<
1796 Vals
[i
].getName() << "\n");
1798 std::string Decoder
= "";
1799 Record
*TypeRecord
= CGI
.Operands
[SO
.first
].Rec
;
1801 RecordVal
*DecoderString
= TypeRecord
->getValue("DecoderMethod");
1802 StringInit
*String
= DecoderString
?
1803 dyn_cast
<StringInit
>(DecoderString
->getValue()) : nullptr;
1804 if (String
&& String
->getValue() != "")
1805 Decoder
= String
->getValue();
1807 if (Decoder
== "" &&
1808 CGI
.Operands
[SO
.first
].MIOperandInfo
&&
1809 CGI
.Operands
[SO
.first
].MIOperandInfo
->getNumArgs()) {
1810 Init
*Arg
= CGI
.Operands
[SO
.first
].MIOperandInfo
->
1812 if (TypedInit
*TI
= cast
<TypedInit
>(Arg
)) {
1813 RecordRecTy
*Type
= cast
<RecordRecTy
>(TI
->getType());
1814 TypeRecord
= Type
->getRecord();
1819 if (TypeRecord
->isSubClassOf("RegisterOperand"))
1820 TypeRecord
= TypeRecord
->getValueAsDef("RegClass");
1821 if (TypeRecord
->isSubClassOf("RegisterClass")) {
1822 Decoder
= "Decode" + TypeRecord
->getName() + "RegisterClass";
1824 } else if (TypeRecord
->isSubClassOf("PointerLikeRegClass")) {
1825 Decoder
= "DecodePointerLikeRegClass" +
1826 utostr(TypeRecord
->getValueAsInt("RegClassKind"));
1830 DecoderString
= TypeRecord
->getValue("DecoderMethod");
1831 String
= DecoderString
?
1832 dyn_cast
<StringInit
>(DecoderString
->getValue()) : nullptr;
1833 if (!isReg
&& String
&& String
->getValue() != "")
1834 Decoder
= String
->getValue();
1836 OperandInfo
OpInfo(Decoder
);
1837 OpInfo
.addField(bitStart
, bitWidth
, 0);
1839 NumberedInsnOperands
[Name
].push_back(OpInfo
);
1841 // FIXME: For complex operands with custom decoders we can't handle tied
1842 // sub-operands automatically. Skip those here and assume that this is
1843 // fixed up elsewhere.
1844 if (CGI
.Operands
[SO
.first
].MIOperandInfo
&&
1845 CGI
.Operands
[SO
.first
].MIOperandInfo
->getNumArgs() > 1 &&
1846 String
&& String
->getValue() != "")
1847 NumberedInsnOperandsNoTie
.insert(Name
);
1851 // For each operand, see if we can figure out where it is encoded.
1852 for (const auto &Op
: InOutOperands
) {
1853 if (!NumberedInsnOperands
[Op
.second
].empty()) {
1854 InsnOperands
.insert(InsnOperands
.end(),
1855 NumberedInsnOperands
[Op
.second
].begin(),
1856 NumberedInsnOperands
[Op
.second
].end());
1859 if (!NumberedInsnOperands
[TiedNames
[Op
.second
]].empty()) {
1860 if (!NumberedInsnOperandsNoTie
.count(TiedNames
[Op
.second
])) {
1861 // Figure out to which (sub)operand we're tied.
1862 unsigned i
= CGI
.Operands
.getOperandNamed(TiedNames
[Op
.second
]);
1863 int tiedTo
= CGI
.Operands
[i
].getTiedRegister();
1865 i
= CGI
.Operands
.getOperandNamed(Op
.second
);
1866 tiedTo
= CGI
.Operands
[i
].getTiedRegister();
1870 std::pair
<unsigned, unsigned> SO
=
1871 CGI
.Operands
.getSubOperandNumber(tiedTo
);
1873 InsnOperands
.push_back(NumberedInsnOperands
[TiedNames
[Op
.second
]]
1880 std::string Decoder
= "";
1882 // At this point, we can locate the field, but we need to know how to
1883 // interpret it. As a first step, require the target to provide callbacks
1884 // for decoding register classes.
1885 // FIXME: This need to be extended to handle instructions with custom
1886 // decoder methods, and operands with (simple) MIOperandInfo's.
1887 TypedInit
*TI
= cast
<TypedInit
>(Op
.first
);
1888 RecordRecTy
*Type
= cast
<RecordRecTy
>(TI
->getType());
1889 Record
*TypeRecord
= Type
->getRecord();
1891 if (TypeRecord
->isSubClassOf("RegisterOperand"))
1892 TypeRecord
= TypeRecord
->getValueAsDef("RegClass");
1893 if (TypeRecord
->isSubClassOf("RegisterClass")) {
1894 Decoder
= "Decode" + TypeRecord
->getName() + "RegisterClass";
1896 } else if (TypeRecord
->isSubClassOf("PointerLikeRegClass")) {
1897 Decoder
= "DecodePointerLikeRegClass" +
1898 utostr(TypeRecord
->getValueAsInt("RegClassKind"));
1902 RecordVal
*DecoderString
= TypeRecord
->getValue("DecoderMethod");
1903 StringInit
*String
= DecoderString
?
1904 dyn_cast
<StringInit
>(DecoderString
->getValue()) : nullptr;
1905 if (!isReg
&& String
&& String
->getValue() != "")
1906 Decoder
= String
->getValue();
1908 OperandInfo
OpInfo(Decoder
);
1909 unsigned Base
= ~0U;
1911 unsigned Offset
= 0;
1913 for (unsigned bi
= 0; bi
< Bits
.getNumBits(); ++bi
) {
1914 VarInit
*Var
= nullptr;
1915 VarBitInit
*BI
= dyn_cast
<VarBitInit
>(Bits
.getBit(bi
));
1917 Var
= dyn_cast
<VarInit
>(BI
->getBitVar());
1919 Var
= dyn_cast
<VarInit
>(Bits
.getBit(bi
));
1923 OpInfo
.addField(Base
, Width
, Offset
);
1931 if (Var
->getName() != Op
.second
&&
1932 Var
->getName() != TiedNames
[Op
.second
]) {
1934 OpInfo
.addField(Base
, Width
, Offset
);
1945 Offset
= BI
? BI
->getBitNum() : 0;
1946 } else if (BI
&& BI
->getBitNum() != Offset
+ Width
) {
1947 OpInfo
.addField(Base
, Width
, Offset
);
1950 Offset
= BI
->getBitNum();
1957 OpInfo
.addField(Base
, Width
, Offset
);
1959 if (OpInfo
.numFields() > 0)
1960 InsnOperands
.push_back(OpInfo
);
1963 Operands
[Opc
] = InsnOperands
;
1968 // Dumps the instruction encoding bits.
1969 dumpBits(errs(), Bits
);
1973 // Dumps the list of operand info.
1974 for (unsigned i
= 0, e
= CGI
.Operands
.size(); i
!= e
; ++i
) {
1975 const CGIOperandList::OperandInfo
&Info
= CGI
.Operands
[i
];
1976 const std::string
&OperandName
= Info
.Name
;
1977 const Record
&OperandDef
= *Info
.Rec
;
1979 errs() << "\t" << OperandName
<< " (" << OperandDef
.getName() << ")\n";
1987 // emitFieldFromInstruction - Emit the templated helper function
1988 // fieldFromInstruction().
1989 static void emitFieldFromInstruction(formatted_raw_ostream
&OS
) {
1990 OS
<< "// Helper function for extracting fields from encoded instructions.\n"
1991 << "template<typename InsnType>\n"
1992 << "static InsnType fieldFromInstruction(InsnType insn, unsigned startBit,\n"
1993 << " unsigned numBits) {\n"
1994 << " assert(startBit + numBits <= (sizeof(InsnType)*8) &&\n"
1995 << " \"Instruction field out of bounds!\");\n"
1996 << " InsnType fieldMask;\n"
1997 << " if (numBits == sizeof(InsnType)*8)\n"
1998 << " fieldMask = (InsnType)(-1LL);\n"
2000 << " fieldMask = (((InsnType)1 << numBits) - 1) << startBit;\n"
2001 << " return (insn & fieldMask) >> startBit;\n"
2005 // emitDecodeInstruction - Emit the templated helper function
2006 // decodeInstruction().
2007 static void emitDecodeInstruction(formatted_raw_ostream
&OS
) {
2008 OS
<< "template<typename InsnType>\n"
2009 << "static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,\n"
2010 << " InsnType insn, uint64_t Address,\n"
2011 << " const void *DisAsm,\n"
2012 << " const MCSubtargetInfo &STI) {\n"
2013 << " uint64_t Bits = STI.getFeatureBits();\n"
2015 << " const uint8_t *Ptr = DecodeTable;\n"
2016 << " uint32_t CurFieldValue = 0;\n"
2017 << " DecodeStatus S = MCDisassembler::Success;\n"
2019 << " ptrdiff_t Loc = Ptr - DecodeTable;\n"
2020 << " switch (*Ptr) {\n"
2022 << " errs() << Loc << \": Unexpected decode table opcode!\\n\";\n"
2023 << " return MCDisassembler::Fail;\n"
2024 << " case MCD::OPC_ExtractField: {\n"
2025 << " unsigned Start = *++Ptr;\n"
2026 << " unsigned Len = *++Ptr;\n"
2028 << " CurFieldValue = fieldFromInstruction(insn, Start, Len);\n"
2029 << " DEBUG(dbgs() << Loc << \": OPC_ExtractField(\" << Start << \", \"\n"
2030 << " << Len << \"): \" << CurFieldValue << \"\\n\");\n"
2033 << " case MCD::OPC_FilterValue: {\n"
2034 << " // Decode the field value.\n"
2035 << " unsigned Len;\n"
2036 << " InsnType Val = decodeULEB128(++Ptr, &Len);\n"
2038 << " // NumToSkip is a plain 16-bit integer.\n"
2039 << " unsigned NumToSkip = *Ptr++;\n"
2040 << " NumToSkip |= (*Ptr++) << 8;\n"
2042 << " // Perform the filter operation.\n"
2043 << " if (Val != CurFieldValue)\n"
2044 << " Ptr += NumToSkip;\n"
2045 << " DEBUG(dbgs() << Loc << \": OPC_FilterValue(\" << Val << \", \" << NumToSkip\n"
2046 << " << \"): \" << ((Val != CurFieldValue) ? \"FAIL:\" : \"PASS:\")\n"
2047 << " << \" continuing at \" << (Ptr - DecodeTable) << \"\\n\");\n"
2051 << " case MCD::OPC_CheckField: {\n"
2052 << " unsigned Start = *++Ptr;\n"
2053 << " unsigned Len = *++Ptr;\n"
2054 << " InsnType FieldValue = fieldFromInstruction(insn, Start, Len);\n"
2055 << " // Decode the field value.\n"
2056 << " uint32_t ExpectedValue = decodeULEB128(++Ptr, &Len);\n"
2058 << " // NumToSkip is a plain 16-bit integer.\n"
2059 << " unsigned NumToSkip = *Ptr++;\n"
2060 << " NumToSkip |= (*Ptr++) << 8;\n"
2062 << " // If the actual and expected values don't match, skip.\n"
2063 << " if (ExpectedValue != FieldValue)\n"
2064 << " Ptr += NumToSkip;\n"
2065 << " DEBUG(dbgs() << Loc << \": OPC_CheckField(\" << Start << \", \"\n"
2066 << " << Len << \", \" << ExpectedValue << \", \" << NumToSkip\n"
2067 << " << \"): FieldValue = \" << FieldValue << \", ExpectedValue = \"\n"
2068 << " << ExpectedValue << \": \"\n"
2069 << " << ((ExpectedValue == FieldValue) ? \"PASS\\n\" : \"FAIL\\n\"));\n"
2072 << " case MCD::OPC_CheckPredicate: {\n"
2073 << " unsigned Len;\n"
2074 << " // Decode the Predicate Index value.\n"
2075 << " unsigned PIdx = decodeULEB128(++Ptr, &Len);\n"
2077 << " // NumToSkip is a plain 16-bit integer.\n"
2078 << " unsigned NumToSkip = *Ptr++;\n"
2079 << " NumToSkip |= (*Ptr++) << 8;\n"
2080 << " // Check the predicate.\n"
2082 << " if (!(Pred = checkDecoderPredicate(PIdx, Bits)))\n"
2083 << " Ptr += NumToSkip;\n"
2085 << " DEBUG(dbgs() << Loc << \": OPC_CheckPredicate(\" << PIdx << \"): \"\n"
2086 << " << (Pred ? \"PASS\\n\" : \"FAIL\\n\"));\n"
2090 << " case MCD::OPC_Decode: {\n"
2091 << " unsigned Len;\n"
2092 << " // Decode the Opcode value.\n"
2093 << " unsigned Opc = decodeULEB128(++Ptr, &Len);\n"
2095 << " unsigned DecodeIdx = decodeULEB128(Ptr, &Len);\n"
2097 << " DEBUG(dbgs() << Loc << \": OPC_Decode: opcode \" << Opc\n"
2098 << " << \", using decoder \" << DecodeIdx << \"\\n\" );\n"
2099 << " DEBUG(dbgs() << \"----- DECODE SUCCESSFUL -----\\n\");\n"
2101 << " MI.setOpcode(Opc);\n"
2102 << " return decodeToMCInst(S, DecodeIdx, insn, MI, Address, DisAsm);\n"
2104 << " case MCD::OPC_SoftFail: {\n"
2105 << " // Decode the mask values.\n"
2106 << " unsigned Len;\n"
2107 << " InsnType PositiveMask = decodeULEB128(++Ptr, &Len);\n"
2109 << " InsnType NegativeMask = decodeULEB128(Ptr, &Len);\n"
2111 << " bool Fail = (insn & PositiveMask) || (~insn & NegativeMask);\n"
2113 << " S = MCDisassembler::SoftFail;\n"
2114 << " DEBUG(dbgs() << Loc << \": OPC_SoftFail: \" << (Fail ? \"FAIL\\n\":\"PASS\\n\"));\n"
2117 << " case MCD::OPC_Fail: {\n"
2118 << " DEBUG(dbgs() << Loc << \": OPC_Fail\\n\");\n"
2119 << " return MCDisassembler::Fail;\n"
2123 << " llvm_unreachable(\"bogosity detected in disassembler state machine!\");\n"
2127 // Emits disassembler code for instruction decoding.
2128 void FixedLenDecoderEmitter::run(raw_ostream
&o
) {
2129 formatted_raw_ostream
OS(o
);
2130 OS
<< "#include \"llvm/MC/MCInst.h\"\n";
2131 OS
<< "#include \"llvm/Support/Debug.h\"\n";
2132 OS
<< "#include \"llvm/Support/DataTypes.h\"\n";
2133 OS
<< "#include \"llvm/Support/LEB128.h\"\n";
2134 OS
<< "#include \"llvm/Support/raw_ostream.h\"\n";
2135 OS
<< "#include <assert.h>\n";
2137 OS
<< "namespace llvm {\n\n";
2139 emitFieldFromInstruction(OS
);
2141 Target
.reverseBitsForLittleEndianEncoding();
2143 // Parameterize the decoders based on namespace and instruction width.
2144 NumberedInstructions
= &Target
.getInstructionsByEnumValue();
2145 std::map
<std::pair
<std::string
, unsigned>,
2146 std::vector
<unsigned> > OpcMap
;
2147 std::map
<unsigned, std::vector
<OperandInfo
> > Operands
;
2149 for (unsigned i
= 0; i
< NumberedInstructions
->size(); ++i
) {
2150 const CodeGenInstruction
*Inst
= NumberedInstructions
->at(i
);
2151 const Record
*Def
= Inst
->TheDef
;
2152 unsigned Size
= Def
->getValueAsInt("Size");
2153 if (Def
->getValueAsString("Namespace") == "TargetOpcode" ||
2154 Def
->getValueAsBit("isPseudo") ||
2155 Def
->getValueAsBit("isAsmParserOnly") ||
2156 Def
->getValueAsBit("isCodeGenOnly"))
2159 std::string DecoderNamespace
= Def
->getValueAsString("DecoderNamespace");
2162 if (populateInstruction(Target
, *Inst
, i
, Operands
)) {
2163 OpcMap
[std::make_pair(DecoderNamespace
, Size
)].push_back(i
);
2168 DecoderTableInfo TableInfo
;
2169 for (const auto &Opc
: OpcMap
) {
2170 // Emit the decoder for this namespace+width combination.
2171 FilterChooser
FC(*NumberedInstructions
, Opc
.second
, Operands
,
2172 8*Opc
.first
.second
, this);
2174 // The decode table is cleared for each top level decoder function. The
2175 // predicates and decoders themselves, however, are shared across all
2176 // decoders to give more opportunities for uniqueing.
2177 TableInfo
.Table
.clear();
2178 TableInfo
.FixupStack
.clear();
2179 TableInfo
.Table
.reserve(16384);
2180 TableInfo
.FixupStack
.push_back(FixupList());
2181 FC
.emitTableEntries(TableInfo
);
2182 // Any NumToSkip fixups in the top level scope can resolve to the
2183 // OPC_Fail at the end of the table.
2184 assert(TableInfo
.FixupStack
.size() == 1 && "fixup stack phasing error!");
2185 // Resolve any NumToSkip fixups in the current scope.
2186 resolveTableFixups(TableInfo
.Table
, TableInfo
.FixupStack
.back(),
2187 TableInfo
.Table
.size());
2188 TableInfo
.FixupStack
.clear();
2190 TableInfo
.Table
.push_back(MCD::OPC_Fail
);
2192 // Print the table to the output stream.
2193 emitTable(OS
, TableInfo
.Table
, 0, FC
.getBitWidth(), Opc
.first
.first
);
2197 // Emit the predicate function.
2198 emitPredicateFunction(OS
, TableInfo
.Predicates
, 0);
2200 // Emit the decoder function.
2201 emitDecoderFunction(OS
, TableInfo
.Decoders
, 0);
2203 // Emit the main entry point for the decoder, decodeInstruction().
2204 emitDecodeInstruction(OS
);
2206 OS
<< "\n} // End llvm namespace\n";
2211 void EmitFixedLenDecoder(RecordKeeper
&RK
, raw_ostream
&OS
,
2212 std::string PredicateNamespace
,
2213 std::string GPrefix
,
2214 std::string GPostfix
,
2218 FixedLenDecoderEmitter(RK
, PredicateNamespace
, GPrefix
, GPostfix
,
2219 ROK
, RFail
, L
).run(OS
);
2222 } // End llvm namespace