ParsedAttr.cpp

Go to the documentation of this file.

//======- ParsedAttr.cpp --------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines the ParsedAttr class implementation
//
//===----------------------------------------------------------------------===//
 
#include "clang/Sema/ParsedAttr.h"
#include "clang/AST/ASTContext.h"
#include "clang/Basic/AttrSubjectMatchRules.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/Sema/SemaInternal.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include <cassert>
#include <cstddef>
#include <utility>
 
using namespace clang;
 
IdentifierLoc *IdentifierLoc::create(ASTContext &Ctx, SourceLocation Loc,
                                     IdentifierInfo *Ident) {
  IdentifierLoc *Result = new (Ctx) IdentifierLoc;
  Result->Loc = Loc;
  Result->Ident = Ident;
  return Result;
}
 
size_t ParsedAttr::allocated_size() const {
  if (IsAvailability) return AttributeFactory::AvailabilityAllocSize;
  else if (IsTypeTagForDatatype)
    return AttributeFactory::TypeTagForDatatypeAllocSize;
  else if (IsProperty)
    return AttributeFactory::PropertyAllocSize;
  else if (HasParsedType)
    return totalSizeToAlloc<ArgsUnion, detail::AvailabilityData,
                            detail::TypeTagForDatatypeData, ParsedType,
                            detail::PropertyData>(0, 0, 0, 1, 0);
  return totalSizeToAlloc<ArgsUnion, detail::AvailabilityData,
                          detail::TypeTagForDatatypeData, ParsedType,
                          detail::PropertyData>(NumArgs, 0, 0, 0, 0);
}
 
AttributeFactory::AttributeFactory() {
  // Go ahead and configure all the inline capacity.  This is just a memset.
  FreeLists.resize(InlineFreeListsCapacity);
}
AttributeFactory::~AttributeFactory() = default;
 
static size_t getFreeListIndexForSize(size_t size) {
  assert(size >= sizeof(ParsedAttr));
  assert((size % sizeof(void*)) == 0);
  return ((size - sizeof(ParsedAttr)) / sizeof(void *));
}
 
void *AttributeFactory::allocate(size_t size) {
  // Check for a previously reclaimed attribute.
  size_t index = getFreeListIndexForSize(size);
  if (index < FreeLists.size() && !FreeLists[index].empty()) {
    ParsedAttr *attr = FreeLists[index].back();
    FreeLists[index].pop_back();
    return attr;
  }
 
  // Otherwise, allocate something new.
  return Alloc.Allocate(size, alignof(AttributeFactory));
}
 
void AttributeFactory::deallocate(ParsedAttr *Attr) {
  size_t size = Attr->allocated_size();
  size_t freeListIndex = getFreeListIndexForSize(size);
 
  // Expand FreeLists to the appropriate size, if required.
  if (freeListIndex >= FreeLists.size())
    FreeLists.resize(freeListIndex + 1);
 
#ifndef NDEBUG
  // In debug mode, zero out the attribute to help find memory overwriting.
  memset(Attr, 0, size);
#endif
 
  // Add 'Attr' to the appropriate free-list.
  FreeLists[freeListIndex].push_back(Attr);
}
 
void AttributeFactory::reclaimPool(AttributePool &cur) {
  for (ParsedAttr *AL : cur.Attrs)
    deallocate(AL);
}
 
void AttributePool::takePool(AttributePool &pool) {
  Attrs.insert(Attrs.end(), pool.Attrs.begin(), pool.Attrs.end());
  pool.Attrs.clear();
}
 
void AttributePool::takeFrom(ParsedAttributesView &List, AttributePool &Pool) {
  assert(&Pool != this && "AttributePool can't take attributes from itself");
  llvm::for_each(List.AttrList, [&Pool](ParsedAttr *A) { Pool.remove(A); });
  Attrs.insert(Attrs.end(), List.AttrList.begin(), List.AttrList.end());
}
 
namespace {
 
#include "clang/Sema/AttrParsedAttrImpl.inc"
 
} // namespace
 
const ParsedAttrInfo &ParsedAttrInfo::get(const AttributeCommonInfo &A) {
  // If we have a ParsedAttrInfo for this ParsedAttr then return that.
  if ((size_t)A.getParsedKind() < std::size(AttrInfoMap))
    return *AttrInfoMap[A.getParsedKind()];
 
  // If this is an ignored attribute then return an appropriate ParsedAttrInfo.
  static const ParsedAttrInfo IgnoredParsedAttrInfo(
      AttributeCommonInfo::IgnoredAttribute);
  if (A.getParsedKind() == AttributeCommonInfo::IgnoredAttribute)
    return IgnoredParsedAttrInfo;
 
  // Otherwise this may be an attribute defined by a plugin.
 
  // Search for a ParsedAttrInfo whose name and syntax match.
  std::string FullName = A.getNormalizedFullName();
  AttributeCommonInfo::Syntax SyntaxUsed = A.getSyntax();
  if (SyntaxUsed == AttributeCommonInfo::AS_ContextSensitiveKeyword)
    SyntaxUsed = AttributeCommonInfo::AS_Keyword;
 
  for (auto &Ptr : getAttributePluginInstances())
    if (Ptr->hasSpelling(SyntaxUsed, FullName))
      return *Ptr;
 
  // If we failed to find a match then return a default ParsedAttrInfo.
  static const ParsedAttrInfo DefaultParsedAttrInfo(
      AttributeCommonInfo::UnknownAttribute);
  return DefaultParsedAttrInfo;
}
 
ArrayRef<const ParsedAttrInfo *> ParsedAttrInfo::getAllBuiltin() {
  return llvm::ArrayRef(AttrInfoMap);
}
 
unsigned ParsedAttr::getMinArgs() const { return getInfo().NumArgs; }
 
unsigned ParsedAttr::getMaxArgs() const {
  return getMinArgs() + getInfo().OptArgs;
}
 
unsigned ParsedAttr::getNumArgMembers() const {
  return getInfo().NumArgMembers;
}
 
bool ParsedAttr::hasCustomParsing() const {
  return getInfo().HasCustomParsing;
}
 
bool ParsedAttr::diagnoseAppertainsTo(Sema &S, const Decl *D) const {
  return getInfo().diagAppertainsToDecl(S, *this, D);
}
 
bool ParsedAttr::diagnoseAppertainsTo(Sema &S, const Stmt *St) const {
  return getInfo().diagAppertainsToStmt(S, *this, St);
}
 
bool ParsedAttr::diagnoseMutualExclusion(Sema &S, const Decl *D) const {
  return getInfo().diagMutualExclusion(S, *this, D);
}
 
bool ParsedAttr::appliesToDecl(const Decl *D,
                               attr::SubjectMatchRule MatchRule) const {
  return checkAttributeMatchRuleAppliesTo(D, MatchRule);
}
 
void ParsedAttr::getMatchRules(
    const LangOptions &LangOpts,
    SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules)
    const {
  return getInfo().getPragmaAttributeMatchRules(MatchRules, LangOpts);
}
 
bool ParsedAttr::diagnoseLangOpts(Sema &S) const {
  if (getInfo().acceptsLangOpts(S.getLangOpts()))
    return true;
  S.Diag(getLoc(), diag::warn_attribute_ignored) << *this;
  return false;
}
 
bool ParsedAttr::isTargetSpecificAttr() const {
  return getInfo().IsTargetSpecific;
}
 
bool ParsedAttr::isTypeAttr() const { return getInfo().IsType; }
 
bool ParsedAttr::isStmtAttr() const { return getInfo().IsStmt; }
 
bool ParsedAttr::existsInTarget(const TargetInfo &Target) const {
  Kind K = getParsedKind();
 
  // If the attribute has a target-specific spelling, check that it exists.
  // Only call this if the attr is not ignored/unknown. For most targets, this
  // function just returns true.
  bool HasSpelling = K != IgnoredAttribute && K != UnknownAttribute &&
                     K != NoSemaHandlerAttribute;
  bool TargetSpecificSpellingExists =
      !HasSpelling ||
      getInfo().spellingExistsInTarget(Target, getAttributeSpellingListIndex());
 
  return getInfo().existsInTarget(Target) && TargetSpecificSpellingExists;
}
 
bool ParsedAttr::isKnownToGCC() const { return getInfo().IsKnownToGCC; }
 
bool ParsedAttr::isSupportedByPragmaAttribute() const {
  return getInfo().IsSupportedByPragmaAttribute;
}
 
bool ParsedAttr::supportsNonconformingLambdaSyntax() const {
  return getInfo().SupportsNonconformingLambdaSyntax && isCXX11Attribute();
}
 
bool ParsedAttr::slidesFromDeclToDeclSpecLegacyBehavior() const {
  if (isRegularKeywordAttribute())
    // The appurtenance rules are applied strictly for all regular keyword
    // atributes.
    return false;
 
  assert(isStandardAttributeSyntax());
 
  // We have historically allowed some type attributes with standard attribute
  // syntax to slide to the decl-specifier-seq, so we have to keep supporting
  // it. This property is consciously not defined as a flag in Attr.td because
  // we don't want new attributes to specify it.
  //
  // Note: No new entries should be added to this list. Entries should be
  // removed from this list after a suitable deprecation period, provided that
  // there are no compatibility considerations with other compilers. If
  // possible, we would like this list to go away entirely.
  switch (getParsedKind()) {
  case AT_AddressSpace:
  case AT_OpenCLPrivateAddressSpace:
  case AT_OpenCLGlobalAddressSpace:
  case AT_OpenCLGlobalDeviceAddressSpace:
  case AT_OpenCLGlobalHostAddressSpace:
  case AT_OpenCLLocalAddressSpace:
  case AT_OpenCLConstantAddressSpace:
  case AT_OpenCLGenericAddressSpace:
  case AT_NeonPolyVectorType:
  case AT_NeonVectorType:
  case AT_ArmMveStrictPolymorphism:
  case AT_BTFTypeTag:
  case AT_ObjCGC:
  case AT_MatrixType:
    return true;
  default:
    return false;
  }
}
 
bool ParsedAttr::acceptsExprPack() const { return getInfo().AcceptsExprPack; }
 
unsigned ParsedAttr::getSemanticSpelling() const {
  return getInfo().spellingIndexToSemanticSpelling(*this);
}
 
bool ParsedAttr::hasVariadicArg() const {
  // If the attribute has the maximum number of optional arguments, we will
  // claim that as being variadic. If we someday get an attribute that
  // legitimately bumps up against that maximum, we can use another bit to track
  // whether it's truly variadic or not.
  return getInfo().OptArgs == 15;
}
 
bool ParsedAttr::isParamExpr(size_t N) const {
  return getInfo().isParamExpr(N);
}
 
void ParsedAttr::handleAttrWithDelayedArgs(Sema &S, Decl *D) const {
  ::handleAttrWithDelayedArgs(S, D, *this);
}
 
static unsigned getNumAttributeArgs(const ParsedAttr &AL) {
  // FIXME: Include the type in the argument list.
  return AL.getNumArgs() + AL.hasParsedType();
}
 
template <typename Compare>
static bool checkAttributeNumArgsImpl(Sema &S, const ParsedAttr &AL,
                                      unsigned Num, unsigned Diag,
                                      Compare Comp) {
  if (Comp(getNumAttributeArgs(AL), Num)) {
    S.Diag(AL.getLoc(), Diag) << AL << Num;
    return false;
  }
  return true;
}
 
bool ParsedAttr::checkExactlyNumArgs(Sema &S, unsigned Num) const {
  return checkAttributeNumArgsImpl(S, *this, Num,
                                   diag::err_attribute_wrong_number_arguments,
                                   std::not_equal_to<unsigned>());
}
bool ParsedAttr::checkAtLeastNumArgs(Sema &S, unsigned Num) const {
  return checkAttributeNumArgsImpl(S, *this, Num,
                                   diag::err_attribute_too_few_arguments,
                                   std::less<unsigned>());
}
bool ParsedAttr::checkAtMostNumArgs(Sema &S, unsigned Num) const {
  return checkAttributeNumArgsImpl(S, *this, Num,
                                   diag::err_attribute_too_many_arguments,
                                   std::greater<unsigned>());
}
 
void clang::takeAndConcatenateAttrs(ParsedAttributes &First,
                                    ParsedAttributes &Second,
                                    ParsedAttributes &Result) {
  // Note that takeAllFrom() puts the attributes at the beginning of the list,
  // so to obtain the correct ordering, we add `Second`, then `First`.
  Result.takeAllFrom(Second);
  Result.takeAllFrom(First);
  if (First.Range.getBegin().isValid())
    Result.Range.setBegin(First.Range.getBegin());
  else
    Result.Range.setBegin(Second.Range.getBegin());
  if (Second.Range.getEnd().isValid())
    Result.Range.setEnd(Second.Range.getEnd());
  else
    Result.Range.setEnd(First.Range.getEnd());
}