ParsedAttr.cpp | Explore in Territory

//======- 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>

usingnamespaceclang;

IdentifierLoc *IdentifierLoc::create(ASTContext &Ctx, SourceLocation Loc,
                                     IdentifierInfo *Ident) { … }

size_t ParsedAttr::allocated_size() const { … }

AttributeFactory::AttributeFactory() { … }
AttributeFactory::~AttributeFactory() = default;

static size_t getFreeListIndexForSize(size_t size) { … }

void *AttributeFactory::allocate(size_t size) { … }

void AttributeFactory::deallocate(ParsedAttr *Attr) { … }

void AttributeFactory::reclaimPool(AttributePool &cur) { … }

void AttributePool::takePool(AttributePool &pool) { … }

void AttributePool::takeFrom(ParsedAttributesView &List, AttributePool &Pool) { … }

namespace {

#include "clang/Sema/AttrParsedAttrImpl.inc"

} // namespace

const ParsedAttrInfo &ParsedAttrInfo::get(const AttributeCommonInfo &A) { … }

ArrayRef<const ParsedAttrInfo *> ParsedAttrInfo::getAllBuiltin() { … }

unsigned ParsedAttr::getMinArgs() const { … }

unsigned ParsedAttr::getMaxArgs() const { … }

unsigned ParsedAttr::getNumArgMembers() const { … }

bool ParsedAttr::hasCustomParsing() const { … }

bool ParsedAttr::diagnoseAppertainsTo(Sema &S, const Decl *D) const { … }

bool ParsedAttr::diagnoseAppertainsTo(Sema &S, const Stmt *St) const { … }

bool ParsedAttr::diagnoseMutualExclusion(Sema &S, const Decl *D) const { … }

bool ParsedAttr::appliesToDecl(const Decl *D,
                               attr::SubjectMatchRule MatchRule) const { … }

void ParsedAttr::getMatchRules(
    const LangOptions &LangOpts,
    SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules)
    const { … }

bool ParsedAttr::diagnoseLangOpts(Sema &S) const { … }

bool ParsedAttr::isTargetSpecificAttr() const { … }

bool ParsedAttr::isTypeAttr() const { … }

bool ParsedAttr::isStmtAttr() const { … }

bool ParsedAttr::existsInTarget(const TargetInfo &Target) const { … }

bool ParsedAttr::isKnownToGCC() const { … }

bool ParsedAttr::isSupportedByPragmaAttribute() const { … }

bool ParsedAttr::slidesFromDeclToDeclSpecLegacyBehavior() const { … }

bool ParsedAttr::acceptsExprPack() const { … }

unsigned ParsedAttr::getSemanticSpelling() const { … }

bool ParsedAttr::hasVariadicArg() const { … }

bool ParsedAttr::isParamExpr(size_t N) const { … }

void ParsedAttr::handleAttrWithDelayedArgs(Sema &S, Decl *D) const { … }

static unsigned getNumAttributeArgs(const ParsedAttr &AL) { … }

template <typename Compare>
static bool checkAttributeNumArgsImpl(Sema &S, const ParsedAttr &AL,
                                      unsigned Num, unsigned Diag,
                                      Compare Comp) { … }

bool ParsedAttr::checkExactlyNumArgs(Sema &S, unsigned Num) const { … }
bool ParsedAttr::checkAtLeastNumArgs(Sema &S, unsigned Num) const { … }
bool ParsedAttr::checkAtMostNumArgs(Sema &S, unsigned Num) const { … }

void clang::takeAndConcatenateAttrs(ParsedAttributes &First,
                                    ParsedAttributes &Second,
                                    ParsedAttributes &Result) { … }
llvm/clang/lib/Sema/ParsedAttr.cpp
