[cfe-commits] r77299 - in /cfe/trunk: include/clang/AST/Type.h lib/AST/Type.cpp

[John McCall]

Author: rjmccall
Date: Tue Jul 28 00:41:20 2009
New Revision: 77299

URL: http://llvm.org/viewvc/llvm-project?rev=77299&view=rev
Log:
Reimplement QualifierSet using a single word, as requested by dgregor.


Modified:
    cfe/trunk/include/clang/AST/Type.h
    cfe/trunk/lib/AST/Type.cpp

Modified: cfe/trunk/include/clang/AST/Type.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/AST/Type.h?rev=77299&r1=77298&r2=77299&view=diff

==============================================================================
--- cfe/trunk/include/clang/AST/Type.h (original)
+++ cfe/trunk/include/clang/AST/Type.h Tue Jul 28 00:41:20 2009
@@ -571,38 +571,51 @@
 /// QualifierSet - This class is used to collect qualifiers.
 class QualifierSet {
 public:
-  QualifierSet() :
-    CVRMask(0), AddressSpace(0), GCAttrType(QualType::GCNone) {
-  }
+  QualifierSet() : Mask(0) {}
 
   void removeConst() { removeCVR(QualType::Const); }
   void removeVolatile() { removeCVR(QualType::Volatile); }
   void removeRestrict() { removeCVR(QualType::Restrict); }
-  void removeCVR(unsigned mask) { CVRMask &= ~mask; }
-  void removeAddressSpace() { AddressSpace = 0; }
-  void removeGCAttrType() { GCAttrType = QualType::GCNone; }
+  void removeCVR(unsigned mask) { Mask &= ~mask; }
+  void removeAddressSpace() { setAddressSpace(0); }
+  void removeObjCGCAttrType() { setGCAttrType(QualType::GCNone); }
 
   void addConst() { addCVR(QualType::Const); }
   void addVolatile() { addCVR(QualType::Volatile); }
   void addRestrict() { addCVR(QualType::Restrict); }
-  void addCVR(unsigned mask) { CVRMask |= mask; }
+  void addCVR(unsigned mask) { Mask |= mask; }
   void addAddressSpace(unsigned space) {
     assert(space);
-    AddressSpace = space;
+    setAddressSpace(space);
   }
-  void addGCAttrType(QualType::GCAttrTypes type) {
+  void addObjCGCAttrType(QualType::GCAttrTypes type) {
     assert(type);
-    GCAttrType = type;
+    setGCAttrType(type);
+  }
+
+  bool hasConst() const { return Mask & QualType::Const; }
+  bool hasVolatile() const { return Mask & QualType::Volatile; }
+  bool hasRestrict() const { return Mask & QualType::Restrict; }
+  unsigned getCVRMask() const { return Mask & CVRMask; }
+
+  bool hasObjCGCAttrType() const { return Mask & GCAttrMask; }
+  QualType::GCAttrTypes getObjCGCAttrType() const {
+    return QualType::GCAttrTypes((Mask & GCAttrMask) >> GCAttrShift);
   }
 
+  bool hasAddressSpace() const { return Mask & AddressSpaceMask; }
+  unsigned getAddressSpace() const { return Mask >> AddressSpaceShift; }
+
+  /// empty() - Return true if there are no qualifiers collected
+  /// in this set.
   bool empty() {
-    return !CVRMask && !AddressSpace && !GCAttrType;
+    return (Mask == 0);
   }
 
   /// Collect any qualifiers on the given type and return an
   /// unqualified type.
   const Type *strip(QualType QT) {
-    CVRMask |= QT.getCVRQualifiers();
+    Mask |= QT.getCVRQualifiers();
     return strip(QT.getTypePtr());
   }
 
@@ -617,11 +630,30 @@
   QualType apply(const Type* T, ASTContext& C) {
     return apply(QualType(T, 0), C);
   }
+
+  bool operator==(QualifierSet& Other) { return Mask == Other.Mask; }
   
 private:
-  unsigned CVRMask;
-  unsigned AddressSpace;
-  QualType::GCAttrTypes GCAttrType;
+  void setAddressSpace(unsigned space) {
+    assert(space <= MaxAddressSpace);
+    Mask = (Mask & ~AddressSpaceMask)
+         | (((uint32_t) space) << AddressSpaceShift);
+  }
+
+  void setGCAttrType(QualType::GCAttrTypes type) {
+    Mask = (Mask & ~GCAttrMask) | (type << GCAttrShift);
+  }
+
+  // bits:     |0 1 2|3 .. 4|5  ..  31|
+  //           |C R V|GCAttr|AddrSpace|
+  uint32_t Mask;
+
+  static const uint32_t CVRMask = 0x07;
+  static const uint32_t GCAttrMask = 0x18;
+  static const uint32_t GCAttrShift = 3;
+  static const uint32_t AddressSpaceMask = ~(CVRMask | GCAttrMask);
+  static const uint32_t AddressSpaceShift = 5;
+  static const unsigned MaxAddressSpace = ~0u >> AddressSpaceShift;
 };
 
 

Modified: cfe/trunk/lib/AST/Type.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/Type.cpp?rev=77299&r1=77298&r2=77299&view=diff

==============================================================================
--- cfe/trunk/lib/AST/Type.cpp (original)
+++ cfe/trunk/lib/AST/Type.cpp Tue Jul 28 00:41:20 2009
@@ -1075,13 +1075,13 @@
 
 const Type *QualifierSet::strip(const Type* T) {
   QualType DT = T->getDesugaredType();
-  CVRMask |= DT.getCVRQualifiers();
+  addCVR(DT.getCVRQualifiers());
   
   if (const ExtQualType* EQT = dyn_cast<ExtQualType>(DT)) {
     if (EQT->getAddressSpace())
-      AddressSpace = EQT->getAddressSpace();
+      addAddressSpace(EQT->getAddressSpace());
     if (EQT->getObjCGCAttr())
-      GCAttrType = EQT->getObjCGCAttr();
+      addObjCGCAttrType(EQT->getObjCGCAttr());
     return EQT->getBaseType();
   } else {
     // Use the sugared type unless desugaring found extra qualifiers.
@@ -1090,9 +1090,9 @@
 }
 
 QualType QualifierSet::apply(QualType QT, ASTContext& C) {
-  QT = QT.getWithAdditionalQualifiers(CVRMask);
-  if (GCAttrType) QT = C.getObjCGCQualType(QT, GCAttrType);
-  if (AddressSpace) QT = C.getAddrSpaceQualType(QT, AddressSpace);
+  QT = QT.getWithAdditionalQualifiers(getCVRMask());
+  if (hasObjCGCAttrType()) QT = C.getObjCGCQualType(QT, getObjCGCAttrType());
+  if (hasAddressSpace()) QT = C.getAddrSpaceQualType(QT, getAddressSpace());
   return QT;
 }