CbC/CbC_llvm: lib/IR/Attributes.cpp comparison

comparison lib/IR/Attributes.cpp @ 148:63bd29f05246

merged

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Wed, 14 Aug 2019 19:46:37 +0900
parents	c2174574ed3a
children

comparison

equal deleted inserted replaced

-:3fc4d5c3e21e
+:63bd29f05246
 //===- Attributes.cpp - Implement AttributesList --------------------------===//
 //
-//                     The LLVM Compiler Infrastructure
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-//
+// See https://llvm.org/LICENSE.txt for license information.
-// This file is distributed under the University of Illinois Open Source
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // \file
-// \brief This file implements the Attribute, AttributeImpl, AttrBuilder,
+// This file implements the Attribute, AttributeImpl, AttrBuilder,
 // AttributeListImpl, and AttributeList classes.
 //
 //===----------------------------------------------------------------------===//
 #include "llvm/IR/Attributes.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/Config/llvm-config.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include <cassert>
 #include <climits>
 #include <cstddef>
 #include <cstdint>
 #include <limits>
-#include <map>
 #include <string>
 #include <tuple>
 #include <utility>
 using namespace llvm;
 // Return the Attribute that we found or created.
 return Attribute(PA);
 }
+Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind,
+Type *Ty) {
+LLVMContextImpl *pImpl = Context.pImpl;
+FoldingSetNodeID ID;
+ID.AddInteger(Kind);
+ID.AddPointer(Ty);
+void *InsertPoint;
+AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);
+if (!PA) {
+// If we didn't find any existing attributes of the same shape then create a
+// new one and insert it.
+PA = new TypeAttributeImpl(Kind, Ty);
+pImpl->AttrsSet.InsertNode(PA, InsertPoint);
+}
+// Return the Attribute that we found or created.
+return Attribute(PA);
+}
 Attribute Attribute::getWithAlignment(LLVMContext &Context, uint64_t Align) {
 assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
 assert(Align <= 0x40000000 && "Alignment too large.");
 return get(Context, Alignment, Align);
 }
 Attribute Attribute::getWithDereferenceableOrNullBytes(LLVMContext &Context,
 uint64_t Bytes) {
 assert(Bytes && "Bytes must be non-zero.");
 return get(Context, DereferenceableOrNull, Bytes);
+}
+Attribute Attribute::getWithByValType(LLVMContext &Context, Type *Ty) {
+return get(Context, ByVal, Ty);
 }
 Attribute
 Attribute::getWithAllocSizeArgs(LLVMContext &Context, unsigned ElemSizeArg,
 const Optional<unsigned> &NumElemsArg) {
 bool Attribute::isStringAttribute() const {
 return pImpl && pImpl->isStringAttribute();
 }
+bool Attribute::isTypeAttribute() const {
+return pImpl && pImpl->isTypeAttribute();
+}
 Attribute::AttrKind Attribute::getKindAsEnum() const {
 if (!pImpl) return None;
-assert((isEnumAttribute() || isIntAttribute()) &&
+assert((isEnumAttribute() || isIntAttribute() || isTypeAttribute()) &&
 "Invalid attribute type to get the kind as an enum!");
 return pImpl->getKindAsEnum();
 }
 uint64_t Attribute::getValueAsInt() const {
 "Expected the attribute to be an integer attribute!");
 return pImpl->getValueAsInt();
 }
 StringRef Attribute::getKindAsString() const {
-if (!pImpl) return StringRef();
+if (!pImpl) return {};
 assert(isStringAttribute() &&
 "Invalid attribute type to get the kind as a string!");
 return pImpl->getKindAsString();
 }
 StringRef Attribute::getValueAsString() const {
-if (!pImpl) return StringRef();
+if (!pImpl) return {};
 assert(isStringAttribute() &&
 "Invalid attribute type to get the value as a string!");
 return pImpl->getValueAsString();
 }
+Type *Attribute::getValueAsType() const {
+if (!pImpl) return {};
+assert(isTypeAttribute() &&
+"Invalid attribute type to get the value as a type!");
+return pImpl->getValueAsType();
+}
 bool Attribute::hasAttribute(AttrKind Kind) const {
 return (pImpl && pImpl->hasAttribute(Kind)) || (!pImpl && Kind == None);
 }
 "Trying to get allocsize args from non-allocsize attribute");
 return unpackAllocSizeArgs(pImpl->getValueAsInt());
 }
 std::string Attribute::getAsString(bool InAttrGrp) const {
-if (!pImpl) return "";
+if (!pImpl) return {};
 if (hasAttribute(Attribute::SanitizeAddress))
 return "sanitize_address";
 if (hasAttribute(Attribute::SanitizeHWAddress))
 return "sanitize_hwaddress";
+if (hasAttribute(Attribute::SanitizeMemTag))
+return "sanitize_memtag";
 if (hasAttribute(Attribute::AlwaysInline))
 return "alwaysinline";
 if (hasAttribute(Attribute::ArgMemOnly))
 return "argmemonly";
 if (hasAttribute(Attribute::Builtin))
 return "builtin";
-if (hasAttribute(Attribute::ByVal))
-return "byval";
 if (hasAttribute(Attribute::Convergent))
 return "convergent";
 if (hasAttribute(Attribute::SwiftError))
 return "swifterror";
 if (hasAttribute(Attribute::SwiftSelf))
 return "nobuiltin";
 if (hasAttribute(Attribute::NoCapture))
 return "nocapture";
 if (hasAttribute(Attribute::NoDuplicate))
 return "noduplicate";
+if (hasAttribute(Attribute::NoFree))
+return "nofree";
 if (hasAttribute(Attribute::NoImplicitFloat))
 return "noimplicitfloat";
 if (hasAttribute(Attribute::NoInline))
 return "noinline";
 if (hasAttribute(Attribute::NonLazyBind))
 return "nonnull";
 if (hasAttribute(Attribute::NoRedZone))
 return "noredzone";
 if (hasAttribute(Attribute::NoReturn))
 return "noreturn";
+if (hasAttribute(Attribute::NoSync))
+return "nosync";
+if (hasAttribute(Attribute::WillReturn))
+return "willreturn";
+if (hasAttribute(Attribute::NoCfCheck))
+return "nocf_check";
 if (hasAttribute(Attribute::NoRecurse))
 return "norecurse";
 if (hasAttribute(Attribute::NoUnwind))
 return "nounwind";
+if (hasAttribute(Attribute::OptForFuzzing))
+return "optforfuzzing";
 if (hasAttribute(Attribute::OptimizeNone))
 return "optnone";
 if (hasAttribute(Attribute::OptimizeForSize))
 return "optsize";
 if (hasAttribute(Attribute::ReadNone))
 return "returned";
 if (hasAttribute(Attribute::ReturnsTwice))
 return "returns_twice";
 if (hasAttribute(Attribute::SExt))
 return "signext";
+if (hasAttribute(Attribute::SpeculativeLoadHardening))
+return "speculative_load_hardening";
 if (hasAttribute(Attribute::Speculatable))
 return "speculatable";
 if (hasAttribute(Attribute::StackProtect))
 return "ssp";
 if (hasAttribute(Attribute::StackProtectReq))
 return "sspreq";
 if (hasAttribute(Attribute::StackProtectStrong))
 return "sspstrong";
 if (hasAttribute(Attribute::SafeStack))
 return "safestack";
+if (hasAttribute(Attribute::ShadowCallStack))
+return "shadowcallstack";
 if (hasAttribute(Attribute::StrictFP))
 return "strictfp";
 if (hasAttribute(Attribute::StructRet))
 return "sret";
 if (hasAttribute(Attribute::SanitizeThread))
 return "uwtable";
 if (hasAttribute(Attribute::ZExt))
 return "zeroext";
 if (hasAttribute(Attribute::Cold))
 return "cold";
+if (hasAttribute(Attribute::ImmArg))
+return "immarg";
+if (hasAttribute(Attribute::ByVal)) {
+std::string Result;
+Result += "byval";
+if (Type *Ty = getValueAsType()) {
+raw_string_ostream OS(Result);
+Result += '(';
+Ty->print(OS, false, true);
+OS.flush();
+Result += ')';
+}
+return Result;
+}
 // FIXME: These should be output like this:
 //
 //   align=4
 //   alignstack=8
 // printable, those have to be escaped to make the attribute value printable
 // as is.  e.g. "\01__gnu_mcount_nc"
 {
 raw_string_ostream OS(Result);
 OS << "=\"";
-PrintEscapedString(AttrVal, OS);
+printEscapedString(AttrVal, OS);
 OS << "\"";
 }
 return Result;
 }
 void IntAttributeImpl::anchor() {}
 void StringAttributeImpl::anchor() {}
+void TypeAttributeImpl::anchor() {}
 bool AttributeImpl::hasAttribute(Attribute::AttrKind A) const {
 if (isStringAttribute()) return false;
 return getKindAsEnum() == A;
 }
 if (!isStringAttribute()) return false;
 return getKindAsString() == Kind;
 }
 Attribute::AttrKind AttributeImpl::getKindAsEnum() const {
-assert(isEnumAttribute() || isIntAttribute());
+assert(isEnumAttribute() || isIntAttribute() || isTypeAttribute());
 return static_cast<const EnumAttributeImpl *>(this)->getEnumKind();
 }
 uint64_t AttributeImpl::getValueAsInt() const {
 assert(isIntAttribute());
 }
 StringRef AttributeImpl::getValueAsString() const {
 assert(isStringAttribute());
 return static_cast<const StringAttributeImpl *>(this)->getStringValue();
+}
+Type *AttributeImpl::getValueAsType() const {
+assert(isTypeAttribute());
+return static_cast<const TypeAttributeImpl *>(this)->getTypeValue();
 }
 bool AttributeImpl::operator<(const AttributeImpl &AI) const {
 // This sorts the attributes with Attribute::AttrKinds coming first (sorted
 // relative to their enum value) and then strings.
 if (isEnumAttribute()) {
 if (AI.isEnumAttribute()) return getKindAsEnum() < AI.getKindAsEnum();
 if (AI.isIntAttribute()) return true;
 if (AI.isStringAttribute()) return true;
+if (AI.isTypeAttribute()) return true;
+}
+if (isTypeAttribute()) {
+if (AI.isEnumAttribute()) return false;
+if (AI.isTypeAttribute()) {
+assert(getKindAsEnum() != AI.getKindAsEnum() &&
+"Comparison of types would be unstable");
+return getKindAsEnum() < AI.getKindAsEnum();
+}
+if (AI.isIntAttribute()) return true;
+if (AI.isStringAttribute()) return true;
 }
 if (isIntAttribute()) {
 if (AI.isEnumAttribute()) return false;
+if (AI.isTypeAttribute()) return false;
 if (AI.isIntAttribute()) {
 if (getKindAsEnum() == AI.getKindAsEnum())
 return getValueAsInt() < AI.getValueAsInt();
 return getKindAsEnum() < AI.getKindAsEnum();
 }
 if (AI.isStringAttribute()) return true;
 }
+assert(isStringAttribute());
 if (AI.isEnumAttribute()) return false;
+if (AI.isTypeAttribute()) return false;
 if (AI.isIntAttribute()) return false;
 if (getKindAsString() == AI.getKindAsString())
 return getValueAsString() < AI.getValueAsString();
 return getKindAsString() < AI.getKindAsString();
 }
 if (!AS.hasAttributes())
 return *this;
 AttrBuilder B(AS);
-for (Attribute I : *this)
+for (const auto I : *this)
 B.addAttribute(I);
 return get(C, B);
 }
 uint64_t AttributeSet::getDereferenceableOrNullBytes() const {
 return SetNode ? SetNode->getDereferenceableOrNullBytes() : 0;
 }
+Type *AttributeSet::getByValType() const {
+return SetNode ? SetNode->getByValType() : nullptr;
+}
 std::pair<unsigned, Optional<unsigned>> AttributeSet::getAllocSizeArgs() const {
 return SetNode ? SetNode->getAllocSizeArgs()
 : std::pair<unsigned, Optional<unsigned>>(0, 0);
 }
 //===----------------------------------------------------------------------===//
 // AttributeSetNode Definition
 //===----------------------------------------------------------------------===//
 AttributeSetNode::AttributeSetNode(ArrayRef<Attribute> Attrs)
-: AvailableAttrs(0), NumAttrs(Attrs.size()) {
+: NumAttrs(Attrs.size()) {
 // There's memory after the node where we can store the entries in.
-std::copy(Attrs.begin(), Attrs.end(), getTrailingObjects<Attribute>());
+llvm::copy(Attrs, getTrailingObjects<Attribute>());
-for (Attribute I : *this) {
+static_assert(Attribute::EndAttrKinds <=
+sizeof(AvailableAttrs) * CHAR_BIT,
+"Too many attributes");
+for (const auto I : *this) {
 if (!I.isStringAttribute()) {
-AvailableAttrs |= ((uint64_t)1) << I.getKindAsEnum();
+Attribute::AttrKind Kind = I.getKindAsEnum();
+AvailableAttrs[Kind / 8] |= 1ULL << (Kind % 8);
 }
 }
 }
 AttributeSetNode *AttributeSetNode::get(LLVMContext &C,
 // Otherwise, build a key to look up the existing attributes.
 LLVMContextImpl *pImpl = C.pImpl;
 FoldingSetNodeID ID;
 SmallVector<Attribute, 8> SortedAttrs(Attrs.begin(), Attrs.end());
-std::sort(SortedAttrs.begin(), SortedAttrs.end());
+llvm::sort(SortedAttrs);
-for (Attribute Attr : SortedAttrs)
+for (const auto Attr : SortedAttrs)
 Attr.Profile(ID);
 void *InsertPoint;
 AttributeSetNode *PA =
 pImpl->AttrsSetNodes.FindNodeOrInsertPos(ID, InsertPoint);
 if (!B.contains(Kind))
 continue;
 Attribute Attr;
 switch (Kind) {
+case Attribute::ByVal:
+Attr = Attribute::getWithByValType(C, B.getByValType());
+break;
 case Attribute::Alignment:
 Attr = Attribute::getWithAlignment(C, B.getAlignment());
 break;
 case Attribute::StackAlignment:
 Attr = Attribute::getWithStackAlignment(C, B.getStackAlignment());
 return get(C, Attrs);
 }
 bool AttributeSetNode::hasAttribute(StringRef Kind) const {
-for (Attribute I : *this)
+for (const auto I : *this)
 if (I.hasAttribute(Kind))
 return true;
 return false;
 }
 Attribute AttributeSetNode::getAttribute(Attribute::AttrKind Kind) const {
 if (hasAttribute(Kind)) {
-for (Attribute I : *this)
+for (const auto I : *this)
 if (I.hasAttribute(Kind))
 return I;
 }
-return Attribute();
+return {};
 }
 Attribute AttributeSetNode::getAttribute(StringRef Kind) const {
-for (Attribute I : *this)
+for (const auto I : *this)
 if (I.hasAttribute(Kind))
 return I;
-return Attribute();
+return {};
 }
 unsigned AttributeSetNode::getAlignment() const {
-for (Attribute I : *this)
+for (const auto I : *this)
 if (I.hasAttribute(Attribute::Alignment))
 return I.getAlignment();
 return 0;
 }
 unsigned AttributeSetNode::getStackAlignment() const {
-for (Attribute I : *this)
+for (const auto I : *this)
 if (I.hasAttribute(Attribute::StackAlignment))
 return I.getStackAlignment();
 return 0;
 }
+Type *AttributeSetNode::getByValType() const {
+for (const auto I : *this)
+if (I.hasAttribute(Attribute::ByVal))
+return I.getValueAsType();
+return 0;
+}
 uint64_t AttributeSetNode::getDereferenceableBytes() const {
-for (Attribute I : *this)
+for (const auto I : *this)
 if (I.hasAttribute(Attribute::Dereferenceable))
 return I.getDereferenceableBytes();
 return 0;
 }
 uint64_t AttributeSetNode::getDereferenceableOrNullBytes() const {
-for (Attribute I : *this)
+for (const auto I : *this)
 if (I.hasAttribute(Attribute::DereferenceableOrNull))
 return I.getDereferenceableOrNullBytes();
 return 0;
 }
 std::pair<unsigned, Optional<unsigned>>
 AttributeSetNode::getAllocSizeArgs() const {
-for (Attribute I : *this)
+for (const auto I : *this)
 if (I.hasAttribute(Attribute::AllocSize))
 return I.getAllocSizeArgs();
 return std::make_pair(0, 0);
 }
 return Index == AttributeList::FunctionIndex ? 0 : Index + 1;
 }
 AttributeListImpl::AttributeListImpl(LLVMContext &C,
 ArrayRef<AttributeSet> Sets)
-: AvailableFunctionAttrs(0), Context(C), NumAttrSets(Sets.size()) {
+: Context(C), NumAttrSets(Sets.size()) {
 assert(!Sets.empty() && "pointless AttributeListImpl");
 // There's memory after the node where we can store the entries in.
-std::copy(Sets.begin(), Sets.end(), getTrailingObjects<AttributeSet>());
+llvm::copy(Sets, getTrailingObjects<AttributeSet>());
 // Initialize AvailableFunctionAttrs summary bitset.
 static_assert(Attribute::EndAttrKinds <=
 sizeof(AvailableFunctionAttrs) * CHAR_BIT,
 "Too many attributes");
 static_assert(attrIdxToArrayIdx(AttributeList::FunctionIndex) == 0U,
 "function should be stored in slot 0");
-for (Attribute I : Sets[0]) {
+for (const auto I : Sets[0]) {
-if (!I.isStringAttribute())
+if (!I.isStringAttribute()) {
-AvailableFunctionAttrs |= 1ULL << I.getKindAsEnum();
+Attribute::AttrKind Kind = I.getKindAsEnum();
+AvailableFunctionAttrs[Kind / 8] |= 1ULL << (Kind % 8);
+}
 }
 }
 void AttributeListImpl::Profile(FoldingSetNodeID &ID) const {
 Profile(ID, makeArrayRef(begin(), end()));
 AttributeList
 AttributeList::get(LLVMContext &C,
 ArrayRef<std::pair<unsigned, Attribute>> Attrs) {
 // If there are no attributes then return a null AttributesList pointer.
 if (Attrs.empty())
-return AttributeList();
+return {};
 assert(std::is_sorted(Attrs.begin(), Attrs.end(),
 [](const std::pair<unsigned, Attribute> &LHS,
 const std::pair<unsigned, Attribute> &RHS) {
 return LHS.first < RHS.first;
 }) && "Misordered Attributes list!");
-assert(none_of(Attrs,
+assert(llvm::none_of(Attrs,
 [](const std::pair<unsigned, Attribute> &Pair) {
 return Pair.second.hasAttribute(Attribute::None);
 }) &&
 "Pointless attribute!");
 // Create a vector if (unsigned, AttributeSetNode*) pairs from the attributes
 // list.
 SmallVector<std::pair<unsigned, AttributeSet>, 8> AttrPairVec;
 AttributeList
 AttributeList::get(LLVMContext &C,
 ArrayRef<std::pair<unsigned, AttributeSet>> Attrs) {
 // If there are no attributes then return a null AttributesList pointer.
 if (Attrs.empty())
-return AttributeList();
+return {};
 assert(std::is_sorted(Attrs.begin(), Attrs.end(),
 [](const std::pair<unsigned, AttributeSet> &LHS,
 const std::pair<unsigned, AttributeSet> &RHS) {
 return LHS.first < RHS.first;
 }) &&
 "Misordered Attributes list!");
-assert(none_of(Attrs,
+assert(llvm::none_of(Attrs,
 [](const std::pair<unsigned, AttributeSet> &Pair) {
 return !Pair.second.hasAttributes();
 }) &&
 "Pointless attribute!");
 unsigned MaxIndex = Attrs.back().first;
+// If the MaxIndex is FunctionIndex and there are other indices in front
+// of it, we need to use the largest of those to get the right size.
+if (MaxIndex == FunctionIndex && Attrs.size() > 1)
+MaxIndex = Attrs[Attrs.size() - 2].first;
 SmallVector<AttributeSet, 4> AttrVec(attrIdxToArrayIdx(MaxIndex) + 1);
-for (auto Pair : Attrs)
+for (const auto Pair : Attrs)
 AttrVec[attrIdxToArrayIdx(Pair.first)] = Pair.second;
 return getImpl(C, AttrVec);
 }
 NumSets = 1;
 }
 // If all attribute sets were empty, we can use the empty attribute list.
 if (NumSets == 0)
-return AttributeList();
+return {};
 SmallVector<AttributeSet, 8> AttrSets;
 AttrSets.reserve(NumSets);
 // If we have any attributes, we always have function attributes.
 AttrSets.push_back(FnAttrs);
 }
 AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
 const AttrBuilder &B) {
 if (!B.hasAttributes())
-return AttributeList();
+return {};
 Index = attrIdxToArrayIdx(Index);
 SmallVector<AttributeSet, 8> AttrSets(Index + 1);
 AttrSets[Index] = AttributeSet::get(C, B);
 return getImpl(C, AttrSets);
 }
 AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
 ArrayRef<Attribute::AttrKind> Kinds) {
 SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
-for (Attribute::AttrKind K : Kinds)
+for (const auto K : Kinds)
 Attrs.emplace_back(Index, Attribute::get(C, K));
 return get(C, Attrs);
 }
 AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
 ArrayRef<StringRef> Kinds) {
 SmallVector<std::pair<unsigned, Attribute>, 8> Attrs;
-for (StringRef K : Kinds)
+for (const auto K : Kinds)
 Attrs.emplace_back(Index, Attribute::get(C, K));
 return get(C, Attrs);
 }
 AttributeList AttributeList::get(LLVMContext &C,
 ArrayRef<AttributeList> Attrs) {
 if (Attrs.empty())
-return AttributeList();
+return {};
 if (Attrs.size() == 1)
 return Attrs[0];
 unsigned MaxSize = 0;
-for (AttributeList List : Attrs)
+for (const auto List : Attrs)
 MaxSize = std::max(MaxSize, List.getNumAttrSets());
 // If every list was empty, there is no point in merging the lists.
 if (MaxSize == 0)
-return AttributeList();
+return {};
 SmallVector<AttributeSet, 8> NewAttrSets(MaxSize);
 for (unsigned I = 0; I < MaxSize; ++I) {
 AttrBuilder CurBuilder;
-for (AttributeList List : Attrs)
+for (const auto List : Attrs)
 CurBuilder.merge(List.getAttributes(I - 1));
 NewAttrSets[I] = AttributeSet::get(C, CurBuilder);
 }
 return getImpl(C, NewAttrSets);
 AttributeList
 AttributeList::removeAttributes(LLVMContext &C, unsigned Index,
 const AttrBuilder &AttrsToRemove) const {
 if (!pImpl)
-return AttributeList();
+return {};
 Index = attrIdxToArrayIdx(Index);
 SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
 if (Index >= AttrSets.size())
 AttrSets.resize(Index + 1);
 }
 AttributeList AttributeList::removeAttributes(LLVMContext &C,
 unsigned WithoutIndex) const {
 if (!pImpl)
-return AttributeList();
+return {};
 WithoutIndex = attrIdxToArrayIdx(WithoutIndex);
 if (WithoutIndex >= getNumAttrSets())
 return *this;
 SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
 AttrSets[WithoutIndex] = AttributeSet();
 unsigned AttributeList::getParamAlignment(unsigned ArgNo) const {
 return getAttributes(ArgNo + FirstArgIndex).getAlignment();
 }
+Type *AttributeList::getParamByValType(unsigned Index) const {
+return getAttributes(Index+FirstArgIndex).getByValType();
+}
 unsigned AttributeList::getStackAlignment(unsigned Index) const {
 return getAttributes(Index).getStackAlignment();
 }
 uint64_t AttributeList::getDereferenceableBytes(unsigned Index) const {
 }
 AttributeSet AttributeList::getAttributes(unsigned Index) const {
 Index = attrIdxToArrayIdx(Index);
 if (!pImpl || Index >= getNumAttrSets())
-return AttributeSet();
+return {};
 return pImpl->begin()[Index];
 }
 AttributeList::iterator AttributeList::begin() const {
 return pImpl ? pImpl->begin() : nullptr;
 //===----------------------------------------------------------------------===//
 // FIXME: Remove this ctor, use AttributeSet.
 AttrBuilder::AttrBuilder(AttributeList AL, unsigned Index) {
 AttributeSet AS = AL.getAttributes(Index);
-for (const Attribute &A : AS)
+for (const auto &A : AS)
 addAttribute(A);
 }
 AttrBuilder::AttrBuilder(AttributeSet AS) {
-for (const Attribute &A : AS)
+for (const auto &A : AS)
 addAttribute(A);
 }
 void AttrBuilder::clear() {
 Attrs.reset();
 TargetDepAttrs.clear();
-Alignment = StackAlignment = DerefBytes = DerefOrNullBytes = 0;
+Alignment.reset();
+StackAlignment.reset();
+DerefBytes = DerefOrNullBytes = 0;
 AllocSizeArgs = 0;
+ByValType = nullptr;
 }
 AttrBuilder &AttrBuilder::addAttribute(Attribute::AttrKind Val) {
 assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
 assert(Val != Attribute::Alignment && Val != Attribute::StackAlignment &&
 Attribute::AttrKind Kind = Attr.getKindAsEnum();
 Attrs[Kind] = true;
 if (Kind == Attribute::Alignment)
-Alignment = Attr.getAlignment();
+Alignment = MaybeAlign(Attr.getAlignment());
 else if (Kind == Attribute::StackAlignment)
-StackAlignment = Attr.getStackAlignment();
+StackAlignment = MaybeAlign(Attr.getStackAlignment());
+else if (Kind == Attribute::ByVal)
+ByValType = Attr.getValueAsType();
 else if (Kind == Attribute::Dereferenceable)
 DerefBytes = Attr.getDereferenceableBytes();
 else if (Kind == Attribute::DereferenceableOrNull)
 DerefOrNullBytes = Attr.getDereferenceableOrNullBytes();
 else if (Kind == Attribute::AllocSize)
 AttrBuilder &AttrBuilder::removeAttribute(Attribute::AttrKind Val) {
 assert((unsigned)Val < Attribute::EndAttrKinds && "Attribute out of range!");
 Attrs[Val] = false;
 if (Val == Attribute::Alignment)
-Alignment = 0;
+Alignment.reset();
 else if (Val == Attribute::StackAlignment)
-StackAlignment = 0;
+StackAlignment.reset();
+else if (Val == Attribute::ByVal)
+ByValType = nullptr;
 else if (Val == Attribute::Dereferenceable)
 DerefBytes = 0;
 else if (Val == Attribute::DereferenceableOrNull)
 DerefOrNullBytes = 0;
 else if (Val == Attribute::AllocSize)
 remove(A.getAttributes(Index));
 return *this;
 }
 AttrBuilder &AttrBuilder::removeAttribute(StringRef A) {
-std::map<std::string, std::string>::iterator I = TargetDepAttrs.find(A);
+auto I = TargetDepAttrs.find(A);
 if (I != TargetDepAttrs.end())
 TargetDepAttrs.erase(I);
 return *this;
 }
 std::pair<unsigned, Optional<unsigned>> AttrBuilder::getAllocSizeArgs() const {
 return unpackAllocSizeArgs(AllocSizeArgs);
 }
-AttrBuilder &AttrBuilder::addAlignmentAttr(unsigned Align) {
+AttrBuilder &AttrBuilder::addAlignmentAttr(unsigned A) {
-if (Align == 0) return *this;
+MaybeAlign Align(A);
+if (!Align)
-assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
+return *this;
-assert(Align <= 0x40000000 && "Alignment too large.");
+assert(*Align <= 0x40000000 && "Alignment too large.");
 Attrs[Attribute::Alignment] = true;
 Alignment = Align;
 return *this;
 }
-AttrBuilder &AttrBuilder::addStackAlignmentAttr(unsigned Align) {
+AttrBuilder &AttrBuilder::addStackAlignmentAttr(unsigned A) {
+MaybeAlign Align(A);
 // Default alignment, allow the target to define how to align it.
-if (Align == 0) return *this;
+if (!Align)
+return *this;
-assert(isPowerOf2_32(Align) && "Alignment must be a power of two.");
-assert(Align <= 0x100 && "Alignment too large.");
+assert(*Align <= 0x100 && "Alignment too large.");
 Attrs[Attribute::StackAlignment] = true;
 StackAlignment = Align;
 return *this;
 }
 // save a few bytes over using a pair<unsigned, Optional<unsigned>>.
 AllocSizeArgs = RawArgs;
 return *this;
 }
+AttrBuilder &AttrBuilder::addByValAttr(Type *Ty) {
+Attrs[Attribute::ByVal] = true;
+ByValType = Ty;
+return *this;
+}
 AttrBuilder &AttrBuilder::merge(const AttrBuilder &B) {
 // FIXME: What if both have alignments, but they don't match?!
 if (!Alignment)
 Alignment = B.Alignment;
 DerefOrNullBytes = B.DerefOrNullBytes;
 if (!AllocSizeArgs)
 AllocSizeArgs = B.AllocSizeArgs;
+if (!ByValType)
+ByValType = B.ByValType;
 Attrs |= B.Attrs;
 for (auto I : B.td_attrs())
 TargetDepAttrs[I.first] = I.second;
 }
 AttrBuilder &AttrBuilder::remove(const AttrBuilder &B) {
 // FIXME: What if both have alignments, but they don't match?!
 if (B.Alignment)
-Alignment = 0;
+Alignment.reset();
 if (B.StackAlignment)
-StackAlignment = 0;
+StackAlignment.reset();
 if (B.DerefBytes)
 DerefBytes = 0;
 if (B.DerefOrNullBytes)
 DerefOrNullBytes = 0;
 if (B.AllocSizeArgs)
 AllocSizeArgs = 0;
+if (B.ByValType)
+ByValType = nullptr;
 Attrs &= ~B.Attrs;
 for (auto I : B.td_attrs())
 TargetDepAttrs.erase(I.first);
 }
 bool AttrBuilder::hasAttributes(AttributeList AL, uint64_t Index) const {
 AttributeSet AS = AL.getAttributes(Index);
-for (Attribute Attr : AS) {
+for (const auto Attr : AS) {
 if (Attr.isEnumAttribute() || Attr.isIntAttribute()) {
 if (contains(Attr.getKindAsEnum()))
 return true;
 } else {
 assert(Attr.isStringAttribute() && "Invalid attribute kind!");
 E = TargetDepAttrs.end(); I != E; ++I)
 if (B.TargetDepAttrs.find(I->first) == B.TargetDepAttrs.end())
 return false;
 return Alignment == B.Alignment && StackAlignment == B.StackAlignment &&
-DerefBytes == B.DerefBytes;
+DerefBytes == B.DerefBytes && ByValType == B.ByValType;
 }
 //===----------------------------------------------------------------------===//
 // AttributeFuncs Function Defintions
 //===----------------------------------------------------------------------===//
-/// \brief Which attributes cannot be applied to a type.
+/// Which attributes cannot be applied to a type.
 AttrBuilder AttributeFuncs::typeIncompatible(Type *Ty) {
 AttrBuilder Incompatible;
 if (!Ty->isIntegerTy())
 // Attribute that only apply to integers.
 static bool isEqual(const Function &Caller, const Function &Callee) {
 return Caller.getFnAttribute(AttrClass::getKind()) ==
 Callee.getFnAttribute(AttrClass::getKind());
 }
-/// \brief Compute the logical AND of the attributes of the caller and the
+/// Compute the logical AND of the attributes of the caller and the
 /// callee.
 ///
 /// This function sets the caller's attribute to false if the callee's attribute
 /// is false.
 template<typename AttrClass>
 if (AttrClass::isSet(Caller, AttrClass::getKind()) &&
 !AttrClass::isSet(Callee, AttrClass::getKind()))
 AttrClass::set(Caller, AttrClass::getKind(), false);
 }
-/// \brief Compute the logical OR of the attributes of the caller and the
+/// Compute the logical OR of the attributes of the caller and the
 /// callee.
 ///
 /// This function sets the caller's attribute to true if the callee's attribute
 /// is true.
 template<typename AttrClass>
 if (!AttrClass::isSet(Caller, AttrClass::getKind()) &&
 AttrClass::isSet(Callee, AttrClass::getKind()))
 AttrClass::set(Caller, AttrClass::getKind(), true);
 }
-/// \brief If the inlined function had a higher stack protection level than the
+/// If the inlined function had a higher stack protection level than the
 /// calling function, then bump up the caller's stack protection level.
 static void adjustCallerSSPLevel(Function &Caller, const Function &Callee) {
 // If upgrading the SSP attribute, clear out the old SSP Attributes first.
 // Having multiple SSP attributes doesn't actually hurt, but it adds useless
 // clutter to the IR.
 !Caller.hasFnAttribute(Attribute::StackProtectReq) &&
 !Caller.hasFnAttribute(Attribute::StackProtectStrong))
 Caller.addFnAttr(Attribute::StackProtect);
 }
-/// \brief If the inlined function required stack probes, then ensure that
+/// If the inlined function required stack probes, then ensure that
 /// the calling function has those too.
 static void adjustCallerStackProbes(Function &Caller, const Function &Callee) {
 if (!Caller.hasFnAttribute("probe-stack") &&
 Callee.hasFnAttribute("probe-stack")) {
 Caller.addFnAttr(Callee.getFnAttribute("probe-stack"));
 }
 }
-/// \brief If the inlined function defines the size of guard region
+/// If the inlined function defines the size of guard region
 /// on the stack, then ensure that the calling function defines a guard region
 /// that is no larger.
 static void
 adjustCallerStackProbeSize(Function &Caller, const Function &Callee) {
 if (Callee.hasFnAttribute("stack-probe-size")) {
 Caller.addFnAttr(Callee.getFnAttribute("stack-probe-size"));
 }
 }
 }
+/// If the inlined function defines a min legal vector width, then ensure
+/// the calling function has the same or larger min legal vector width. If the
+/// caller has the attribute, but the callee doesn't, we need to remove the
+/// attribute from the caller since we can't make any guarantees about the
+/// caller's requirements.
+/// This function is called after the inlining decision has been made so we have
+/// to merge the attribute this way. Heuristics that would use
+/// min-legal-vector-width to determine inline compatibility would need to be
+/// handled as part of inline cost analysis.
+static void
+adjustMinLegalVectorWidth(Function &Caller, const Function &Callee) {
+if (Caller.hasFnAttribute("min-legal-vector-width")) {
+if (Callee.hasFnAttribute("min-legal-vector-width")) {
+uint64_t CallerVectorWidth;
+Caller.getFnAttribute("min-legal-vector-width")
+.getValueAsString()
+.getAsInteger(0, CallerVectorWidth);
+uint64_t CalleeVectorWidth;
+Callee.getFnAttribute("min-legal-vector-width")
+.getValueAsString()
+.getAsInteger(0, CalleeVectorWidth);
+if (CallerVectorWidth < CalleeVectorWidth)
+Caller.addFnAttr(Callee.getFnAttribute("min-legal-vector-width"));
+} else {
+// If the callee doesn't have the attribute then we don't know anything
+// and must drop the attribute from the caller.
+Caller.removeFnAttr("min-legal-vector-width");
+}
+}
+}
+/// If the inlined function has "null-pointer-is-valid=true" attribute,
+/// set this attribute in the caller post inlining.
+static void
+adjustNullPointerValidAttr(Function &Caller, const Function &Callee) {
+if (Callee.nullPointerIsDefined() && !Caller.nullPointerIsDefined()) {
+Caller.addFnAttr(Callee.getFnAttribute("null-pointer-is-valid"));
+}
+}
 #define GET_ATTR_COMPAT_FUNC
 #include "AttributesCompatFunc.inc"
 bool AttributeFuncs::areInlineCompatible(const Function &Caller,
 const Function &Callee) {

Mercurial > hg > CbC > CbC_llvm

comparison lib/IR/Attributes.cpp @ 148:63bd29f05246