llvm/NoneSemaAttr.cpp

//===--- SemaAttr.cpp - Semantic Analysis for Attributes ------------------===//
//
// 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 implements semantic analysis for non-trivial attributes and
// pragmas.
//
//===----------------------------------------------------------------------===//

#include "clang/AST/ASTConsumer.h"
#include "clang/AST/Attr.h"
#include "clang/AST/Expr.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/Lex/Preprocessor.h"
#include "clang/Sema/Lookup.h"
#include "clang/Sema/SemaInternal.h"
#include <optional>
usingnamespaceclang;

//===----------------------------------------------------------------------===//
// Pragma 'pack' and 'options align'
//===----------------------------------------------------------------------===//

Sema::PragmaStackSentinelRAII::PragmaStackSentinelRAII(Sema &S,
                                                       StringRef SlotLabel,
                                                       bool ShouldAct)
    : … { … }

Sema::PragmaStackSentinelRAII::~PragmaStackSentinelRAII() { … }

void Sema::AddAlignmentAttributesForRecord(RecordDecl *RD) { … }

void Sema::AddMsStructLayoutForRecord(RecordDecl *RD) { … }

template <typename Attribute>
static void addGslOwnerPointerAttributeIfNotExisting(ASTContext &Context,
                                                     CXXRecordDecl *Record) { … }

void Sema::inferGslPointerAttribute(NamedDecl *ND,
                                    CXXRecordDecl *UnderlyingRecord) { … }

void Sema::inferGslPointerAttribute(TypedefNameDecl *TD) { … }

void Sema::inferGslOwnerPointerAttribute(CXXRecordDecl *Record) { … }

void Sema::inferLifetimeBoundAttribute(FunctionDecl *FD) { … }

void Sema::inferNullableClassAttribute(CXXRecordDecl *CRD) { … }

void Sema::ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,
                                   SourceLocation PragmaLoc) { … }

void Sema::ActOnPragmaClangSection(SourceLocation PragmaLoc,
                                   PragmaClangSectionAction Action,
                                   PragmaClangSectionKind SecKind,
                                   StringRef SecName) { … }

void Sema::ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action,
                           StringRef SlotLabel, Expr *alignment) { … }

bool Sema::ConstantFoldAttrArgs(const AttributeCommonInfo &CI,
                                MutableArrayRef<Expr *> Args) { … }

void Sema::DiagnoseNonDefaultPragmaAlignPack(PragmaAlignPackDiagnoseKind Kind,
                                             SourceLocation IncludeLoc) { … }

void Sema::DiagnoseUnterminatedPragmaAlignPack() { … }

void Sema::ActOnPragmaMSStruct(PragmaMSStructKind Kind) { … }

void Sema::ActOnPragmaMSComment(SourceLocation CommentLoc,
                                PragmaMSCommentKind Kind, StringRef Arg) { … }

void Sema::ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name,
                                     StringRef Value) { … }

void Sema::ActOnPragmaFPEvalMethod(SourceLocation Loc,
                                   LangOptions::FPEvalMethodKind Value) { … }

void Sema::ActOnPragmaFloatControl(SourceLocation Loc,
                                   PragmaMsStackAction Action,
                                   PragmaFloatControlKind Value) { … }

void Sema::ActOnPragmaMSPointersToMembers(
    LangOptions::PragmaMSPointersToMembersKind RepresentationMethod,
    SourceLocation PragmaLoc) { … }

void Sema::ActOnPragmaMSVtorDisp(PragmaMsStackAction Action,
                                 SourceLocation PragmaLoc,
                                 MSVtorDispMode Mode) { … }

template <>
void Sema::PragmaStack<Sema::AlignPackInfo>::Act(SourceLocation PragmaLocation,
                                                 PragmaMsStackAction Action,
                                                 llvm::StringRef StackSlotLabel,
                                                 AlignPackInfo Value) { … }

bool Sema::UnifySection(StringRef SectionName, int SectionFlags,
                        NamedDecl *Decl) { … }

bool Sema::UnifySection(StringRef SectionName,
                        int SectionFlags,
                        SourceLocation PragmaSectionLocation) { … }

/// Called on well formed \#pragma bss_seg().
void Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation,
                            PragmaMsStackAction Action,
                            llvm::StringRef StackSlotLabel,
                            StringLiteral *SegmentName,
                            llvm::StringRef PragmaName) { … }

/// Called on well formed \#pragma strict_gs_check().
void Sema::ActOnPragmaMSStrictGuardStackCheck(SourceLocation PragmaLocation,
                                              PragmaMsStackAction Action,
                                              bool Value) { … }

/// Called on well formed \#pragma bss_seg().
void Sema::ActOnPragmaMSSection(SourceLocation PragmaLocation,
                                int SectionFlags, StringLiteral *SegmentName) { … }

void Sema::ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,
                                StringLiteral *SegmentName) { … }

void Sema::ActOnPragmaMSAllocText(
    SourceLocation PragmaLocation, StringRef Section,
    const SmallVector<std::tuple<IdentifierInfo *, SourceLocation>>
        &Functions) { … }

void Sema::ActOnPragmaUnused(const Token &IdTok, Scope *curScope,
                             SourceLocation PragmaLoc) { … }

namespace {

std::optional<attr::SubjectMatchRule>
getParentAttrMatcherRule(attr::SubjectMatchRule Rule) { … }

bool isNegatedAttrMatcherSubRule(attr::SubjectMatchRule Rule) { … }

CharSourceRange replacementRangeForListElement(const Sema &S,
                                               SourceRange Range) { … }

std::string
attrMatcherRuleListToString(ArrayRef<attr::SubjectMatchRule> Rules) { … }

} // end anonymous namespace

void Sema::ActOnPragmaAttributeAttribute(
    ParsedAttr &Attribute, SourceLocation PragmaLoc,
    attr::ParsedSubjectMatchRuleSet Rules) { … }

void Sema::ActOnPragmaAttributeEmptyPush(SourceLocation PragmaLoc,
                                         const IdentifierInfo *Namespace) { … }

void Sema::ActOnPragmaAttributePop(SourceLocation PragmaLoc,
                                   const IdentifierInfo *Namespace) { … }

void Sema::AddPragmaAttributes(Scope *S, Decl *D) { … }

void Sema::PrintPragmaAttributeInstantiationPoint() { … }

void Sema::DiagnoseUnterminatedPragmaAttribute() { … }

void Sema::ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc) { … }

void Sema::ActOnPragmaMSOptimize(SourceLocation Loc, bool IsOn) { … }

void Sema::ActOnPragmaMSFunction(
    SourceLocation Loc, const llvm::SmallVectorImpl<StringRef> &NoBuiltins) { … }

void Sema::AddRangeBasedOptnone(FunctionDecl *FD) { … }

void Sema::AddSectionMSAllocText(FunctionDecl *FD) { … }

void Sema::ModifyFnAttributesMSPragmaOptimize(FunctionDecl *FD) { … }

void Sema::AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD,
                                            SourceLocation Loc) { … }

void Sema::AddImplicitMSFunctionNoBuiltinAttr(FunctionDecl *FD) { … }

VisStack;
enum : unsigned { … };

void Sema::AddPushedVisibilityAttribute(Decl *D) { … }

void Sema::FreeVisContext() { … }

static void PushPragmaVisibility(Sema &S, unsigned type, SourceLocation loc) { … }

void Sema::ActOnPragmaVisibility(const IdentifierInfo* VisType,
                                 SourceLocation PragmaLoc) { … }

void Sema::ActOnPragmaFPContract(SourceLocation Loc,
                                 LangOptions::FPModeKind FPC) { … }

void Sema::ActOnPragmaFPValueChangingOption(SourceLocation Loc,
                                            PragmaFPKind Kind, bool IsEnabled) { … }

void Sema::ActOnPragmaFEnvRound(SourceLocation Loc, llvm::RoundingMode FPR) { … }

void Sema::setExceptionMode(SourceLocation Loc,
                            LangOptions::FPExceptionModeKind FPE) { … }

void Sema::ActOnPragmaFEnvAccess(SourceLocation Loc, bool IsEnabled) { … }

void Sema::ActOnPragmaCXLimitedRange(SourceLocation Loc,
                                     LangOptions::ComplexRangeKind Range) { … }

void Sema::ActOnPragmaFPExceptions(SourceLocation Loc,
                                   LangOptions::FPExceptionModeKind FPE) { … }

void Sema::PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,
                                       SourceLocation Loc) { … }

void Sema::PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc) { … }

template <typename Ty>
static bool checkCommonAttributeFeatures(Sema &S, const Ty *Node,
                                         const ParsedAttr &A,
                                         bool SkipArgCountCheck) { … }

bool Sema::checkCommonAttributeFeatures(const Decl *D, const ParsedAttr &A,
                                        bool SkipArgCountCheck) { … }
bool Sema::checkCommonAttributeFeatures(const Stmt *S, const ParsedAttr &A,
                                        bool SkipArgCountCheck) { … }