1 //===- HexagonMCChecker.h - Instruction bundle checking ---------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This implements the checking of insns inside a bundle according to the
10 // packet constraint rules of the Hexagon ISA.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_LIB_TARGET_HEXAGON_MCTARGETDESC_HEXAGONMCCHECKER_H
15 #define LLVM_LIB_TARGET_HEXAGON_MCTARGETDESC_HEXAGONMCCHECKER_H
16 
17 #include "MCTargetDesc/HexagonMCInstrInfo.h"
18 #include "MCTargetDesc/HexagonMCTargetDesc.h"
19 #include "llvm/ADT/DenseMap.h"
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/Support/SMLoc.h"
22 #include <set>
23 #include <utility>
24 
25 namespace llvm {
26 
27 class MCContext;
28 class MCInst;
29 class MCInstrInfo;
30 class MCRegisterInfo;
31 class MCSubtargetInfo;
32 
33 /// Check for a valid bundle.
34 class HexagonMCChecker {
35   MCContext &Context;
36   MCInst &MCB;
37   const MCRegisterInfo &RI;
38   MCInstrInfo const &MCII;
39   MCSubtargetInfo const &STI;
40   bool ReportErrors;
41 
42   /// Set of definitions: register #, if predicated, if predicated true.
43   using PredSense = std::pair<unsigned, bool>;
44   static const PredSense Unconditional;
45   using PredSet = std::multiset<PredSense>;
46   using PredSetIterator = std::multiset<PredSense>::iterator;
47 
48   using DefsIterator = DenseMap<unsigned, PredSet>::iterator;
49   DenseMap<unsigned, PredSet> Defs;
50 
51   /// Set of weak definitions whose clashes should be enforced selectively.
52   using SoftDefsIterator = std::set<unsigned>::iterator;
53   std::set<unsigned> SoftDefs;
54 
55   /// Set of temporary definitions not committed to the register file.
56   using TmpDefsIterator = std::set<unsigned>::iterator;
57   std::set<unsigned> TmpDefs;
58 
59   /// Set of new predicates used.
60   using NewPredsIterator = std::set<unsigned>::iterator;
61   std::set<unsigned> NewPreds;
62 
63   /// Set of predicates defined late.
64   using LatePredsIterator = std::multiset<unsigned>::iterator;
65   std::multiset<unsigned> LatePreds;
66 
67   /// Set of uses.
68   using UsesIterator = std::set<unsigned>::iterator;
69   std::set<unsigned> Uses;
70 
71   /// Pre-defined set of read-only registers.
72   using ReadOnlyIterator = std::set<unsigned>::iterator;
73   std::set<unsigned> ReadOnly;
74 
75   // Contains the vector-pair-registers with the even number
76   // first ("v0:1", e.g.) used/def'd in this packet.
77   std::set<unsigned> ReversePairs;
78 
79   void init();
80   void init(MCInst const &);
81   void initReg(MCInst const &, unsigned, unsigned &PredReg, bool &isTrue);
82 
83   bool registerUsed(unsigned Register);
84 
85   /// \return a tuple of: pointer to the producer instruction or nullptr if
86   /// none was found, the operand index, and the PredicateInfo for the
87   /// producer.
88   std::tuple<MCInst const *, unsigned, HexagonMCInstrInfo::PredicateInfo>
89   registerProducer(unsigned Register,
90                    HexagonMCInstrInfo::PredicateInfo Predicated);
91 
92   // Checks performed.
93   bool checkBranches();
94   bool checkPredicates();
95   bool checkNewValues();
96   bool checkRegisters();
97   bool checkRegistersReadOnly();
98   void checkRegisterCurDefs();
99   bool checkSolo();
100   bool checkShuffle();
101   bool checkSlots();
102   bool checkAXOK();
103   bool checkHWLoop();
104   bool checkCOFMax1();
105   bool checkLegalVecRegPair();
106   bool checkValidTmpDst();
107   bool checkHVXAccum();
108 
109   static void compoundRegisterMap(unsigned &);
110 
111   bool isLoopRegister(unsigned R) const {
112     return (Hexagon::SA0 == R || Hexagon::LC0 == R || Hexagon::SA1 == R ||
113             Hexagon::LC1 == R);
114   }
115 
116 public:
117   explicit HexagonMCChecker(MCContext &Context, MCInstrInfo const &MCII,
118                             MCSubtargetInfo const &STI, MCInst &mcb,
119                             const MCRegisterInfo &ri, bool ReportErrors = true);
120   explicit HexagonMCChecker(HexagonMCChecker const &Check,
121                             MCSubtargetInfo const &STI, bool CopyReportErrors);
122 
123   bool check(bool FullCheck = true);
124   void reportErrorRegisters(unsigned Register);
125   void reportErrorNewValue(unsigned Register);
126   void reportError(SMLoc Loc, Twine const &Msg);
127   void reportNote(SMLoc Loc, Twine const &Msg);
128   void reportError(Twine const &Msg);
129   void reportWarning(Twine const &Msg);
130   void reportBranchErrors();
131 };
132 
133 } // end namespace llvm
134 
135 #endif // LLVM_LIB_TARGET_HEXAGON_MCTARGETDESC_HEXAGONMCCHECKER_H
136