Home | History | Annotate | Download | only in MCTargetDesc 
      1 //===----- HexagonMCChecker.h - Instruction bundle checking ---------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This implements the checking of insns inside a bundle according to the
     11 // packet constraint rules of the Hexagon ISA.
     12 //
     13 //===----------------------------------------------------------------------===//
     14 
     15 #ifndef HEXAGONMCCHECKER_H
     16 #define HEXAGONMCCHECKER_H
     17 
     18 #include <map>
     19 #include <set>
     20 #include <queue>
     21 #include "MCTargetDesc/HexagonMCShuffler.h"
     22 
     23 using namespace llvm;
     24 
     25 namespace llvm {
     26 class MCOperandInfo;
     27 
     28 typedef struct {
     29   unsigned Error, Warning, ShuffleError;
     30   unsigned Register;
     31 } ErrInfo_T;
     32 
     33 class HexagonMCErrInfo {
     34 public:
     35   enum {
     36     CHECK_SUCCESS         = 0,
     37     // Errors.
     38     CHECK_ERROR_BRANCHES  = 0x00001,
     39     CHECK_ERROR_NEWP      = 0x00002,
     40     CHECK_ERROR_NEWV      = 0x00004,
     41     CHECK_ERROR_REGISTERS = 0x00008,
     42     CHECK_ERROR_READONLY  = 0x00010,
     43     CHECK_ERROR_LOOP      = 0x00020,
     44     CHECK_ERROR_ENDLOOP   = 0x00040,
     45     CHECK_ERROR_SOLO      = 0x00080,
     46     CHECK_ERROR_SHUFFLE   = 0x00100,
     47     CHECK_ERROR_NOSLOTS   = 0x00200,
     48     CHECK_ERROR_UNKNOWN   = 0x00400,
     49     // Warnings.
     50     CHECK_WARN_CURRENT    = 0x10000,
     51     CHECK_WARN_TEMPORARY  = 0x20000
     52   };
     53   ErrInfo_T s;
     54 
     55   void reset() {
     56     s.Error = CHECK_SUCCESS;
     57     s.Warning = CHECK_SUCCESS;
     58     s.ShuffleError = HexagonShuffler::SHUFFLE_SUCCESS;
     59     s.Register = Hexagon::NoRegister;
     60   };
     61   HexagonMCErrInfo() {
     62     reset();
     63   };
     64 
     65   void setError(unsigned e, unsigned r = Hexagon::NoRegister)
     66     { s.Error = e; s.Register = r; };
     67   void setWarning(unsigned w, unsigned r = Hexagon::NoRegister)
     68     { s.Warning = w; s.Register = r; };
     69   void setShuffleError(unsigned e) { s.ShuffleError = e; };
     70 };
     71 
     72 /// Check for a valid bundle.
     73 class HexagonMCChecker {
     74   /// Insn bundle.
     75   MCInst& MCB;
     76   MCInst& MCBDX;
     77   const MCRegisterInfo& RI;
     78   MCInstrInfo const &MCII;
     79   MCSubtargetInfo const &STI;
     80   bool bLoadErrInfo;
     81 
     82   /// Set of definitions: register #, if predicated, if predicated true.
     83   typedef std::pair<unsigned, bool> PredSense;
     84   static const PredSense Unconditional;
     85   typedef std::multiset<PredSense> PredSet;
     86   typedef std::multiset<PredSense>::iterator PredSetIterator;
     87 
     88   typedef llvm::DenseMap<unsigned, PredSet>::iterator DefsIterator;
     89   llvm::DenseMap<unsigned, PredSet> Defs;
     90 
     91   /// Information about how a new-value register is defined or used:
     92   ///   PredReg = predicate register, 0 if use/def not predicated,
     93   ///   Cond    = true/false for if(PredReg)/if(!PredReg) respectively,
     94   ///   IsFloat = true if definition produces a floating point value
     95   ///             (not valid for uses),
     96   ///   IsNVJ   = true if the use is a new-value branch (not valid for
     97   ///             definitions).
     98   struct NewSense {
     99     unsigned PredReg;
    100     bool IsFloat, IsNVJ, Cond;
    101     // The special-case "constructors":
    102     static NewSense Jmp(bool isNVJ) {
    103       NewSense NS = { /*PredReg=*/ 0, /*IsFloat=*/ false, /*IsNVJ=*/ isNVJ,
    104                       /*Cond=*/ false };
    105       return NS;
    106     }
    107     static NewSense Use(unsigned PR, bool True) {
    108       NewSense NS = { /*PredReg=*/ PR, /*IsFloat=*/ false, /*IsNVJ=*/ false,
    109                       /*Cond=*/ True };
    110       return NS;
    111     }
    112     static NewSense Def(unsigned PR, bool True, bool Float) {
    113       NewSense NS = { /*PredReg=*/ PR, /*IsFloat=*/ Float, /*IsNVJ=*/ false,
    114                       /*Cond=*/ True };
    115       return NS;
    116     }
    117   };
    118   /// Set of definitions that produce new register:
    119   typedef llvm::SmallVector<NewSense,2> NewSenseList;
    120   typedef llvm::DenseMap<unsigned, NewSenseList>::iterator NewDefsIterator;
    121   llvm::DenseMap<unsigned, NewSenseList> NewDefs;
    122 
    123   /// Set of weak definitions whose clashes should be enforced selectively.
    124   typedef std::set<unsigned>::iterator SoftDefsIterator;
    125   std::set<unsigned> SoftDefs;
    126 
    127   /// Set of current definitions committed to the register file.
    128   typedef std::set<unsigned>::iterator CurDefsIterator;
    129   std::set<unsigned> CurDefs;
    130 
    131   /// Set of temporary definitions not committed to the register file.
    132   typedef std::set<unsigned>::iterator TmpDefsIterator;
    133   std::set<unsigned> TmpDefs;
    134 
    135   /// Set of new predicates used.
    136   typedef std::set<unsigned>::iterator NewPredsIterator;
    137   std::set<unsigned> NewPreds;
    138 
    139   /// Set of predicates defined late.
    140   typedef std::multiset<unsigned>::iterator LatePredsIterator;
    141   std::multiset<unsigned> LatePreds;
    142 
    143   /// Set of uses.
    144   typedef std::set<unsigned>::iterator UsesIterator;
    145   std::set<unsigned> Uses;
    146 
    147   /// Set of new values used: new register, if new-value jump.
    148   typedef llvm::DenseMap<unsigned, NewSense>::iterator NewUsesIterator;
    149   llvm::DenseMap<unsigned, NewSense> NewUses;
    150 
    151   /// Pre-defined set of read-only registers.
    152   typedef std::set<unsigned>::iterator ReadOnlyIterator;
    153   std::set<unsigned> ReadOnly;
    154 
    155   std::queue<ErrInfo_T> ErrInfoQ;
    156   HexagonMCErrInfo CrntErrInfo;
    157 
    158   void getErrInfo() {
    159     if (bLoadErrInfo == true) {
    160       if (ErrInfoQ.empty()) {
    161         CrntErrInfo.reset();
    162       } else {
    163         CrntErrInfo.s = ErrInfoQ.front();
    164         ErrInfoQ.pop();
    165       }
    166     }
    167     bLoadErrInfo = false;
    168   }
    169 
    170   void init();
    171   void init(MCInst const&);
    172 
    173   // Checks performed.
    174   bool checkBranches();
    175   bool checkPredicates();
    176   bool checkNewValues();
    177   bool checkRegisters();
    178   bool checkSolo();
    179   bool checkShuffle();
    180   bool checkSlots();
    181 
    182   static void compoundRegisterMap(unsigned&);
    183 
    184   bool isPredicateRegister(unsigned R) const {
    185     return (Hexagon::P0 == R || Hexagon::P1 == R ||
    186             Hexagon::P2 == R || Hexagon::P3 == R);
    187   };
    188   bool isLoopRegister(unsigned R) const {
    189     return (Hexagon::SA0 == R || Hexagon::LC0 == R ||
    190             Hexagon::SA1 == R || Hexagon::LC1 == R);
    191   };
    192 
    193   bool hasValidNewValueDef(const NewSense &Use,
    194                            const NewSenseList &Defs) const;
    195 
    196   public:
    197   explicit HexagonMCChecker(MCInstrInfo const &MCII, MCSubtargetInfo const &STI, MCInst& mcb, MCInst &mcbdx,
    198                             const MCRegisterInfo& ri);
    199 
    200   bool check();
    201 
    202   /// add a new error/warning
    203   void addErrInfo(HexagonMCErrInfo &err) { ErrInfoQ.push(err.s); };
    204 
    205   /// Return the error code for the last operation in the insn bundle.
    206   unsigned getError() { getErrInfo(); return CrntErrInfo.s.Error; };
    207   unsigned getWarning() { getErrInfo(); return CrntErrInfo.s.Warning; };
    208   unsigned getShuffleError() { getErrInfo(); return CrntErrInfo.s.ShuffleError; };
    209   unsigned getErrRegister() { getErrInfo(); return CrntErrInfo.s.Register; };
    210   bool getNextErrInfo() {
    211     bLoadErrInfo = true;
    212     return (ErrInfoQ.empty()) ? false : (getErrInfo(), true);
    213   }
    214 };
    215 
    216 }
    217 
    218 #endif // HEXAGONMCCHECKER_H
    219