Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===- llvm/MC/LaneBitmask.h ------------------------------------*- 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. /// \file
  10. /// A common definition of LaneBitmask for use in TableGen and CodeGen.
  11. ///
  12. /// A lane mask is a bitmask representing the covering of a register with
  13. /// sub-registers.
  14. ///
  15. /// This is typically used to track liveness at sub-register granularity.
  16. /// Lane masks for sub-register indices are similar to register units for
  17. /// physical registers. The individual bits in a lane mask can't be assigned
  18. /// any specific meaning. They can be used to check if two sub-register
  19. /// indices overlap.
  20. ///
  21. /// Iff the target has a register such that:
  22. ///
  23. ///   getSubReg(Reg, A) overlaps getSubReg(Reg, B)
  24. ///
  25. /// then:
  26. ///
  27. ///   (getSubRegIndexLaneMask(A) & getSubRegIndexLaneMask(B)) != 0
  28.  
  29. #ifndef LLVM_MC_LANEBITMASK_H
  30. #define LLVM_MC_LANEBITMASK_H
  31.  
  32. #include "llvm/Support/Compiler.h"
  33. #include "llvm/Support/Format.h"
  34. #include "llvm/Support/MathExtras.h"
  35. #include "llvm/Support/Printable.h"
  36. #include "llvm/Support/raw_ostream.h"
  37.  
  38. namespace llvm {
  39.  
  40.   struct LaneBitmask {
  41.     // When changing the underlying type, change the format string as well.
  42.     using Type = uint64_t;
  43.     enum : unsigned { BitWidth = 8*sizeof(Type) };
  44.     constexpr static const char *const FormatStr = "%016llX";
  45.  
  46.     constexpr LaneBitmask() = default;
  47.     explicit constexpr LaneBitmask(Type V) : Mask(V) {}
  48.  
  49.     constexpr bool operator== (LaneBitmask M) const { return Mask == M.Mask; }
  50.     constexpr bool operator!= (LaneBitmask M) const { return Mask != M.Mask; }
  51.     constexpr bool operator< (LaneBitmask M)  const { return Mask < M.Mask; }
  52.     constexpr bool none() const { return Mask == 0; }
  53.     constexpr bool any()  const { return Mask != 0; }
  54.     constexpr bool all()  const { return ~Mask == 0; }
  55.  
  56.     constexpr LaneBitmask operator~() const {
  57.       return LaneBitmask(~Mask);
  58.     }
  59.     constexpr LaneBitmask operator|(LaneBitmask M) const {
  60.       return LaneBitmask(Mask | M.Mask);
  61.     }
  62.     constexpr LaneBitmask operator&(LaneBitmask M) const {
  63.       return LaneBitmask(Mask & M.Mask);
  64.     }
  65.     LaneBitmask &operator|=(LaneBitmask M) {
  66.       Mask |= M.Mask;
  67.       return *this;
  68.     }
  69.     LaneBitmask &operator&=(LaneBitmask M) {
  70.       Mask &= M.Mask;
  71.       return *this;
  72.     }
  73.  
  74.     constexpr Type getAsInteger() const { return Mask; }
  75.  
  76.     unsigned getNumLanes() const { return llvm::popcount(Mask); }
  77.     unsigned getHighestLane() const {
  78.       return Log2_64(Mask);
  79.     }
  80.  
  81.     static constexpr LaneBitmask getNone() { return LaneBitmask(0); }
  82.     static constexpr LaneBitmask getAll() { return ~LaneBitmask(0); }
  83.     static constexpr LaneBitmask getLane(unsigned Lane) {
  84.       return LaneBitmask(Type(1) << Lane);
  85.     }
  86.  
  87.   private:
  88.     Type Mask = 0;
  89.   };
  90.  
  91.   /// Create Printable object to print LaneBitmasks on a \ref raw_ostream.
  92.   inline Printable PrintLaneMask(LaneBitmask LaneMask) {
  93.     return Printable([LaneMask](raw_ostream &OS) {
  94.       OS << format(LaneBitmask::FormatStr, LaneMask.getAsInteger());
  95.     });
  96.   }
  97.  
  98. } // end namespace llvm
  99.  
  100. #endif // LLVM_MC_LANEBITMASK_H
  101.