Move methods out-of-line.

The internal representation of the Attributes class will be opaque. All of the
query methods will need to query the opaque class. Therefore, these methods need
to be out-of-line.
No functionality change intended.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165305 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/Attributes.h

@@ -27,8 +27,8 @@ class Type;
 
 namespace Attribute {
 
-/// We use this proxy POD type to allow constructing Attributes constants using
+/// AttrConst - We use this proxy POD type to allow constructing Attributes
-/// initializer lists. Do not use this class directly.
+/// constants using initializer lists. Do not use this class directly.
 struct AttrConst {
   uint64_t v;
   AttrConst operator | (const AttrConst Attrs) const {
@@ -157,95 +157,34 @@ public:
     Builder() : Bits(0) {}
     Builder(const Attributes &A) : Bits(A.Bits) {}
 
-    void addZExtAttr() {
+    void addAddressSafetyAttr();
-      Bits |= Attribute::ZExt_i;
+    void addAlwaysInlineAttr();
-    }
+    void addByValAttr();
-    void addSExtAttr() {
+    void addInlineHintAttr();
-      Bits |= Attribute::SExt_i;
+    void addInRegAttr();
-    }
+    void addNakedAttr();
-    void addNoReturnAttr() {
+    void addNestAttr();
-      Bits |= Attribute::NoReturn_i;
+    void addNoAliasAttr();
-    }
+    void addNoCaptureAttr();
-    void addInRegAttr() {
+    void addNoImplicitFloatAttr();
-      Bits |= Attribute::InReg_i;
+    void addNoInlineAttr();
-    }
+    void addNonLazyBindAttr();
-    void addStructRetAttr() {
+    void addNoRedZoneAttr();
-      Bits |= Attribute::StructRet_i;
+    void addNoReturnAttr();
-    }
+    void addNoUnwindAttr();
-    void addNoUnwindAttr() {
+    void addOptimizeForSizeAttr();
-      Bits |= Attribute::NoUnwind_i;
+    void addReadNoneAttr();
-    }
+    void addReadOnlyAttr();
-    void addNoAliasAttr() {
+    void addReturnsTwiceAttr();
-      Bits |= Attribute::NoAlias_i;
+    void addSExtAttr();
-    }
+    void addStackProtectAttr();
-    void addByValAttr() {
+    void addStackProtectReqAttr();
-      Bits |= Attribute::ByVal_i;
+    void addStructRetAttr();
-    }
+    void addUWTableAttr();
-    void addNestAttr() {
+    void addZExtAttr();
-      Bits |= Attribute::Nest_i;
-    }
-    void addReadNoneAttr() {
-      Bits |= Attribute::ReadNone_i;
-    }
-    void addReadOnlyAttr() {
-      Bits |= Attribute::ReadOnly_i;
-    }
-    void addNoInlineAttr() {
-      Bits |= Attribute::NoInline_i;
-    }
-    void addAlwaysInlineAttr() {
-      Bits |= Attribute::AlwaysInline_i;
-    }
-    void addOptimizeForSizeAttr() {
-      Bits |= Attribute::OptimizeForSize_i;
-    }
-    void addStackProtectAttr() {
-      Bits |= Attribute::StackProtect_i;
-    }
-    void addStackProtectReqAttr() {
-      Bits |= Attribute::StackProtectReq_i;
-    }
-    void addNoCaptureAttr() {
-      Bits |= Attribute::NoCapture_i;
-    }
-    void addNoRedZoneAttr() {
-      Bits |= Attribute::NoRedZone_i;
-    }
-    void addNoImplicitFloatAttr() {
-      Bits |= Attribute::NoImplicitFloat_i;
-    }
-    void addNakedAttr() {
-      Bits |= Attribute::Naked_i;
-    }
-    void addInlineHintAttr() {
-      Bits |= Attribute::InlineHint_i;
-    }
-    void addReturnsTwiceAttr() {
-      Bits |= Attribute::ReturnsTwice_i;
-    }
-    void addUWTableAttr() {
-      Bits |= Attribute::UWTable_i;
-    }
-    void addNonLazyBindAttr() {
-      Bits |= Attribute::NonLazyBind_i;
-    }
-    void addAddressSafetyAttr() {
-      Bits |= Attribute::AddressSafety_i;
-    }
-    void addAlignmentAttr(unsigned Align) {
-      if (Align == 0) return;
-      assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
-      assert(Align <= 0x40000000 && "Alignment too large.");
-      Bits |= (Log2_32(Align) + 1) << 16;
-    }
-    void addStackAlignmentAttr(unsigned Align) {
-      // Default alignment, allow the target to define how to align it.
-      if (Align == 0) return;
 
-      assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
+    void addAlignmentAttr(unsigned Align);
-      assert(Align <= 0x100 && "Alignment too large.");
+    void addStackAlignmentAttr(unsigned Align);
-      Bits |= (Log2_32(Align) + 1) << 26;
-    }
   };
 
   /// get - Return a uniquified Attributes object. This takes the uniquified
@@ -261,103 +200,41 @@ public:
     return Bits & A.Bits;
   }
 
-  bool hasZExtAttr() const {
+  bool hasAddressSafetyAttr() const;
-    return Bits & Attribute::ZExt_i;
+  bool hasAlignmentAttr() const;
-  }
+  bool hasAlwaysInlineAttr() const;
-  bool hasSExtAttr() const {
+  bool hasByValAttr() const;
-    return Bits & Attribute::SExt_i;
+  bool hasInRegAttr() const;
-  }
+  bool hasInlineHintAttr() const;
-  bool hasNoReturnAttr() const {
+  bool hasNakedAttr() const;
-    return Bits & Attribute::NoReturn_i;
+  bool hasNestAttr() const;
-  }
+  bool hasNoAliasAttr() const;
-  bool hasInRegAttr() const {
+  bool hasNoCaptureAttr() const;
-    return Bits & Attribute::InReg_i;
+  bool hasNoImplicitFloatAttr() const;
-  }
+  bool hasNoInlineAttr() const;
-  bool hasStructRetAttr() const {
+  bool hasNonLazyBindAttr() const;
-    return Bits & Attribute::StructRet_i;
+  bool hasNoRedZoneAttr() const;
-  }
+  bool hasNoReturnAttr() const;
-  bool hasNoUnwindAttr() const {
+  bool hasNoUnwindAttr() const;
-    return Bits & Attribute::NoUnwind_i;
+  bool hasOptimizeForSizeAttr() const;
-  }
+  bool hasReadNoneAttr() const;
-  bool hasNoAliasAttr() const {
+  bool hasReadOnlyAttr() const;
-    return Bits & Attribute::NoAlias_i;
+  bool hasReturnsTwiceAttr() const;
-  }
+  bool hasSExtAttr() const;
-  bool hasByValAttr() const {
+  bool hasStackAlignmentAttr() const;
-    return Bits & Attribute::ByVal_i;
+  bool hasStackProtectAttr() const;
-  }
+  bool hasStackProtectReqAttr() const;
-  bool hasNestAttr() const {
+  bool hasStructRetAttr() const;
-    return Bits & Attribute::Nest_i;
+  bool hasUWTableAttr() const;
-  }
+  bool hasZExtAttr() const;
-  bool hasReadNoneAttr() const {
-    return Bits & Attribute::ReadNone_i;
-  }
-  bool hasReadOnlyAttr() const {
-    return Bits & Attribute::ReadOnly_i;
-  }
-  bool hasNoInlineAttr() const {
-    return Bits & Attribute::NoInline_i;
-  }
-  bool hasAlwaysInlineAttr() const {
-    return Bits & Attribute::AlwaysInline_i;
-  }
-  bool hasOptimizeForSizeAttr() const {
-    return Bits & Attribute::OptimizeForSize_i;
-  }
-  bool hasStackProtectAttr() const {
-    return Bits & Attribute::StackProtect_i;
-  }
-  bool hasStackProtectReqAttr() const {
-    return Bits & Attribute::StackProtectReq_i;
-  }
-  bool hasAlignmentAttr() const {
-    return Bits & Attribute::Alignment_i;
-  }
-  bool hasNoCaptureAttr() const {
-    return Bits & Attribute::NoCapture_i;
-  }
-  bool hasNoRedZoneAttr() const {
-    return Bits & Attribute::NoRedZone_i;
-  }
-  bool hasNoImplicitFloatAttr() const {
-    return Bits & Attribute::NoImplicitFloat_i;
-  }
-  bool hasNakedAttr() const {
-    return Bits & Attribute::Naked_i;
-  }
-  bool hasInlineHintAttr() const {
-    return Bits & Attribute::InlineHint_i;
-  }
-  bool hasReturnsTwiceAttr() const {
-    return Bits & Attribute::ReturnsTwice_i;
-  }
-  bool hasStackAlignmentAttr() const {
-    return Bits & Attribute::StackAlignment_i;
-  }
-  bool hasUWTableAttr() const {
-    return Bits & Attribute::UWTable_i;
-  }
-  bool hasNonLazyBindAttr() const {
-    return Bits & Attribute::NonLazyBind_i;
-  }
-  bool hasAddressSafetyAttr() const {
-    return Bits & Attribute::AddressSafety_i;
-  }
 
   /// This returns the alignment field of an attribute as a byte alignment
   /// value.
-  unsigned getAlignment() const {
+  unsigned getAlignment() const;
-    if (!hasAlignmentAttr())
-      return 0;
-    return 1U << (((Bits & Attribute::Alignment_i) >> 16) - 1);
-  }
 
   /// This returns the stack alignment field of an attribute as a byte alignment
   /// value.
-  unsigned getStackAlignment() const {
+  unsigned getStackAlignment() const;
-    if (!hasStackAlignmentAttr())
-      return 0;
-    return 1U << (((Bits & Attribute::StackAlignment_i) >> 26) - 1);
-  }
 
   // This is a "safe bool() operator".
   operator const void *() const { return Bits ? this : 0; }
@@ -368,6 +245,7 @@ public:
   bool operator != (const Attributes &Attrs) const {
     return Bits != Attrs.Bits;
   }
+
   Attributes operator | (const Attributes &Attrs) const {
     return Attributes(Bits | Attrs.Bits);
   }
@@ -388,8 +266,8 @@ public:
   Attributes operator ~ () const { return Attributes(~Bits); }
   uint64_t Raw() const { return Bits; }
 
-  /// This turns an int alignment (a power of 2, normally) into the form used
+  /// constructAlignmentFromInt - This turns an int alignment (a power of 2,
-  /// internally in Attributes.
+  /// normally) into the form used internally in Attributes.
   static Attributes constructAlignmentFromInt(unsigned i) {
     // Default alignment, allow the target to define how to align it.
     if (i == 0)
@@ -400,8 +278,8 @@ public:
     return Attributes((Log2_32(i)+1) << 16);
   }
 
-  /// This turns an int stack alignment (which must be a power of 2) into the
+  /// constructStackAlignmentFromInt - This turns an int stack alignment (which
-  /// form used internally in Attributes.
+  /// must be a power of 2) into the form used internally in Attributes.
   static Attributes constructStackAlignmentFromInt(unsigned i) {
     // Default alignment, allow the target to define how to align it.
     if (i == 0)
@@ -415,9 +293,9 @@ public:
   /// @brief Which attributes cannot be applied to a type.
   static Attributes typeIncompatible(Type *Ty);
 
-  /// This returns an integer containing an encoding of all the LLVM attributes
+  /// encodeLLVMAttributesForBitcode - This returns an integer containing an
-  /// found in the given attribute bitset.  Any change to this encoding is a
+  /// encoding of all the LLVM attributes found in the given attribute bitset.
-  /// breaking change to bitcode compatibility.
+  /// Any change to this encoding is a breaking change to bitcode compatibility.
   static uint64_t encodeLLVMAttributesForBitcode(Attributes Attrs) {
     // FIXME: It doesn't make sense to store the alignment information as an
     // expanded out value, we should store it as a log2 value.  However, we
@@ -429,16 +307,17 @@ public:
     // Store the alignment in the bitcode as a 16-bit raw value instead of a
     // 5-bit log2 encoded value. Shift the bits above the alignment up by 11
     // bits.
-    uint64_t EncodedAttrs = Attrs.Raw() & 0xffff;
+    uint64_t EncodedAttrs = Attrs.Bits & 0xffff;
     if (Attrs.hasAlignmentAttr())
       EncodedAttrs |= (1ULL << 16) <<
         (((Attrs.Bits & Attribute::Alignment_i) - 1) >> 16);
-    EncodedAttrs |= (Attrs.Raw() & (0xfffULL << 21)) << 11;
+    EncodedAttrs |= (Attrs.Bits & (0xfffULL << 21)) << 11;
     return EncodedAttrs;
   }
 
-  /// This returns an attribute bitset containing the LLVM attributes that have
+  /// decodeLLVMAttributesForBitcode - This returns an attribute bitset
-  /// been decoded from the given integer.  This function must stay in sync with
+  /// containing the LLVM attributes that have been decoded from the given
+  /// integer.  This function must stay in sync with
   /// 'encodeLLVMAttributesForBitcode'.
   static Attributes decodeLLVMAttributesForBitcode(uint64_t EncodedAttrs) {
     // The alignment is stored as a 16-bit raw value from bits 31--16.  We shift
@@ -454,15 +333,19 @@ public:
     return Attrs;
   }
 
-  /// The set of Attributes set in Attributes is converted to a string of
+  /// getAsString - The set of Attributes set in Attributes is converted to a
-  /// equivalent mnemonics. This is, presumably, for writing out the mnemonics
+  /// string of equivalent mnemonics. This is, presumably, for writing out the
-  /// for the assembly writer.
+  /// mnemonics for the assembly writer.
   /// @brief Convert attribute bits to text
   std::string getAsString() const;
 };
 
-/// This is just a pair of values to associate a set of attributes
+//===----------------------------------------------------------------------===//
-/// with an index.
+// AttributeWithIndex
+//===----------------------------------------------------------------------===//
+
+/// AttributeWithIndex - This is just a pair of values to associate a set of
+/// attributes with an index.
 struct AttributeWithIndex {
   Attributes Attrs;  ///< The attributes that are set, or'd together.
   unsigned Index;    ///< Index of the parameter for which the attributes apply.

lib/VMCore/Attributes.cpp

@@ -28,6 +28,124 @@ using namespace llvm;
 // Attribute Function Definitions
 //===----------------------------------------------------------------------===//
 
+bool Attributes::hasAddressSafetyAttr() const {
+  return Bits & Attribute::AddressSafety_i;
+}
+bool Attributes::hasAlignmentAttr() const {
+  return Bits & Attribute::Alignment_i;
+}
+bool Attributes::hasAlwaysInlineAttr() const {
+  return Bits & Attribute::AlwaysInline_i;
+}
+bool Attributes::hasByValAttr() const {
+  return Bits & Attribute::ByVal_i;
+}
+bool Attributes::hasInlineHintAttr() const {
+  return Bits & Attribute::InlineHint_i;
+}
+bool Attributes::hasInRegAttr() const {
+  return Bits & Attribute::InReg_i;
+}
+bool Attributes::hasNakedAttr() const {
+  return Bits & Attribute::Naked_i;
+}
+bool Attributes::hasNestAttr() const {
+  return Bits & Attribute::Nest_i;
+}
+bool Attributes::hasNoAliasAttr() const {
+  return Bits & Attribute::NoAlias_i;
+}
+bool Attributes::hasNoCaptureAttr() const {
+  return Bits & Attribute::NoCapture_i;
+}
+bool Attributes::hasNoImplicitFloatAttr() const {
+  return Bits & Attribute::NoImplicitFloat_i;
+}
+bool Attributes::hasNoInlineAttr() const {
+  return Bits & Attribute::NoInline_i;
+}
+bool Attributes::hasNonLazyBindAttr() const {
+  return Bits & Attribute::NonLazyBind_i;
+}
+bool Attributes::hasNoRedZoneAttr() const {
+  return Bits & Attribute::NoRedZone_i;
+}
+bool Attributes::hasNoReturnAttr() const {
+  return Bits & Attribute::NoReturn_i;
+}
+bool Attributes::hasNoUnwindAttr() const {
+  return Bits & Attribute::NoUnwind_i;
+}
+bool Attributes::hasOptimizeForSizeAttr() const {
+  return Bits & Attribute::OptimizeForSize_i;
+}
+bool Attributes::hasReadNoneAttr() const {
+  return Bits & Attribute::ReadNone_i;
+}
+bool Attributes::hasReadOnlyAttr() const {
+  return Bits & Attribute::ReadOnly_i;
+}
+bool Attributes::hasReturnsTwiceAttr() const {
+  return Bits & Attribute::ReturnsTwice_i;
+}
+bool Attributes::hasSExtAttr() const {
+  return Bits & Attribute::SExt_i;
+}
+bool Attributes::hasStackAlignmentAttr() const {
+  return Bits & Attribute::StackAlignment_i;
+}
+bool Attributes::hasStackProtectAttr() const {
+  return Bits & Attribute::StackProtect_i;
+}
+bool Attributes::hasStackProtectReqAttr() const {
+  return Bits & Attribute::StackProtectReq_i;
+}
+bool Attributes::hasStructRetAttr() const {
+  return Bits & Attribute::StructRet_i;
+}
+bool Attributes::hasUWTableAttr() const {
+  return Bits & Attribute::UWTable_i;
+}
+bool Attributes::hasZExtAttr() const {
+  return Bits & Attribute::ZExt_i;
+}
+
+/// This returns the alignment field of an attribute as a byte alignment value.
+unsigned Attributes::getAlignment() const {
+  if (!hasAlignmentAttr())
+    return 0;
+  return 1U << (((Bits & Attribute::Alignment_i) >> 16) - 1);
+}
+
+/// This returns the stack alignment field of an attribute as a byte alignment
+/// value.
+unsigned Attributes::getStackAlignment() const {
+  if (!hasStackAlignmentAttr())
+    return 0;
+  return 1U << (((Bits & Attribute::StackAlignment_i) >> 26) - 1);
+}
+
+Attributes Attributes::typeIncompatible(Type *Ty) {
+  Attributes::Builder Incompatible;
+  
+  if (!Ty->isIntegerTy()) {
+    // Attributes that only apply to integers.
+    Incompatible.addSExtAttr();
+    Incompatible.addZExtAttr();
+  }
+  
+  if (!Ty->isPointerTy()) {
+    // Attributes that only apply to pointers.
+    Incompatible.addByValAttr();
+    Incompatible.addNestAttr();
+    Incompatible.addNoAliasAttr();
+    Incompatible.addNoCaptureAttr();
+    Incompatible.addStructRetAttr();
+  }
+  
+  return Attributes(Incompatible.Bits); // FIXME: Use Attributes::get().
+}
+
 std::string Attributes::getAsString() const {
   std::string Result;
   if (hasZExtAttr())
@@ -96,19 +214,98 @@ std::string Attributes::getAsString() const {
   return Result;
 }
 
-Attributes Attributes::typeIncompatible(Type *Ty) {
+//===----------------------------------------------------------------------===//
-  Attributes Incompatible = Attribute::None;
+// Attributes::Builder Implementation
+//===----------------------------------------------------------------------===//
 
-  if (!Ty->isIntegerTy())
+void Attributes::Builder::addAddressSafetyAttr() {
-    // Attributes that only apply to integers.
+  Bits |= Attribute::AddressSafety_i;
-    Incompatible |= Attribute::SExt | Attribute::ZExt;
+}
+void Attributes::Builder::addAlwaysInlineAttr() {
+  Bits |= Attribute::AlwaysInline_i;
+}
+void Attributes::Builder::addByValAttr() {
+  Bits |= Attribute::ByVal_i;
+}
+void Attributes::Builder::addInlineHintAttr() {
+  Bits |= Attribute::InlineHint_i;
+}
+void Attributes::Builder::addInRegAttr() {
+  Bits |= Attribute::InReg_i;
+}
+void Attributes::Builder::addNakedAttr() {
+  Bits |= Attribute::Naked_i;
+}
+void Attributes::Builder::addNestAttr() {
+  Bits |= Attribute::Nest_i;
+}
+void Attributes::Builder::addNoAliasAttr() {
+  Bits |= Attribute::NoAlias_i;
+}
+void Attributes::Builder::addNoCaptureAttr() {
+  Bits |= Attribute::NoCapture_i;
+}
+void Attributes::Builder::addNoImplicitFloatAttr() {
+  Bits |= Attribute::NoImplicitFloat_i;
+}
+void Attributes::Builder::addNoInlineAttr() {
+  Bits |= Attribute::NoInline_i;
+}
+void Attributes::Builder::addNonLazyBindAttr() {
+  Bits |= Attribute::NonLazyBind_i;
+}
+void Attributes::Builder::addNoRedZoneAttr() {
+  Bits |= Attribute::NoRedZone_i;
+}
+void Attributes::Builder::addNoReturnAttr() {
+  Bits |= Attribute::NoReturn_i;
+}
+void Attributes::Builder::addNoUnwindAttr() {
+  Bits |= Attribute::NoUnwind_i;
+}
+void Attributes::Builder::addOptimizeForSizeAttr() {
+  Bits |= Attribute::OptimizeForSize_i;
+}
+void Attributes::Builder::addReadNoneAttr() {
+  Bits |= Attribute::ReadNone_i;
+}
+void Attributes::Builder::addReadOnlyAttr() {
+  Bits |= Attribute::ReadOnly_i;
+}
+void Attributes::Builder::addReturnsTwiceAttr() {
+  Bits |= Attribute::ReturnsTwice_i;
+}
+void Attributes::Builder::addSExtAttr() {
+  Bits |= Attribute::SExt_i;
+}
+void Attributes::Builder::addStackProtectAttr() {
+  Bits |= Attribute::StackProtect_i;
+}
+void Attributes::Builder::addStackProtectReqAttr() {
+  Bits |= Attribute::StackProtectReq_i;
+}
+void Attributes::Builder::addStructRetAttr() {
+  Bits |= Attribute::StructRet_i;
+}
+void Attributes::Builder::addUWTableAttr() {
+  Bits |= Attribute::UWTable_i;
+}
+void Attributes::Builder::addZExtAttr() {
+  Bits |= Attribute::ZExt_i;
+}
 
-  if (!Ty->isPointerTy())
+void Attributes::Builder::addAlignmentAttr(unsigned Align) {
-    // Attributes that only apply to pointers.
+  if (Align == 0) return;
-    Incompatible |= Attribute::ByVal | Attribute::Nest | Attribute::NoAlias |
+  assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
-      Attribute::StructRet | Attribute::NoCapture;
+  assert(Align <= 0x40000000 && "Alignment too large.");
-  
+  Bits |= (Log2_32(Align) + 1) << 16;
-  return Incompatible;
+}
+void Attributes::Builder::addStackAlignmentAttr(unsigned Align) {
+  // Default alignment, allow the target to define how to align it.
+  if (Align == 0) return;
+  assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
+  assert(Align <= 0x100 && "Alignment too large.");
+  Bits |= (Log2_32(Align) + 1) << 26;
 }
 
 //===----------------------------------------------------------------------===//