lib/Target/Hexagon/MCTargetDesc/HexagonShuffler.h

   1 //===----- HexagonShuffler.h - Instruction bundle shuffling ---------------===//
   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 shuffling of insns inside a bundle according to the
  11 // packet formation rules of the Hexagon ISA.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef HEXAGONSHUFFLER_H
  16 #define HEXAGONSHUFFLER_H
  17
  18 #include "Hexagon.h"
  19 #include "MCTargetDesc/HexagonMCInstrInfo.h"
  20
  21 #include "llvm/ADT/SmallVector.h"
  22 #include "llvm/MC/MCInstrInfo.h"
  23
  24 using namespace llvm;
  25
  26 namespace llvm {
  27 // Insn resources.
  28 class HexagonResource {
  29   // Mask of the slots or units that may execute the insn and
  30   // the weight or priority that the insn requires to be assigned a slot.
  31   unsigned Slots, Weight;
  32
  33 public:
  34   HexagonResource(unsigned s) { setUnits(s); };
  35
  36   void setUnits(unsigned s) {
  37     Slots = s & ~(~0U << HEXAGON_PACKET_SIZE);
  38   };
  39   unsigned setWeight(unsigned s);
  40
  41   unsigned getUnits() const { return (Slots); };
  42   unsigned getWeight() const { return (Weight); };
  43
  44   // Check if the resources are in ascending slot order.
  45   static bool lessUnits(const HexagonResource &A, const HexagonResource &B) {
  46     return (countPopulation(A.getUnits()) < countPopulation(B.getUnits()));
  47   };
  48   // Check if the resources are in ascending weight order.
  49   static bool lessWeight(const HexagonResource &A, const HexagonResource &B) {
  50     return (A.getWeight() < B.getWeight());
  51   };
  52 };
  53
  54 // HVX insn resources.
  55 class HexagonCVIResource : public HexagonResource {
  56   typedef std::pair<unsigned, unsigned> UnitsAndLanes;
  57   typedef llvm::DenseMap<unsigned, UnitsAndLanes> TypeUnitsAndLanes;
  58
  59   // Available HVX slots.
  60   enum {
  61     CVI_NONE = 0,
  62     CVI_XLANE = 1 << 0,
  63     CVI_SHIFT = 1 << 1,
  64     CVI_MPY0 = 1 << 2,
  65     CVI_MPY1 = 1 << 3
  66   };
  67
  68   static bool SetUp;
  69   static bool setup();
  70   static TypeUnitsAndLanes *TUL;
  71
  72   // Count of adjacent slots that the insn requires to be executed.
  73   unsigned Lanes;
  74   // Flag whether the insn is a load or a store.
  75   bool Load, Store;
  76   // Flag whether the HVX resources are valid.
  77   bool Valid;
  78
  79   void setLanes(unsigned l) { Lanes = l; };
  80   void setLoad(bool f = true) { Load = f; };
  81   void setStore(bool f = true) { Store = f; };
  82
  83 public:
  84   HexagonCVIResource(MCInstrInfo const &MCII, unsigned s, MCInst const *id);
  85
  86   bool isValid() const { return (Valid); };
  87   unsigned getLanes() const { return (Lanes); };
  88   bool mayLoad() const { return (Load); };
  89   bool mayStore() const { return (Store); };
  90 };
  91
  92 // Handle to an insn used by the shuffling algorithm.
  93 class HexagonInstr {
  94   friend class HexagonShuffler;
  95
  96   MCInst const *ID;
  97   MCInst const *Extender;
  98   HexagonResource Core;
  99   HexagonCVIResource CVI;
 100   bool SoloException;
 101
 102 public:
 103   HexagonInstr(MCInstrInfo const &MCII, MCInst const *id,
 104                MCInst const *Extender, unsigned s, bool x = false)
 105       : ID(id), Extender(Extender), Core(s), CVI(MCII, s, id),
 106         SoloException(x){};
 107
 108   MCInst const *getDesc() const { return (ID); };
 109
 110   MCInst const *getExtender() const { return Extender; }
 111
 112   unsigned isSoloException() const { return (SoloException); };
 113
 114   // Check if the handles are in ascending order for shuffling purposes.
 115   bool operator<(const HexagonInstr &B) const {
 116     return (HexagonResource::lessWeight(B.Core, Core));
 117   };
 118   // Check if the handles are in ascending order by core slots.
 119   static bool lessCore(const HexagonInstr &A, const HexagonInstr &B) {
 120     return (HexagonResource::lessUnits(A.Core, B.Core));
 121   };
 122   // Check if the handles are in ascending order by HVX slots.
 123   static bool lessCVI(const HexagonInstr &A, const HexagonInstr &B) {
 124     return (HexagonResource::lessUnits(A.CVI, B.CVI));
 125   };
 126 };
 127
 128 // Bundle shuffler.
 129 class HexagonShuffler {
 130   typedef SmallVector<HexagonInstr, HEXAGON_PRESHUFFLE_PACKET_SIZE>
 131       HexagonPacket;
 132
 133   // Insn handles in a bundle.
 134   HexagonPacket Packet;
 135
 136   // Shuffling error code.
 137   unsigned Error;
 138
 139 protected:
 140   int64_t BundleFlags;
 141   MCInstrInfo const &MCII;
 142   MCSubtargetInfo const &STI;
 143
 144 public:
 145   typedef HexagonPacket::iterator iterator;
 146
 147   enum {
 148     SHUFFLE_SUCCESS = 0,    ///< Successful operation.
 149     SHUFFLE_ERROR_INVALID,  ///< Invalid bundle.
 150     SHUFFLE_ERROR_STORES,   ///< No free slots for store insns.
 151     SHUFFLE_ERROR_LOADS,    ///< No free slots for load insns.
 152     SHUFFLE_ERROR_BRANCHES, ///< No free slots for branch insns.
 153     SHUFFLE_ERROR_NOSLOTS,  ///< No free slots for other insns.
 154     SHUFFLE_ERROR_SLOTS,    ///< Over-subscribed slots.
 155     SHUFFLE_ERROR_ERRATA2, ///< Errata violation (v60).
 156     SHUFFLE_ERROR_STORE_LOAD_CONFLICT, ///< store/load conflict
 157     SHUFFLE_ERROR_UNKNOWN   ///< Unknown error.
 158   };
 159
 160   explicit HexagonShuffler(MCInstrInfo const &MCII, MCSubtargetInfo const &STI);
 161
 162   // Reset to initial state.
 163   void reset();
 164   // Check if the bundle may be validly shuffled.
 165   bool check();
 166   // Reorder the insn handles in the bundle.
 167   bool shuffle();
 168
 169   unsigned size() const { return (Packet.size()); };
 170
 171   iterator begin() { return (Packet.begin()); };
 172   iterator end() { return (Packet.end()); };
 173
 174   // Add insn handle to the bundle .
 175   void append(MCInst const *ID, MCInst const *Extender, unsigned S,
 176               bool X = false);
 177
 178   // Return the error code for the last check or shuffling of the bundle.
 179   void setError(unsigned Err) { Error = Err; };
 180   unsigned getError() const { return (Error); };
 181 };
 182 }
 183
 184 #endif // HEXAGONSHUFFLER_H