Bindings = None);\n NamedDecl *\n ActOnDecompositionDeclarator(Scope *S, Declarator &D,\n MultiTemplateParamsArg TemplateParamLists);\n // Returns true if the variable declaration is a redeclaration\n bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous);\n void CheckVariableDeclarationType(VarDecl *NewVD);\n bool DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit,\n Expr *Init);\n void CheckCompleteVariableDeclaration(VarDecl *VD);\n void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD);\n void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D);\n\n NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,\n TypeSourceInfo *TInfo,\n LookupResult &Previous,\n MultiTemplateParamsArg TemplateParamLists,\n bool &AddToScope);\n bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD);\n\n enum class CheckConstexprKind {\n /// Diagnose issues that are non-constant or that are extensions.\n Diagnose,\n /// Identify whether this function satisfies the formal rules for constexpr\n /// functions in the current lanugage mode (with no extensions).\n CheckValid\n };\n\n bool CheckConstexprFunctionDefinition(const FunctionDecl *FD,\n CheckConstexprKind Kind);\n\n void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD);\n void FindHiddenVirtualMethods(CXXMethodDecl *MD,\n SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);\n void NoteHiddenVirtualMethods(CXXMethodDecl *MD,\n SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);\n // Returns true if the function declaration is a redeclaration\n bool CheckFunctionDeclaration(Scope *S,\n FunctionDecl *NewFD, LookupResult &Previous,\n bool IsMemberSpecialization);\n bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl);\n bool canFullyTypeCheckRedeclaration(ValueDecl *NewD, ValueDecl *OldD,\n QualType NewT, QualType OldT);\n void CheckMain(FunctionDecl *FD, const DeclSpec &D);\n void CheckMSVCRTEntryPoint(FunctionDecl *FD);\n Attr *getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD,\n bool IsDefinition);\n void CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D);\n Decl *ActOnParamDeclarator(Scope *S, Declarator &D);\n ParmVarDecl *BuildParmVarDeclForTypedef(DeclContext *DC,\n SourceLocation Loc,\n QualType T);\n ParmVarDecl *CheckParameter(DeclContext *DC, SourceLocation StartLoc,\n SourceLocation NameLoc, IdentifierInfo *Name,\n QualType T, TypeSourceInfo *TSInfo,\n StorageClass SC);\n void ActOnParamDefaultArgument(Decl *param,\n SourceLocation EqualLoc,\n Expr *defarg);\n void ActOnParamUnparsedDefaultArgument(Decl *param, SourceLocation EqualLoc,\n SourceLocation ArgLoc);\n void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc);\n ExprResult ConvertParamDefaultArgument(const ParmVarDecl *Param,\n Expr *DefaultArg,\n SourceLocation EqualLoc);\n void SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,\n SourceLocation EqualLoc);\n\n // Contexts where using non-trivial C union types can be disallowed. This is\n // passed to err_non_trivial_c_union_in_invalid_context.\n enum NonTrivialCUnionContext {\n // Function parameter.\n NTCUC_FunctionParam,\n // Function return.\n NTCUC_FunctionReturn,\n // Default-initialized object.\n NTCUC_DefaultInitializedObject,\n // Variable with automatic storage duration.\n NTCUC_AutoVar,\n // Initializer expression that might copy from another object.\n NTCUC_CopyInit,\n // Assignment.\n NTCUC_Assignment,\n // Compound literal.\n NTCUC_CompoundLiteral,\n // Block capture.\n NTCUC_BlockCapture,\n // lvalue-to-rvalue conversion of volatile type.\n NTCUC_LValueToRValueVolatile,\n };\n\n /// Emit diagnostics if the initializer or any of its explicit or\n /// implicitly-generated subexpressions require copying or\n /// default-initializing a type that is or contains a C union type that is\n /// non-trivial to copy or default-initialize.\n void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc);\n\n // These flags are passed to checkNonTrivialCUnion.\n enum NonTrivialCUnionKind {\n NTCUK_Init = 0x1,\n NTCUK_Destruct = 0x2,\n NTCUK_Copy = 0x4,\n };\n\n /// Emit diagnostics if a non-trivial C union type or a struct that contains\n /// a non-trivial C union is used in an invalid context.\n void checkNonTrivialCUnion(QualType QT, SourceLocation Loc,\n NonTrivialCUnionContext UseContext,\n unsigned NonTrivialKind);\n\n void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit);\n void ActOnUninitializedDecl(Decl *dcl);\n void ActOnInitializerError(Decl *Dcl);\n\n void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc);\n void ActOnCXXForRangeDecl(Decl *D);\n StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,\n IdentifierInfo *Ident,\n ParsedAttributes &Attrs,\n SourceLocation AttrEnd);\n void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc);\n void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc);\n void CheckStaticLocalForDllExport(VarDecl *VD);\n void FinalizeDeclaration(Decl *D);\n DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,\n ArrayRef<Decl *> Group);\n DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef<Decl *> Group);\n\n /// Should be called on all declarations that might have attached\n /// documentation comments.\n void ActOnDocumentableDecl(Decl *D);\n void ActOnDocumentableDecls(ArrayRef<Decl *> Group);\n\n void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,\n SourceLocation LocAfterDecls);\n void CheckForFunctionRedefinition(\n FunctionDecl *FD, const FunctionDecl *EffectiveDefinition = nullptr,\n SkipBodyInfo *SkipBody = nullptr);\n Decl *ActOnStartOfFunctionDef(Scope *S, Declarator &D,\n MultiTemplateParamsArg TemplateParamLists,\n SkipBodyInfo *SkipBody = nullptr);\n Decl *ActOnStartOfFunctionDef(Scope *S, Decl *D,\n SkipBodyInfo *SkipBody = nullptr);\n void ActOnStartTrailingRequiresClause(Scope *S, Declarator &D);\n ExprResult ActOnFinishTrailingRequiresClause(ExprResult ConstraintExpr);\n ExprResult ActOnRequiresClause(ExprResult ConstraintExpr);\n void ActOnStartOfObjCMethodDef(Scope *S, Decl *D);\n bool isObjCMethodDecl(Decl *D) {\n return D && isa<ObjCMethodDecl>(D);\n }\n\n /// Determine whether we can delay parsing the body of a function or\n /// function template until it is used, assuming we don't care about emitting\n /// code for that function.\n ///\n /// This will be \\c false if we may need the body of the function in the\n /// middle of parsing an expression (where it's impractical to switch to\n /// parsing a different function), for instance, if it's constexpr in C++11\n /// or has an 'auto' return type in C++14. These cases are essentially bugs.\n bool canDelayFunctionBody(const Declarator &D);\n\n /// Determine whether we can skip parsing the body of a function\n /// definition, assuming we don't care about analyzing its body or emitting\n /// code for that function.\n ///\n /// This will be \\c false only if we may need the body of the function in\n /// order to parse the rest of the program (for instance, if it is\n /// \\c constexpr in C++11 or has an 'auto' return type in C++14).\n bool canSkipFunctionBody(Decl *D);\n\n void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope);\n Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body);\n Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body, bool IsInstantiation);\n Decl *ActOnSkippedFunctionBody(Decl *Decl);\n void ActOnFinishInlineFunctionDef(FunctionDecl *D);\n\n /// ActOnFinishDelayedAttribute - Invoked when we have finished parsing an\n /// attribute for which parsing is delayed.\n void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs);\n\n /// Diagnose any unused parameters in the given sequence of\n /// ParmVarDecl pointers.\n void DiagnoseUnusedParameters(ArrayRef<ParmVarDecl *> Parameters);\n\n /// Diagnose whether the size of parameters or return value of a\n /// function or obj-c method definition is pass-by-value and larger than a\n /// specified threshold.\n void\n DiagnoseSizeOfParametersAndReturnValue(ArrayRef<ParmVarDecl *> Parameters,\n QualType ReturnTy, NamedDecl *D);\n\n void DiagnoseInvalidJumps(Stmt *Body);\n Decl *ActOnFileScopeAsmDecl(Expr *expr,\n SourceLocation AsmLoc,\n SourceLocation RParenLoc);\n\n /// Handle a C++11 empty-declaration and attribute-declaration.\n Decl *ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList,\n SourceLocation SemiLoc);\n\n enum class ModuleDeclKind {\n Interface, ///< 'export module X;'\n Implementation, ///< 'module X;'\n };\n\n /// The parser has processed a module-declaration that begins the definition\n /// of a module interface or implementation.\n DeclGroupPtrTy ActOnModuleDecl(SourceLocation StartLoc,\n SourceLocation ModuleLoc, ModuleDeclKind MDK,\n ModuleIdPath Path, bool IsFirstDecl);\n\n /// The parser has processed a global-module-fragment declaration that begins\n /// the definition of the global module fragment of the current module unit.\n /// \\param ModuleLoc The location of the 'module' keyword.\n DeclGroupPtrTy ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc);\n\n /// The parser has processed a private-module-fragment declaration that begins\n /// the definition of the private module fragment of the current module unit.\n /// \\param ModuleLoc The location of the 'module' keyword.\n /// \\param PrivateLoc The location of the 'private' keyword.\n DeclGroupPtrTy ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc,\n SourceLocation PrivateLoc);\n\n /// The parser has processed a module import declaration.\n ///\n /// \\param StartLoc The location of the first token in the declaration. This\n /// could be the location of an '@', 'export', or 'import'.\n /// \\param ExportLoc The location of the 'export' keyword, if any.\n /// \\param ImportLoc The location of the 'import' keyword.\n /// \\param Path The module access path.\n DeclResult ActOnModuleImport(SourceLocation StartLoc,\n SourceLocation ExportLoc,\n SourceLocation ImportLoc, ModuleIdPath Path);\n DeclResult ActOnModuleImport(SourceLocation StartLoc,\n SourceLocation ExportLoc,\n SourceLocation ImportLoc, Module *M,\n ModuleIdPath Path = {});\n\n /// The parser has processed a module import translated from a\n /// #include or similar preprocessing directive.\n void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod);\n void BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod);\n\n /// The parsed has entered a submodule.\n void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod);\n /// The parser has left a submodule.\n void ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod);\n\n /// Create an implicit import of the given module at the given\n /// source location, for error recovery, if possible.\n ///\n /// This routine is typically used when an entity found by name lookup\n /// is actually hidden within a module that we know about but the user\n /// has forgotten to import.\n void createImplicitModuleImportForErrorRecovery(SourceLocation Loc,\n Module *Mod);\n\n /// Kinds of missing import. Note, the values of these enumerators correspond\n /// to %select values in diagnostics.\n enum class MissingImportKind {\n Declaration,\n Definition,\n DefaultArgument,\n ExplicitSpecialization,\n PartialSpecialization\n };\n\n /// Diagnose that the specified declaration needs to be visible but\n /// isn't, and suggest a module import that would resolve the problem.\n void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,\n MissingImportKind MIK, bool Recover = true);\n void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,\n SourceLocation DeclLoc, ArrayRef<Module *> Modules,\n MissingImportKind MIK, bool Recover);\n\n Decl *ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc,\n SourceLocation LBraceLoc);\n Decl *ActOnFinishExportDecl(Scope *S, Decl *ExportDecl,\n SourceLocation RBraceLoc);\n\n /// We've found a use of a templated declaration that would trigger an\n /// implicit instantiation. Check that any relevant explicit specializations\n /// and partial specializations are visible, and diagnose if not.\n void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec);\n\n /// Retrieve a suitable printing policy for diagnostics.\n PrintingPolicy getPrintingPolicy() const {\n return getPrintingPolicy(Context, PP);\n }\n\n /// Retrieve a suitable printing policy for diagnostics.\n static PrintingPolicy getPrintingPolicy(const ASTContext &Ctx,\n const Preprocessor &PP);\n\n /// Scope actions.\n void ActOnPopScope(SourceLocation Loc, Scope *S);\n void ActOnTranslationUnitScope(Scope *S);\n\n Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,\n RecordDecl *&AnonRecord);\n Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,\n MultiTemplateParamsArg TemplateParams,\n bool IsExplicitInstantiation,\n RecordDecl *&AnonRecord);\n\n Decl *BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,\n AccessSpecifier AS,\n RecordDecl *Record,\n const PrintingPolicy &Policy);\n\n Decl *BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,\n RecordDecl *Record);\n\n /// Common ways to introduce type names without a tag for use in diagnostics.\n /// Keep in sync with err_tag_reference_non_tag.\n enum NonTagKind {\n NTK_NonStruct,\n NTK_NonClass,\n NTK_NonUnion,\n NTK_NonEnum,\n NTK_Typedef,\n NTK_TypeAlias,\n NTK_Template,\n NTK_TypeAliasTemplate,\n NTK_TemplateTemplateArgument,\n };\n\n /// Given a non-tag type declaration, returns an enum useful for indicating\n /// what kind of non-tag type this is.\n NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK);\n\n bool isAcceptableTagRedeclaration(const TagDecl *Previous,\n TagTypeKind NewTag, bool isDefinition,\n SourceLocation NewTagLoc,\n const IdentifierInfo *Name);\n\n enum TagUseKind {\n TUK_Reference, // Reference to a tag: 'struct foo *X;'\n TUK_Declaration, // Fwd decl of a tag: 'struct foo;'\n TUK_Definition, // Definition of a tag: 'struct foo { int X; } Y;'\n TUK_Friend // Friend declaration: 'friend struct foo;'\n };\n\n Decl *ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,\n SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name,\n SourceLocation NameLoc, const ParsedAttributesView &Attr,\n AccessSpecifier AS, SourceLocation ModulePrivateLoc,\n MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl,\n bool &IsDependent, SourceLocation ScopedEnumKWLoc,\n bool ScopedEnumUsesClassTag, TypeResult UnderlyingType,\n bool IsTypeSpecifier, bool IsTemplateParamOrArg,\n SkipBodyInfo *SkipBody = nullptr);\n\n Decl *ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,\n unsigned TagSpec, SourceLocation TagLoc,\n CXXScopeSpec &SS, IdentifierInfo *Name,\n SourceLocation NameLoc,\n const ParsedAttributesView &Attr,\n MultiTemplateParamsArg TempParamLists);\n\n TypeResult ActOnDependentTag(Scope *S,\n unsigned TagSpec,\n TagUseKind TUK,\n const CXXScopeSpec &SS,\n IdentifierInfo *Name,\n SourceLocation TagLoc,\n SourceLocation NameLoc);\n\n void ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart,\n IdentifierInfo *ClassName,\n SmallVectorImpl<Decl *> &Decls);\n Decl *ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart,\n Declarator &D, Expr *BitfieldWidth);\n\n FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart,\n Declarator &D, Expr *BitfieldWidth,\n InClassInitStyle InitStyle,\n AccessSpecifier AS);\n MSPropertyDecl *HandleMSProperty(Scope *S, RecordDecl *TagD,\n SourceLocation DeclStart, Declarator &D,\n Expr *BitfieldWidth,\n InClassInitStyle InitStyle,\n AccessSpecifier AS,\n const ParsedAttr &MSPropertyAttr);\n\n FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T,\n TypeSourceInfo *TInfo,\n RecordDecl *Record, SourceLocation Loc,\n bool Mutable, Expr *BitfieldWidth,\n InClassInitStyle InitStyle,\n SourceLocation TSSL,\n AccessSpecifier AS, NamedDecl *PrevDecl,\n Declarator *D = nullptr);\n\n bool CheckNontrivialField(FieldDecl *FD);\n void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMember CSM);\n\n enum TrivialABIHandling {\n /// The triviality of a method unaffected by \"trivial_abi\".\n TAH_IgnoreTrivialABI,\n\n /// The triviality of a method affected by \"trivial_abi\".\n TAH_ConsiderTrivialABI\n };\n\n bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM,\n TrivialABIHandling TAH = TAH_IgnoreTrivialABI,\n bool Diagnose = false);\n\n /// For a defaulted function, the kind of defaulted function that it is.\n class DefaultedFunctionKind {\n CXXSpecialMember SpecialMember : 8;\n DefaultedComparisonKind Comparison : 8;\n\n public:\n DefaultedFunctionKind()\n : SpecialMember(CXXInvalid), Comparison(DefaultedComparisonKind::None) {\n }\n DefaultedFunctionKind(CXXSpecialMember CSM)\n : SpecialMember(CSM), Comparison(DefaultedComparisonKind::None) {}\n DefaultedFunctionKind(DefaultedComparisonKind Comp)\n : SpecialMember(CXXInvalid), Comparison(Comp) {}\n\n bool isSpecialMember() const { return SpecialMember != CXXInvalid; }\n bool isComparison() const {\n return Comparison != DefaultedComparisonKind::None;\n }\n\n explicit operator bool() const {\n return isSpecialMember() || isComparison();\n }\n\n CXXSpecialMember asSpecialMember() const { return SpecialMember; }\n DefaultedComparisonKind asComparison() const { return Comparison; }\n\n /// Get the index of this function kind for use in diagnostics.\n unsigned getDiagnosticIndex() const {\n static_assert(CXXInvalid > CXXDestructor,\n \"invalid should have highest index\");\n static_assert((unsigned)DefaultedComparisonKind::None == 0,\n \"none should be equal to zero\");\n return SpecialMember + (unsigned)Comparison;\n }\n };\n\n DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD);\n\n CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD) {\n return getDefaultedFunctionKind(MD).asSpecialMember();\n }\n DefaultedComparisonKind getDefaultedComparisonKind(const FunctionDecl *FD) {\n return getDefaultedFunctionKind(FD).asComparison();\n }\n\n void ActOnLastBitfield(SourceLocation DeclStart,\n SmallVectorImpl<Decl *> &AllIvarDecls);\n Decl *ActOnIvar(Scope *S, SourceLocation DeclStart,\n Declarator &D, Expr *BitfieldWidth,\n tok::ObjCKeywordKind visibility);\n\n // This is used for both record definitions and ObjC interface declarations.\n void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl,\n ArrayRef<Decl *> Fields, SourceLocation LBrac,\n SourceLocation RBrac, const ParsedAttributesView &AttrList);\n\n /// ActOnTagStartDefinition - Invoked when we have entered the\n /// scope of a tag's definition (e.g., for an enumeration, class,\n /// struct, or union).\n void ActOnTagStartDefinition(Scope *S, Decl *TagDecl);\n\n /// Perform ODR-like check for C/ObjC when merging tag types from modules.\n /// Differently from C++, actually parse the body and reject / error out\n /// in case of a structural mismatch.\n bool ActOnDuplicateDefinition(DeclSpec &DS, Decl *Prev,\n SkipBodyInfo &SkipBody);\n\n typedef void *SkippedDefinitionContext;\n\n /// Invoked when we enter a tag definition that we're skipping.\n SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope *S, Decl *TD);\n\n Decl *ActOnObjCContainerStartDefinition(Decl *IDecl);\n\n /// ActOnStartCXXMemberDeclarations - Invoked when we have parsed a\n /// C++ record definition's base-specifiers clause and are starting its\n /// member declarations.\n void ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagDecl,\n SourceLocation FinalLoc,\n bool IsFinalSpelledSealed,\n SourceLocation LBraceLoc);\n\n /// ActOnTagFinishDefinition - Invoked once we have finished parsing\n /// the definition of a tag (enumeration, class, struct, or union).\n void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl,\n SourceRange BraceRange);\n\n void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context);\n\n void ActOnObjCContainerFinishDefinition();\n\n /// Invoked when we must temporarily exit the objective-c container\n /// scope for parsing/looking-up C constructs.\n ///\n /// Must be followed by a call to \\see ActOnObjCReenterContainerContext\n void ActOnObjCTemporaryExitContainerContext(DeclContext *DC);\n void ActOnObjCReenterContainerContext(DeclContext *DC);\n\n /// ActOnTagDefinitionError - Invoked when there was an unrecoverable\n /// error parsing the definition of a tag.\n void ActOnTagDefinitionError(Scope *S, Decl *TagDecl);\n\n EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum,\n EnumConstantDecl *LastEnumConst,\n SourceLocation IdLoc,\n IdentifierInfo *Id,\n Expr *val);\n bool CheckEnumUnderlyingType(TypeSourceInfo *TI);\n bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped,\n QualType EnumUnderlyingTy, bool IsFixed,\n const EnumDecl *Prev);\n\n /// Determine whether the body of an anonymous enumeration should be skipped.\n /// \\param II The name of the first enumerator.\n SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II,\n SourceLocation IILoc);\n\n Decl *ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant,\n SourceLocation IdLoc, IdentifierInfo *Id,\n const ParsedAttributesView &Attrs,\n SourceLocation EqualLoc, Expr *Val);\n void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange,\n Decl *EnumDecl, ArrayRef<Decl *> Elements, Scope *S,\n const ParsedAttributesView &Attr);\n\n /// Set the current declaration context until it gets popped.\n void PushDeclContext(Scope *S, DeclContext *DC);\n void PopDeclContext();\n\n /// EnterDeclaratorContext - Used when we must lookup names in the context\n /// of a declarator's nested name specifier.\n void EnterDeclaratorContext(Scope *S, DeclContext *DC);\n void ExitDeclaratorContext(Scope *S);\n\n /// Enter a template parameter scope, after it's been associated with a particular\n /// DeclContext. Causes lookup within the scope to chain through enclosing contexts\n /// in the correct order.\n void EnterTemplatedContext(Scope *S, DeclContext *DC);\n\n /// Push the parameters of D, which must be a function, into scope.\n void ActOnReenterFunctionContext(Scope* S, Decl* D);\n void ActOnExitFunctionContext();\n\n DeclContext *getFunctionLevelDeclContext();\n\n /// getCurFunctionDecl - If inside of a function body, this returns a pointer\n /// to the function decl for the function being parsed. If we're currently\n /// in a 'block', this returns the containing context.\n FunctionDecl *getCurFunctionDecl();\n\n /// getCurMethodDecl - If inside of a method body, this returns a pointer to\n /// the method decl for the method being parsed. If we're currently\n /// in a 'block', this returns the containing context.\n ObjCMethodDecl *getCurMethodDecl();\n\n /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method\n /// or C function we're in, otherwise return null. If we're currently\n /// in a 'block', this returns the containing context.\n NamedDecl *getCurFunctionOrMethodDecl();\n\n /// Add this decl to the scope shadowed decl chains.\n void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext = true);\n\n /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true\n /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns\n /// true if 'D' belongs to the given declaration context.\n ///\n /// \\param AllowInlineNamespace If \\c true, allow the declaration to be in the\n /// enclosing namespace set of the context, rather than contained\n /// directly within it.\n bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S = nullptr,\n bool AllowInlineNamespace = false);\n\n /// Finds the scope corresponding to the given decl context, if it\n /// happens to be an enclosing scope. Otherwise return NULL.\n static Scope *getScopeForDeclContext(Scope *S, DeclContext *DC);\n\n /// Subroutines of ActOnDeclarator().\n TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T,\n TypeSourceInfo *TInfo);\n bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New);\n\n /// Describes the kind of merge to perform for availability\n /// attributes (including \"deprecated\", \"unavailable\", and \"availability\").\n enum AvailabilityMergeKind {\n /// Don't merge availability attributes at all.\n AMK_None,\n /// Merge availability attributes for a redeclaration, which requires\n /// an exact match.\n AMK_Redeclaration,\n /// Merge availability attributes for an override, which requires\n /// an exact match or a weakening of constraints.\n AMK_Override,\n /// Merge availability attributes for an implementation of\n /// a protocol requirement.\n AMK_ProtocolImplementation,\n };\n\n /// Describes the kind of priority given to an availability attribute.\n ///\n /// The sum of priorities deteremines the final priority of the attribute.\n /// The final priority determines how the attribute will be merged.\n /// An attribute with a lower priority will always remove higher priority\n /// attributes for the specified platform when it is being applied. An\n /// attribute with a higher priority will not be applied if the declaration\n /// already has an availability attribute with a lower priority for the\n /// specified platform. The final prirority values are not expected to match\n /// the values in this enumeration, but instead should be treated as a plain\n /// integer value. This enumeration just names the priority weights that are\n /// used to calculate that final vaue.\n enum AvailabilityPriority : int {\n /// The availability attribute was specified explicitly next to the\n /// declaration.\n AP_Explicit = 0,\n\n /// The availability attribute was applied using '#pragma clang attribute'.\n AP_PragmaClangAttribute = 1,\n\n /// The availability attribute for a specific platform was inferred from\n /// an availability attribute for another platform.\n AP_InferredFromOtherPlatform = 2\n };\n\n /// Attribute merging methods. Return true if a new attribute was added.\n AvailabilityAttr *\n mergeAvailabilityAttr(NamedDecl *D, const AttributeCommonInfo &CI,\n IdentifierInfo *Platform, bool Implicit,\n VersionTuple Introduced, VersionTuple Deprecated,\n VersionTuple Obsoleted, bool IsUnavailable,\n StringRef Message, bool IsStrict, StringRef Replacement,\n AvailabilityMergeKind AMK, int Priority);\n TypeVisibilityAttr *\n mergeTypeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI,\n TypeVisibilityAttr::VisibilityType Vis);\n VisibilityAttr *mergeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI,\n VisibilityAttr::VisibilityType Vis);\n UuidAttr *mergeUuidAttr(Decl *D, const AttributeCommonInfo &CI,\n StringRef UuidAsWritten, MSGuidDecl *GuidDecl);\n DLLImportAttr *mergeDLLImportAttr(Decl *D, const AttributeCommonInfo &CI);\n DLLExportAttr *mergeDLLExportAttr(Decl *D, const AttributeCommonInfo &CI);\n MSInheritanceAttr *mergeMSInheritanceAttr(Decl *D,\n const AttributeCommonInfo &CI,\n bool BestCase,\n MSInheritanceModel Model);\n FormatAttr *mergeFormatAttr(Decl *D, const AttributeCommonInfo &CI,\n IdentifierInfo *Format, int FormatIdx,\n int FirstArg);\n SectionAttr *mergeSectionAttr(Decl *D, const AttributeCommonInfo &CI,\n StringRef Name);\n CodeSegAttr *mergeCodeSegAttr(Decl *D, const AttributeCommonInfo &CI,\n StringRef Name);\n AlwaysInlineAttr *mergeAlwaysInlineAttr(Decl *D,\n const AttributeCommonInfo &CI,\n const IdentifierInfo *Ident);\n MinSizeAttr *mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI);\n NoSpeculativeLoadHardeningAttr *\n mergeNoSpeculativeLoadHardeningAttr(Decl *D,\n const NoSpeculativeLoadHardeningAttr &AL);\n SpeculativeLoadHardeningAttr *\n mergeSpeculativeLoadHardeningAttr(Decl *D,\n const SpeculativeLoadHardeningAttr &AL);\n SwiftNameAttr *mergeSwiftNameAttr(Decl *D, const SwiftNameAttr &SNA,\n StringRef Name);\n OptimizeNoneAttr *mergeOptimizeNoneAttr(Decl *D,\n const AttributeCommonInfo &CI);\n InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D, const ParsedAttr &AL);\n InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D,\n const InternalLinkageAttr &AL);\n CommonAttr *mergeCommonAttr(Decl *D, const ParsedAttr &AL);\n CommonAttr *mergeCommonAttr(Decl *D, const CommonAttr &AL);\n WebAssemblyImportNameAttr *mergeImportNameAttr(\n Decl *D, const WebAssemblyImportNameAttr &AL);\n WebAssemblyImportModuleAttr *mergeImportModuleAttr(\n Decl *D, const WebAssemblyImportModuleAttr &AL);\n EnforceTCBAttr *mergeEnforceTCBAttr(Decl *D, const EnforceTCBAttr &AL);\n EnforceTCBLeafAttr *mergeEnforceTCBLeafAttr(Decl *D,\n const EnforceTCBLeafAttr &AL);\n\n void mergeDeclAttributes(NamedDecl *New, Decl *Old,\n AvailabilityMergeKind AMK = AMK_Redeclaration);\n void MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New,\n LookupResult &OldDecls);\n bool MergeFunctionDecl(FunctionDecl *New, NamedDecl *&Old, Scope *S,\n bool MergeTypeWithOld);\n bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old,\n Scope *S, bool MergeTypeWithOld);\n void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old);\n void MergeVarDecl(VarDecl *New, LookupResult &Previous);\n void MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool MergeTypeWithOld);\n void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old);\n bool checkVarDeclRedefinition(VarDecl *OldDefn, VarDecl *NewDefn);\n void notePreviousDefinition(const NamedDecl *Old, SourceLocation New);\n bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S);\n\n // AssignmentAction - This is used by all the assignment diagnostic functions\n // to represent what is actually causing the operation\n enum AssignmentAction {\n AA_Assigning,\n AA_Passing,\n AA_Returning,\n AA_Converting,\n AA_Initializing,\n AA_Sending,\n AA_Casting,\n AA_Passing_CFAudited\n };\n\n /// C++ Overloading.\n enum OverloadKind {\n /// This is a legitimate overload: the existing declarations are\n /// functions or function templates with different signatures.\n Ovl_Overload,\n\n /// This is not an overload because the signature exactly matches\n /// an existing declaration.\n Ovl_Match,\n\n /// This is not an overload because the lookup results contain a\n /// non-function.\n Ovl_NonFunction\n };\n OverloadKind CheckOverload(Scope *S,\n FunctionDecl *New,\n const LookupResult &OldDecls,\n NamedDecl *&OldDecl,\n bool IsForUsingDecl);\n bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl,\n bool ConsiderCudaAttrs = true,\n bool ConsiderRequiresClauses = true);\n\n enum class AllowedExplicit {\n /// Allow no explicit functions to be used.\n None,\n /// Allow explicit conversion functions but not explicit constructors.\n Conversions,\n /// Allow both explicit conversion functions and explicit constructors.\n All\n };\n\n ImplicitConversionSequence\n TryImplicitConversion(Expr *From, QualType ToType,\n bool SuppressUserConversions,\n AllowedExplicit AllowExplicit,\n bool InOverloadResolution,\n bool CStyle,\n bool AllowObjCWritebackConversion);\n\n bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);\n bool IsFloatingPointPromotion(QualType FromType, QualType ToType);\n bool IsComplexPromotion(QualType FromType, QualType ToType);\n bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,\n bool InOverloadResolution,\n QualType& ConvertedType, bool &IncompatibleObjC);\n bool isObjCPointerConversion(QualType FromType, QualType ToType,\n QualType& ConvertedType, bool &IncompatibleObjC);\n bool isObjCWritebackConversion(QualType FromType, QualType ToType,\n QualType &ConvertedType);\n bool IsBlockPointerConversion(QualType FromType, QualType ToType,\n QualType& ConvertedType);\n bool FunctionParamTypesAreEqual(const FunctionProtoType *OldType,\n const FunctionProtoType *NewType,\n unsigned *ArgPos = nullptr);\n void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag,\n QualType FromType, QualType ToType);\n\n void maybeExtendBlockObject(ExprResult &E);\n CastKind PrepareCastToObjCObjectPointer(ExprResult &E);\n bool CheckPointerConversion(Expr *From, QualType ToType,\n CastKind &Kind,\n CXXCastPath& BasePath,\n bool IgnoreBaseAccess,\n bool Diagnose = true);\n bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,\n bool InOverloadResolution,\n QualType &ConvertedType);\n bool CheckMemberPointerConversion(Expr *From, QualType ToType,\n CastKind &Kind,\n CXXCastPath &BasePath,\n bool IgnoreBaseAccess);\n bool IsQualificationConversion(QualType FromType, QualType ToType,\n bool CStyle, bool &ObjCLifetimeConversion);\n bool IsFunctionConversion(QualType FromType, QualType ToType,\n QualType &ResultTy);\n bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType);\n bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg);\n\n ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity,\n const VarDecl *NRVOCandidate,\n QualType ResultType,\n Expr *Value,\n bool AllowNRVO = true);\n\n bool CanPerformAggregateInitializationForOverloadResolution(\n const InitializedEntity &Entity, InitListExpr *From);\n\n bool IsStringInit(Expr *Init, const ArrayType *AT);\n\n bool CanPerformCopyInitialization(const InitializedEntity &Entity,\n ExprResult Init);\n ExprResult PerformCopyInitialization(const InitializedEntity &Entity,\n SourceLocation EqualLoc,\n ExprResult Init,\n bool TopLevelOfInitList = false,\n bool AllowExplicit = false);\n ExprResult PerformObjectArgumentInitialization(Expr *From,\n NestedNameSpecifier *Qualifier,\n NamedDecl *FoundDecl,\n CXXMethodDecl *Method);\n\n /// Check that the lifetime of the initializer (and its subobjects) is\n /// sufficient for initializing the entity, and perform lifetime extension\n /// (when permitted) if not.\n void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init);\n\n ExprResult PerformContextuallyConvertToBool(Expr *From);\n ExprResult PerformContextuallyConvertToObjCPointer(Expr *From);\n\n /// Contexts in which a converted constant expression is required.\n enum CCEKind {\n CCEK_CaseValue, ///< Expression in a case label.\n CCEK_Enumerator, ///< Enumerator value with fixed underlying type.\n CCEK_TemplateArg, ///< Value of a non-type template parameter.\n CCEK_ArrayBound, ///< Array bound in array declarator or new-expression.\n CCEK_ConstexprIf, ///< Condition in a constexpr if statement.\n CCEK_ExplicitBool ///< Condition in an explicit(bool) specifier.\n };\n ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,\n llvm::APSInt &Value, CCEKind CCE);\n ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,\n APValue &Value, CCEKind CCE,\n NamedDecl *Dest = nullptr);\n\n /// Abstract base class used to perform a contextual implicit\n /// conversion from an expression to any type passing a filter.\n class ContextualImplicitConverter {\n public:\n bool Suppress;\n bool SuppressConversion;\n\n ContextualImplicitConverter(bool Suppress = false,\n bool SuppressConversion = false)\n : Suppress(Suppress), SuppressConversion(SuppressConversion) {}\n\n /// Determine whether the specified type is a valid destination type\n /// for this conversion.\n virtual bool match(QualType T) = 0;\n\n /// Emits a diagnostic complaining that the expression does not have\n /// integral or enumeration type.\n virtual SemaDiagnosticBuilder\n diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) = 0;\n\n /// Emits a diagnostic when the expression has incomplete class type.\n virtual SemaDiagnosticBuilder\n diagnoseIncomplete(Sema &S, SourceLocation Loc, QualType T) = 0;\n\n /// Emits a diagnostic when the only matching conversion function\n /// is explicit.\n virtual SemaDiagnosticBuilder diagnoseExplicitConv(\n Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0;\n\n /// Emits a note for the explicit conversion function.\n virtual SemaDiagnosticBuilder\n noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;\n\n /// Emits a diagnostic when there are multiple possible conversion\n /// functions.\n virtual SemaDiagnosticBuilder\n diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T) = 0;\n\n /// Emits a note for one of the candidate conversions.\n virtual SemaDiagnosticBuilder\n noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;\n\n /// Emits a diagnostic when we picked a conversion function\n /// (for cases when we are not allowed to pick a conversion function).\n virtual SemaDiagnosticBuilder diagnoseConversion(\n Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0;\n\n virtual ~ContextualImplicitConverter() {}\n };\n\n class ICEConvertDiagnoser : public ContextualImplicitConverter {\n bool AllowScopedEnumerations;\n\n public:\n ICEConvertDiagnoser(bool AllowScopedEnumerations,\n bool Suppress, bool SuppressConversion)\n : ContextualImplicitConverter(Suppress, SuppressConversion),\n AllowScopedEnumerations(AllowScopedEnumerations) {}\n\n /// Match an integral or (possibly scoped) enumeration type.\n bool match(QualType T) override;\n\n SemaDiagnosticBuilder\n diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) override {\n return diagnoseNotInt(S, Loc, T);\n }\n\n /// Emits a diagnostic complaining that the expression does not have\n /// integral or enumeration type.\n virtual SemaDiagnosticBuilder\n diagnoseNotInt(Sema &S, SourceLocation Loc, QualType T) = 0;\n };\n\n /// Perform a contextual implicit conversion.\n ExprResult PerformContextualImplicitConversion(\n SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter);\n\n\n enum ObjCSubscriptKind {\n OS_Array,\n OS_Dictionary,\n OS_Error\n };\n ObjCSubscriptKind CheckSubscriptingKind(Expr *FromE);\n\n // Note that LK_String is intentionally after the other literals, as\n // this is used for diagnostics logic.\n enum ObjCLiteralKind {\n LK_Array,\n LK_Dictionary,\n LK_Numeric,\n LK_Boxed,\n LK_String,\n LK_Block,\n LK_None\n };\n ObjCLiteralKind CheckLiteralKind(Expr *FromE);\n\n ExprResult PerformObjectMemberConversion(Expr *From,\n NestedNameSpecifier *Qualifier,\n NamedDecl *FoundDecl,\n NamedDecl *Member);\n\n // Members have to be NamespaceDecl* or TranslationUnitDecl*.\n // TODO: make this is a typesafe union.\n typedef llvm::SmallSetVector<DeclContext *, 16> AssociatedNamespaceSet;\n typedef llvm::SmallSetVector<CXXRecordDecl *, 16> AssociatedClassSet;\n\n using ADLCallKind = CallExpr::ADLCallKind;\n\n void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl,\n ArrayRef<Expr *> Args,\n OverloadCandidateSet &CandidateSet,\n bool SuppressUserConversions = false,\n bool PartialOverloading = false,\n bool AllowExplicit = true,\n bool AllowExplicitConversion = false,\n ADLCallKind IsADLCandidate = ADLCallKind::NotADL,\n ConversionSequenceList EarlyConversions = None,\n OverloadCandidateParamOrder PO = {});\n void AddFunctionCandidates(const UnresolvedSetImpl &Functions,\n ArrayRef<Expr *> Args,\n OverloadCandidateSet &CandidateSet,\n TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,\n bool SuppressUserConversions = false,\n bool PartialOverloading = false,\n bool FirstArgumentIsBase = false);\n void AddMethodCandidate(DeclAccessPair FoundDecl,\n QualType ObjectType,\n Expr::Classification ObjectClassification,\n ArrayRef<Expr *> Args,\n OverloadCandidateSet& CandidateSet,\n bool SuppressUserConversion = false,\n OverloadCandidateParamOrder PO = {});\n void AddMethodCandidate(CXXMethodDecl *Method,\n DeclAccessPair FoundDecl,\n CXXRecordDecl *ActingContext, QualType ObjectType,\n Expr::Classification ObjectClassification,\n ArrayRef<Expr *> Args,\n OverloadCandidateSet& CandidateSet,\n bool SuppressUserConversions = false,\n bool PartialOverloading = false,\n ConversionSequenceList EarlyConversions = None,\n OverloadCandidateParamOrder PO = {});\n void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,\n DeclAccessPair FoundDecl,\n CXXRecordDecl *ActingContext,\n TemplateArgumentListInfo *ExplicitTemplateArgs,\n QualType ObjectType,\n Expr::Classification ObjectClassification,\n ArrayRef<Expr *> Args,\n OverloadCandidateSet& CandidateSet,\n bool SuppressUserConversions = false,\n bool PartialOverloading = false,\n OverloadCandidateParamOrder PO = {});\n void AddTemplateOverloadCandidate(\n FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,\n TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,\n OverloadCandidateSet &CandidateSet, bool SuppressUserConversions = false,\n bool PartialOverloading = false, bool AllowExplicit = true,\n ADLCallKind IsADLCandidate = ADLCallKind::NotADL,\n OverloadCandidateParamOrder PO = {});\n bool CheckNonDependentConversions(\n FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes,\n ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,\n ConversionSequenceList &Conversions, bool SuppressUserConversions,\n CXXRecordDecl *ActingContext = nullptr, QualType ObjectType = QualType(),\n Expr::Classification ObjectClassification = {},\n OverloadCandidateParamOrder PO = {});\n void AddConversionCandidate(\n CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,\n CXXRecordDecl *ActingContext, Expr *From, QualType ToType,\n OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,\n bool AllowExplicit, bool AllowResultConversion = true);\n void AddTemplateConversionCandidate(\n FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,\n CXXRecordDecl *ActingContext, Expr *From, QualType ToType,\n OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,\n bool AllowExplicit, bool AllowResultConversion = true);\n void AddSurrogateCandidate(CXXConversionDecl *Conversion,\n DeclAccessPair FoundDecl,\n CXXRecordDecl *ActingContext,\n const FunctionProtoType *Proto,\n Expr *Object, ArrayRef<Expr *> Args,\n OverloadCandidateSet& CandidateSet);\n void AddNonMemberOperatorCandidates(\n const UnresolvedSetImpl &Functions, ArrayRef<Expr *> Args,\n OverloadCandidateSet &CandidateSet,\n TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr);\n void AddMemberOperatorCandidates(OverloadedOperatorKind Op,\n SourceLocation OpLoc, ArrayRef<Expr *> Args,\n OverloadCandidateSet &CandidateSet,\n OverloadCandidateParamOrder PO = {});\n void AddBuiltinCandidate(QualType *ParamTys, ArrayRef<Expr *> Args,\n OverloadCandidateSet& CandidateSet,\n bool IsAssignmentOperator = false,\n unsigned NumContextualBoolArguments = 0);\n void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,\n SourceLocation OpLoc, ArrayRef<Expr *> Args,\n OverloadCandidateSet& CandidateSet);\n void AddArgumentDependentLookupCandidates(DeclarationName Name,\n SourceLocation Loc,\n ArrayRef<Expr *> Args,\n TemplateArgumentListInfo *ExplicitTemplateArgs,\n OverloadCandidateSet& CandidateSet,\n bool PartialOverloading = false);\n\n // Emit as a 'note' the specific overload candidate\n void NoteOverloadCandidate(\n NamedDecl *Found, FunctionDecl *Fn,\n OverloadCandidateRewriteKind RewriteKind = OverloadCandidateRewriteKind(),\n QualType DestType = QualType(), bool TakingAddress = false);\n\n // Emit as a series of 'note's all template and non-templates identified by\n // the expression Expr\n void NoteAllOverloadCandidates(Expr *E, QualType DestType = QualType(),\n bool TakingAddress = false);\n\n /// Check the enable_if expressions on the given function. Returns the first\n /// failing attribute, or NULL if they were all successful.\n EnableIfAttr *CheckEnableIf(FunctionDecl *Function, SourceLocation CallLoc,\n ArrayRef<Expr *> Args,\n bool MissingImplicitThis = false);\n\n /// Find the failed Boolean condition within a given Boolean\n /// constant expression, and describe it with a string.\n std::pair<Expr *, std::string> findFailedBooleanCondition(Expr *Cond);\n\n /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any\n /// non-ArgDependent DiagnoseIfAttrs.\n ///\n /// Argument-dependent diagnose_if attributes should be checked each time a\n /// function is used as a direct callee of a function call.\n ///\n /// Returns true if any errors were emitted.\n bool diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function,\n const Expr *ThisArg,\n ArrayRef<const Expr *> Args,\n SourceLocation Loc);\n\n /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any\n /// ArgDependent DiagnoseIfAttrs.\n ///\n /// Argument-independent diagnose_if attributes should be checked on every use\n /// of a function.\n ///\n /// Returns true if any errors were emitted.\n bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND,\n SourceLocation Loc);\n\n /// Returns whether the given function's address can be taken or not,\n /// optionally emitting a diagnostic if the address can't be taken.\n ///\n /// Returns false if taking the address of the function is illegal.\n bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function,\n bool Complain = false,\n SourceLocation Loc = SourceLocation());\n\n // [PossiblyAFunctionType] --> [Return]\n // NonFunctionType --> NonFunctionType\n // R (A) --> R(A)\n // R (*)(A) --> R (A)\n // R (&)(A) --> R (A)\n // R (S::*)(A) --> R (A)\n QualType ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType);\n\n FunctionDecl *\n ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,\n QualType TargetType,\n bool Complain,\n DeclAccessPair &Found,\n bool *pHadMultipleCandidates = nullptr);\n\n FunctionDecl *\n resolveAddressOfSingleOverloadCandidate(Expr *E, DeclAccessPair &FoundResult);\n\n bool resolveAndFixAddressOfSingleOverloadCandidate(\n ExprResult &SrcExpr, bool DoFunctionPointerConversion = false);\n\n FunctionDecl *\n ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,\n bool Complain = false,\n DeclAccessPair *Found = nullptr);\n\n bool ResolveAndFixSingleFunctionTemplateSpecialization(\n ExprResult &SrcExpr,\n bool DoFunctionPointerConverion = false,\n bool Complain = false,\n SourceRange OpRangeForComplaining = SourceRange(),\n QualType DestTypeForComplaining = QualType(),\n unsigned DiagIDForComplaining = 0);\n\n\n Expr *FixOverloadedFunctionReference(Expr *E,\n DeclAccessPair FoundDecl,\n FunctionDecl *Fn);\n ExprResult FixOverloadedFunctionReference(ExprResult,\n DeclAccessPair FoundDecl,\n FunctionDecl *Fn);\n\n void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,\n ArrayRef<Expr *> Args,\n OverloadCandidateSet &CandidateSet,\n bool PartialOverloading = false);\n void AddOverloadedCallCandidates(\n LookupResult &R, TemplateArgumentListInfo *ExplicitTemplateArgs,\n ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet);\n\n // An enum used to represent the different possible results of building a\n // range-based for loop.\n enum ForRangeStatus {\n FRS_Success,\n FRS_NoViableFunction,\n FRS_DiagnosticIssued\n };\n\n ForRangeStatus BuildForRangeBeginEndCall(SourceLocation Loc,\n SourceLocation RangeLoc,\n const DeclarationNameInfo &NameInfo,\n LookupResult &MemberLookup,\n OverloadCandidateSet *CandidateSet,\n Expr *Range, ExprResult *CallExpr);\n\n ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn,\n UnresolvedLookupExpr *ULE,\n SourceLocation LParenLoc,\n MultiExprArg Args,\n SourceLocation RParenLoc,\n Expr *ExecConfig,\n bool AllowTypoCorrection=true,\n bool CalleesAddressIsTaken=false);\n\n bool buildOverloadedCallSet(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE,\n MultiExprArg Args, SourceLocation RParenLoc,\n OverloadCandidateSet *CandidateSet,\n ExprResult *Result);\n\n ExprResult CreateUnresolvedLookupExpr(CXXRecordDecl *NamingClass,\n NestedNameSpecifierLoc NNSLoc,\n DeclarationNameInfo DNI,\n const UnresolvedSetImpl &Fns,\n bool PerformADL = true);\n\n ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,\n UnaryOperatorKind Opc,\n const UnresolvedSetImpl &Fns,\n Expr *input, bool RequiresADL = true);\n\n void LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet,\n OverloadedOperatorKind Op,\n const UnresolvedSetImpl &Fns,\n ArrayRef<Expr *> Args, bool RequiresADL = true);\n ExprResult CreateOverloadedBinOp(SourceLocation OpLoc,\n BinaryOperatorKind Opc,\n const UnresolvedSetImpl &Fns,\n Expr *LHS, Expr *RHS,\n bool RequiresADL = true,\n bool AllowRewrittenCandidates = true,\n FunctionDecl *DefaultedFn = nullptr);\n ExprResult BuildSynthesizedThreeWayComparison(SourceLocation OpLoc,\n const UnresolvedSetImpl &Fns,\n Expr *LHS, Expr *RHS,\n FunctionDecl *DefaultedFn);\n\n ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,\n SourceLocation RLoc,\n Expr *Base,Expr *Idx);\n\n ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr,\n SourceLocation LParenLoc,\n MultiExprArg Args,\n SourceLocation RParenLoc,\n bool AllowRecovery = false);\n ExprResult\n BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,\n MultiExprArg Args,\n SourceLocation RParenLoc);\n\n ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base,\n SourceLocation OpLoc,\n bool *NoArrowOperatorFound = nullptr);\n\n /// CheckCallReturnType - Checks that a call expression's return type is\n /// complete. Returns true on failure. The location passed in is the location\n /// that best represents the call.\n bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc,\n CallExpr *CE, FunctionDecl *FD);\n\n /// Helpers for dealing with blocks and functions.\n bool CheckParmsForFunctionDef(ArrayRef<ParmVarDecl *> Parameters,\n bool CheckParameterNames);\n void CheckCXXDefaultArguments(FunctionDecl *FD);\n void CheckExtraCXXDefaultArguments(Declarator &D);\n Scope *getNonFieldDeclScope(Scope *S);\n\n /// \\name Name lookup\n ///\n /// These routines provide name lookup that is used during semantic\n /// analysis to resolve the various kinds of names (identifiers,\n /// overloaded operator names, constructor names, etc.) into zero or\n /// more declarations within a particular scope. The major entry\n /// points are LookupName, which performs unqualified name lookup,\n /// and LookupQualifiedName, which performs qualified name lookup.\n ///\n /// All name lookup is performed based on some specific criteria,\n /// which specify what names will be visible to name lookup and how\n /// far name lookup should work. These criteria are important both\n /// for capturing language semantics (certain lookups will ignore\n /// certain names, for example) and for performance, since name\n /// lookup is often a bottleneck in the compilation of C++. Name\n /// lookup criteria is specified via the LookupCriteria enumeration.\n ///\n /// The results of name lookup can vary based on the kind of name\n /// lookup performed, the current language, and the translation\n /// unit. In C, for example, name lookup will either return nothing\n /// (no entity found) or a single declaration. In C++, name lookup\n /// can additionally refer to a set of overloaded functions or\n /// result in an ambiguity. All of the possible results of name\n /// lookup are captured by the LookupResult class, which provides\n /// the ability to distinguish among them.\n //@{\n\n /// Describes the kind of name lookup to perform.\n enum LookupNameKind {\n /// Ordinary name lookup, which finds ordinary names (functions,\n /// variables, typedefs, etc.) in C and most kinds of names\n /// (functions, variables, members, types, etc.) in C++.\n LookupOrdinaryName = 0,\n /// Tag name lookup, which finds the names of enums, classes,\n /// structs, and unions.\n LookupTagName,\n /// Label name lookup.\n LookupLabel,\n /// Member name lookup, which finds the names of\n /// class/struct/union members.\n LookupMemberName,\n /// Look up of an operator name (e.g., operator+) for use with\n /// operator overloading. This lookup is similar to ordinary name\n /// lookup, but will ignore any declarations that are class members.\n LookupOperatorName,\n /// Look up a name following ~ in a destructor name. This is an ordinary\n /// lookup, but prefers tags to typedefs.\n LookupDestructorName,\n /// Look up of a name that precedes the '::' scope resolution\n /// operator in C++. This lookup completely ignores operator, object,\n /// function, and enumerator names (C++ [basic.lookup.qual]p1).\n LookupNestedNameSpecifierName,\n /// Look up a namespace name within a C++ using directive or\n /// namespace alias definition, ignoring non-namespace names (C++\n /// [basic.lookup.udir]p1).\n LookupNamespaceName,\n /// Look up all declarations in a scope with the given name,\n /// including resolved using declarations. This is appropriate\n /// for checking redeclarations for a using declaration.\n LookupUsingDeclName,\n /// Look up an ordinary name that is going to be redeclared as a\n /// name with linkage. This lookup ignores any declarations that\n /// are outside of the current scope unless they have linkage. See\n /// C99 6.2.2p4-5 and C++ [basic.link]p6.\n LookupRedeclarationWithLinkage,\n /// Look up a friend of a local class. This lookup does not look\n /// outside the innermost non-class scope. See C++11 [class.friend]p11.\n LookupLocalFriendName,\n /// Look up the name of an Objective-C protocol.\n LookupObjCProtocolName,\n /// Look up implicit 'self' parameter of an objective-c method.\n LookupObjCImplicitSelfParam,\n /// Look up the name of an OpenMP user-defined reduction operation.\n LookupOMPReductionName,\n /// Look up the name of an OpenMP user-defined mapper.\n LookupOMPMapperName,\n /// Look up any declaration with any name.\n LookupAnyName\n };\n\n /// Specifies whether (or how) name lookup is being performed for a\n /// redeclaration (vs. a reference).\n enum RedeclarationKind {\n /// The lookup is a reference to this name that is not for the\n /// purpose of redeclaring the name.\n NotForRedeclaration = 0,\n /// The lookup results will be used for redeclaration of a name,\n /// if an entity by that name already exists and is visible.\n ForVisibleRedeclaration,\n /// The lookup results will be used for redeclaration of a name\n /// with external linkage; non-visible lookup results with external linkage\n /// may also be found.\n ForExternalRedeclaration\n };\n\n RedeclarationKind forRedeclarationInCurContext() {\n // A declaration with an owning module for linkage can never link against\n // anything that is not visible. We don't need to check linkage here; if\n // the context has internal linkage, redeclaration lookup won't find things\n // from other TUs, and we can't safely compute linkage yet in general.\n if (cast<Decl>(CurContext)\n ->getOwningModuleForLinkage(/*IgnoreLinkage*/true))\n return ForVisibleRedeclaration;\n return ForExternalRedeclaration;\n }\n\n /// The possible outcomes of name lookup for a literal operator.\n enum LiteralOperatorLookupResult {\n /// The lookup resulted in an error.\n LOLR_Error,\n /// The lookup found no match but no diagnostic was issued.\n LOLR_ErrorNoDiagnostic,\n /// The lookup found a single 'cooked' literal operator, which\n /// expects a normal literal to be built and passed to it.\n LOLR_Cooked,\n /// The lookup found a single 'raw' literal operator, which expects\n /// a string literal containing the spelling of the literal token.\n LOLR_Raw,\n /// The lookup found an overload set of literal operator templates,\n /// which expect the characters of the spelling of the literal token to be\n /// passed as a non-type template argument pack.\n LOLR_Template,\n /// The lookup found an overload set of literal operator templates,\n /// which expect the character type and characters of the spelling of the\n /// string literal token to be passed as template arguments.\n LOLR_StringTemplatePack,\n };\n\n SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D,\n CXXSpecialMember SM,\n bool ConstArg,\n bool VolatileArg,\n bool RValueThis,\n bool ConstThis,\n bool VolatileThis);\n\n typedef std::function<void(const TypoCorrection &)> TypoDiagnosticGenerator;\n typedef std::function<ExprResult(Sema &, TypoExpr *, TypoCorrection)>\n TypoRecoveryCallback;\n\nprivate:\n bool CppLookupName(LookupResult &R, Scope *S);\n\n struct TypoExprState {\n std::unique_ptr<TypoCorrectionConsumer> Consumer;\n TypoDiagnosticGenerator DiagHandler;\n TypoRecoveryCallback RecoveryHandler;\n TypoExprState();\n TypoExprState(TypoExprState &&other) noexcept;\n TypoExprState &operator=(TypoExprState &&other) noexcept;\n };\n\n /// The set of unhandled TypoExprs and their associated state.\n llvm::MapVector<TypoExpr *, TypoExprState> DelayedTypos;\n\n /// Creates a new TypoExpr AST node.\n TypoExpr *createDelayedTypo(std::unique_ptr<TypoCorrectionConsumer> TCC,\n TypoDiagnosticGenerator TDG,\n TypoRecoveryCallback TRC, SourceLocation TypoLoc);\n\n // The set of known/encountered (unique, canonicalized) NamespaceDecls.\n //\n // The boolean value will be true to indicate that the namespace was loaded\n // from an AST/PCH file, or false otherwise.\n llvm::MapVector<NamespaceDecl*, bool> KnownNamespaces;\n\n /// Whether we have already loaded known namespaces from an extenal\n /// source.\n bool LoadedExternalKnownNamespaces;\n\n /// Helper for CorrectTypo and CorrectTypoDelayed used to create and\n /// populate a new TypoCorrectionConsumer. Returns nullptr if typo correction\n /// should be skipped entirely.\n std::unique_ptr<TypoCorrectionConsumer>\n makeTypoCorrectionConsumer(const DeclarationNameInfo &Typo,\n Sema::LookupNameKind LookupKind, Scope *S,\n CXXScopeSpec *SS,\n CorrectionCandidateCallback &CCC,\n DeclContext *MemberContext, bool EnteringContext,\n const ObjCObjectPointerType *OPT,\n bool ErrorRecovery);\n\npublic:\n const TypoExprState &getTypoExprState(TypoExpr *TE) const;\n\n /// Clears the state of the given TypoExpr.\n void clearDelayedTypo(TypoExpr *TE);\n\n /// Look up a name, looking for a single declaration. Return\n /// null if the results were absent, ambiguous, or overloaded.\n ///\n /// It is preferable to use the elaborated form and explicitly handle\n /// ambiguity and overloaded.\n NamedDecl *LookupSingleName(Scope *S, DeclarationName Name,\n SourceLocation Loc,\n LookupNameKind NameKind,\n RedeclarationKind Redecl\n = NotForRedeclaration);\n bool LookupBuiltin(LookupResult &R);\n void LookupNecessaryTypesForBuiltin(Scope *S, unsigned ID);\n bool LookupName(LookupResult &R, Scope *S,\n bool AllowBuiltinCreation = false);\n bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,\n bool InUnqualifiedLookup = false);\n bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,\n CXXScopeSpec &SS);\n bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS,\n bool AllowBuiltinCreation = false,\n bool EnteringContext = false);\n ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II, SourceLocation IdLoc,\n RedeclarationKind Redecl\n = NotForRedeclaration);\n bool LookupInSuper(LookupResult &R, CXXRecordDecl *Class);\n\n void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,\n UnresolvedSetImpl &Functions);\n\n LabelDecl *LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc,\n SourceLocation GnuLabelLoc = SourceLocation());\n\n DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class);\n CXXConstructorDecl *LookupDefaultConstructor(CXXRecordDecl *Class);\n CXXConstructorDecl *LookupCopyingConstructor(CXXRecordDecl *Class,\n unsigned Quals);\n CXXMethodDecl *LookupCopyingAssignment(CXXRecordDecl *Class, unsigned Quals,\n bool RValueThis, unsigned ThisQuals);\n CXXConstructorDecl *LookupMovingConstructor(CXXRecordDecl *Class,\n unsigned Quals);\n CXXMethodDecl *LookupMovingAssignment(CXXRecordDecl *Class, unsigned Quals,\n bool RValueThis, unsigned ThisQuals);\n CXXDestructorDecl *LookupDestructor(CXXRecordDecl *Class);\n\n bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id);\n LiteralOperatorLookupResult\n LookupLiteralOperator(Scope *S, LookupResult &R, ArrayRef<QualType> ArgTys,\n bool AllowRaw, bool AllowTemplate,\n bool AllowStringTemplate, bool DiagnoseMissing,\n StringLiteral *StringLit = nullptr);\n bool isKnownName(StringRef name);\n\n /// Status of the function emission on the CUDA/HIP/OpenMP host/device attrs.\n enum class FunctionEmissionStatus {\n Emitted,\n CUDADiscarded, // Discarded due to CUDA/HIP hostness\n OMPDiscarded, // Discarded due to OpenMP hostness\n TemplateDiscarded, // Discarded due to uninstantiated templates\n Unknown,\n };\n FunctionEmissionStatus getEmissionStatus(FunctionDecl *Decl,\n bool Final = false);\n\n // Whether the callee should be ignored in CUDA/HIP/OpenMP host/device check.\n bool shouldIgnoreInHostDeviceCheck(FunctionDecl *Callee);\n\n void ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc,\n ArrayRef<Expr *> Args, ADLResult &Functions);\n\n void LookupVisibleDecls(Scope *S, LookupNameKind Kind,\n VisibleDeclConsumer &Consumer,\n bool IncludeGlobalScope = true,\n bool LoadExternal = true);\n void LookupVisibleDecls(DeclContext *Ctx, LookupNameKind Kind,\n VisibleDeclConsumer &Consumer,\n bool IncludeGlobalScope = true,\n bool IncludeDependentBases = false,\n bool LoadExternal = true);\n\n enum CorrectTypoKind {\n CTK_NonError, // CorrectTypo used in a non error recovery situation.\n CTK_ErrorRecovery // CorrectTypo used in normal error recovery.\n };\n\n TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,\n Sema::LookupNameKind LookupKind,\n Scope *S, CXXScopeSpec *SS,\n CorrectionCandidateCallback &CCC,\n CorrectTypoKind Mode,\n DeclContext *MemberContext = nullptr,\n bool EnteringContext = false,\n const ObjCObjectPointerType *OPT = nullptr,\n bool RecordFailure = true);\n\n TypoExpr *CorrectTypoDelayed(const DeclarationNameInfo &Typo,\n Sema::LookupNameKind LookupKind, Scope *S,\n CXXScopeSpec *SS,\n CorrectionCandidateCallback &CCC,\n TypoDiagnosticGenerator TDG,\n TypoRecoveryCallback TRC, CorrectTypoKind Mode,\n DeclContext *MemberContext = nullptr,\n bool EnteringContext = false,\n const ObjCObjectPointerType *OPT = nullptr);\n\n /// Process any TypoExprs in the given Expr and its children,\n /// generating diagnostics as appropriate and returning a new Expr if there\n /// were typos that were all successfully corrected and ExprError if one or\n /// more typos could not be corrected.\n ///\n /// \\param E The Expr to check for TypoExprs.\n ///\n /// \\param InitDecl A VarDecl to avoid because the Expr being corrected is its\n /// initializer.\n ///\n /// \\param RecoverUncorrectedTypos If true, when typo correction fails, it\n /// will rebuild the given Expr with all TypoExprs degraded to RecoveryExprs.\n ///\n /// \\param Filter A function applied to a newly rebuilt Expr to determine if\n /// it is an acceptable/usable result from a single combination of typo\n /// corrections. As long as the filter returns ExprError, different\n /// combinations of corrections will be tried until all are exhausted.\n ExprResult CorrectDelayedTyposInExpr(\n Expr *E, VarDecl *InitDecl = nullptr,\n bool RecoverUncorrectedTypos = false,\n llvm::function_ref<ExprResult(Expr *)> Filter =\n [](Expr *E) -> ExprResult { return E; });\n\n ExprResult CorrectDelayedTyposInExpr(\n ExprResult ER, VarDecl *InitDecl = nullptr,\n bool RecoverUncorrectedTypos = false,\n llvm::function_ref<ExprResult(Expr *)> Filter =\n [](Expr *E) -> ExprResult { return E; }) {\n return ER.isInvalid()\n ? ER\n : CorrectDelayedTyposInExpr(ER.get(), InitDecl,\n RecoverUncorrectedTypos, Filter);\n }\n\n void diagnoseTypo(const TypoCorrection &Correction,\n const PartialDiagnostic &TypoDiag,\n bool ErrorRecovery = true);\n\n void diagnoseTypo(const TypoCorrection &Correction,\n const PartialDiagnostic &TypoDiag,\n const PartialDiagnostic &PrevNote,\n bool ErrorRecovery = true);\n\n void MarkTypoCorrectedFunctionDefinition(const NamedDecl *F);\n\n void FindAssociatedClassesAndNamespaces(SourceLocation InstantiationLoc,\n ArrayRef<Expr *> Args,\n AssociatedNamespaceSet &AssociatedNamespaces,\n AssociatedClassSet &AssociatedClasses);\n\n void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S,\n bool ConsiderLinkage, bool AllowInlineNamespace);\n\n bool CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old);\n\n void DiagnoseAmbiguousLookup(LookupResult &Result);\n //@}\n\n /// Attempts to produce a RecoveryExpr after some AST node cannot be created.\n ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End,\n ArrayRef<Expr *> SubExprs,\n QualType T = QualType());\n\n ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *&Id,\n SourceLocation IdLoc,\n bool TypoCorrection = false);\n FunctionDecl *CreateBuiltin(IdentifierInfo *II, QualType Type, unsigned ID,\n SourceLocation Loc);\n NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,\n Scope *S, bool ForRedeclaration,\n SourceLocation Loc);\n NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,\n Scope *S);\n void AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(\n FunctionDecl *FD);\n void AddKnownFunctionAttributes(FunctionDecl *FD);\n\n // More parsing and symbol table subroutines.\n\n void ProcessPragmaWeak(Scope *S, Decl *D);\n // Decl attributes - this routine is the top level dispatcher.\n void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD);\n // Helper for delayed processing of attributes.\n void ProcessDeclAttributeDelayed(Decl *D,\n const ParsedAttributesView &AttrList);\n void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AL,\n bool IncludeCXX11Attributes = true);\n bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,\n const ParsedAttributesView &AttrList);\n\n void checkUnusedDeclAttributes(Declarator &D);\n\n /// Determine if type T is a valid subject for a nonnull and similar\n /// attributes. By default, we look through references (the behavior used by\n /// nonnull), but if the second parameter is true, then we treat a reference\n /// type as valid.\n bool isValidPointerAttrType(QualType T, bool RefOkay = false);\n\n bool CheckRegparmAttr(const ParsedAttr &attr, unsigned &value);\n bool CheckCallingConvAttr(const ParsedAttr &attr, CallingConv &CC,\n const FunctionDecl *FD = nullptr);\n bool CheckAttrTarget(const ParsedAttr &CurrAttr);\n bool CheckAttrNoArgs(const ParsedAttr &CurrAttr);\n bool checkStringLiteralArgumentAttr(const ParsedAttr &Attr, unsigned ArgNum,\n StringRef &Str,\n SourceLocation *ArgLocation = nullptr);\n bool checkSectionName(SourceLocation LiteralLoc, StringRef Str);\n bool checkTargetAttr(SourceLocation LiteralLoc, StringRef Str);\n bool checkMSInheritanceAttrOnDefinition(\n CXXRecordDecl *RD, SourceRange Range, bool BestCase,\n MSInheritanceModel SemanticSpelling);\n\n void CheckAlignasUnderalignment(Decl *D);\n\n /// Adjust the calling convention of a method to be the ABI default if it\n /// wasn't specified explicitly. This handles method types formed from\n /// function type typedefs and typename template arguments.\n void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor,\n SourceLocation Loc);\n\n // Check if there is an explicit attribute, but only look through parens.\n // The intent is to look for an attribute on the current declarator, but not\n // one that came from a typedef.\n bool hasExplicitCallingConv(QualType T);\n\n /// Get the outermost AttributedType node that sets a calling convention.\n /// Valid types should not have multiple attributes with different CCs.\n const AttributedType *getCallingConvAttributedType(QualType T) const;\n\n /// Stmt attributes - this routine is the top level dispatcher.\n StmtResult ProcessStmtAttributes(Stmt *Stmt,\n const ParsedAttributesView &Attrs,\n SourceRange Range);\n\n void WarnConflictingTypedMethods(ObjCMethodDecl *Method,\n ObjCMethodDecl *MethodDecl,\n bool IsProtocolMethodDecl);\n\n void CheckConflictingOverridingMethod(ObjCMethodDecl *Method,\n ObjCMethodDecl *Overridden,\n bool IsProtocolMethodDecl);\n\n /// WarnExactTypedMethods - This routine issues a warning if method\n /// implementation declaration matches exactly that of its declaration.\n void WarnExactTypedMethods(ObjCMethodDecl *Method,\n ObjCMethodDecl *MethodDecl,\n bool IsProtocolMethodDecl);\n\n typedef llvm::SmallPtrSet<Selector, 8> SelectorSet;\n\n /// CheckImplementationIvars - This routine checks if the instance variables\n /// listed in the implelementation match those listed in the interface.\n void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,\n ObjCIvarDecl **Fields, unsigned nIvars,\n SourceLocation Loc);\n\n /// ImplMethodsVsClassMethods - This is main routine to warn if any method\n /// remains unimplemented in the class or category \\@implementation.\n void ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl* IMPDecl,\n ObjCContainerDecl* IDecl,\n bool IncompleteImpl = false);\n\n /// DiagnoseUnimplementedProperties - This routine warns on those properties\n /// which must be implemented by this implementation.\n void DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl* IMPDecl,\n ObjCContainerDecl *CDecl,\n bool SynthesizeProperties);\n\n /// Diagnose any null-resettable synthesized setters.\n void diagnoseNullResettableSynthesizedSetters(const ObjCImplDecl *impDecl);\n\n /// DefaultSynthesizeProperties - This routine default synthesizes all\n /// properties which must be synthesized in the class's \\@implementation.\n void DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl,\n ObjCInterfaceDecl *IDecl,\n SourceLocation AtEnd);\n void DefaultSynthesizeProperties(Scope *S, Decl *D, SourceLocation AtEnd);\n\n /// IvarBacksCurrentMethodAccessor - This routine returns 'true' if 'IV' is\n /// an ivar synthesized for 'Method' and 'Method' is a property accessor\n /// declared in class 'IFace'.\n bool IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace,\n ObjCMethodDecl *Method, ObjCIvarDecl *IV);\n\n /// DiagnoseUnusedBackingIvarInAccessor - Issue an 'unused' warning if ivar which\n /// backs the property is not used in the property's accessor.\n void DiagnoseUnusedBackingIvarInAccessor(Scope *S,\n const ObjCImplementationDecl *ImplD);\n\n /// GetIvarBackingPropertyAccessor - If method is a property setter/getter and\n /// it property has a backing ivar, returns this ivar; otherwise, returns NULL.\n /// It also returns ivar's property on success.\n ObjCIvarDecl *GetIvarBackingPropertyAccessor(const ObjCMethodDecl *Method,\n const ObjCPropertyDecl *&PDecl) const;\n\n /// Called by ActOnProperty to handle \\@property declarations in\n /// class extensions.\n ObjCPropertyDecl *HandlePropertyInClassExtension(Scope *S,\n SourceLocation AtLoc,\n SourceLocation LParenLoc,\n FieldDeclarator &FD,\n Selector GetterSel,\n SourceLocation GetterNameLoc,\n Selector SetterSel,\n SourceLocation SetterNameLoc,\n const bool isReadWrite,\n unsigned &Attributes,\n const unsigned AttributesAsWritten,\n QualType T,\n TypeSourceInfo *TSI,\n tok::ObjCKeywordKind MethodImplKind);\n\n /// Called by ActOnProperty and HandlePropertyInClassExtension to\n /// handle creating the ObjcPropertyDecl for a category or \\@interface.\n ObjCPropertyDecl *CreatePropertyDecl(Scope *S,\n ObjCContainerDecl *CDecl,\n SourceLocation AtLoc,\n SourceLocation LParenLoc,\n FieldDeclarator &FD,\n Selector GetterSel,\n SourceLocation GetterNameLoc,\n Selector SetterSel,\n SourceLocation SetterNameLoc,\n const bool isReadWrite,\n const unsigned Attributes,\n const unsigned AttributesAsWritten,\n QualType T,\n TypeSourceInfo *TSI,\n tok::ObjCKeywordKind MethodImplKind,\n DeclContext *lexicalDC = nullptr);\n\n /// AtomicPropertySetterGetterRules - This routine enforces the rule (via\n /// warning) when atomic property has one but not the other user-declared\n /// setter or getter.\n void AtomicPropertySetterGetterRules(ObjCImplDecl* IMPDecl,\n ObjCInterfaceDecl* IDecl);\n\n void DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D);\n\n void DiagnoseMissingDesignatedInitOverrides(\n const ObjCImplementationDecl *ImplD,\n const ObjCInterfaceDecl *IFD);\n\n void DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID);\n\n enum MethodMatchStrategy {\n MMS_loose,\n MMS_strict\n };\n\n /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns\n /// true, or false, accordingly.\n bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,\n const ObjCMethodDecl *PrevMethod,\n MethodMatchStrategy strategy = MMS_strict);\n\n /// MatchAllMethodDeclarations - Check methods declaraed in interface or\n /// or protocol against those declared in their implementations.\n void MatchAllMethodDeclarations(const SelectorSet &InsMap,\n const SelectorSet &ClsMap,\n SelectorSet &InsMapSeen,\n SelectorSet &ClsMapSeen,\n ObjCImplDecl* IMPDecl,\n ObjCContainerDecl* IDecl,\n bool &IncompleteImpl,\n bool ImmediateClass,\n bool WarnCategoryMethodImpl=false);\n\n /// CheckCategoryVsClassMethodMatches - Checks that methods implemented in\n /// category matches with those implemented in its primary class and\n /// warns each time an exact match is found.\n void CheckCategoryVsClassMethodMatches(ObjCCategoryImplDecl *CatIMP);\n\n /// Add the given method to the list of globally-known methods.\n void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method);\n\n /// Returns default addr space for method qualifiers.\n LangAS getDefaultCXXMethodAddrSpace() const;\n\nprivate:\n /// AddMethodToGlobalPool - Add an instance or factory method to the global\n /// pool. See descriptoin of AddInstanceMethodToGlobalPool.\n void AddMethodToGlobalPool(ObjCMethodDecl *Method, bool impl, bool instance);\n\n /// LookupMethodInGlobalPool - Returns the instance or factory method and\n /// optionally warns if there are multiple signatures.\n ObjCMethodDecl *LookupMethodInGlobalPool(Selector Sel, SourceRange R,\n bool receiverIdOrClass,\n bool instance);\n\npublic:\n /// - Returns instance or factory methods in global method pool for\n /// given selector. It checks the desired kind first, if none is found, and\n /// parameter checkTheOther is set, it then checks the other kind. If no such\n /// method or only one method is found, function returns false; otherwise, it\n /// returns true.\n bool\n CollectMultipleMethodsInGlobalPool(Selector Sel,\n SmallVectorImpl<ObjCMethodDecl*>& Methods,\n bool InstanceFirst, bool CheckTheOther,\n const ObjCObjectType *TypeBound = nullptr);\n\n bool\n AreMultipleMethodsInGlobalPool(Selector Sel, ObjCMethodDecl *BestMethod,\n SourceRange R, bool receiverIdOrClass,\n SmallVectorImpl<ObjCMethodDecl*>& Methods);\n\n void\n DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl<ObjCMethodDecl*> &Methods,\n Selector Sel, SourceRange R,\n bool receiverIdOrClass);\n\nprivate:\n /// - Returns a selector which best matches given argument list or\n /// nullptr if none could be found\n ObjCMethodDecl *SelectBestMethod(Selector Sel, MultiExprArg Args,\n bool IsInstance,\n SmallVectorImpl<ObjCMethodDecl*>& Methods);\n\n\n /// Record the typo correction failure and return an empty correction.\n TypoCorrection FailedCorrection(IdentifierInfo *Typo, SourceLocation TypoLoc,\n bool RecordFailure = true) {\n if (RecordFailure)\n TypoCorrectionFailures[Typo].insert(TypoLoc);\n return TypoCorrection();\n }\n\npublic:\n /// AddInstanceMethodToGlobalPool - All instance methods in a translation\n /// unit are added to a global pool. This allows us to efficiently associate\n /// a selector with a method declaraation for purposes of typechecking\n /// messages sent to \"id\" (where the class of the object is unknown).\n void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) {\n AddMethodToGlobalPool(Method, impl, /*instance*/true);\n }\n\n /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods.\n void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) {\n AddMethodToGlobalPool(Method, impl, /*instance*/false);\n }\n\n /// AddAnyMethodToGlobalPool - Add any method, instance or factory to global\n /// pool.\n void AddAnyMethodToGlobalPool(Decl *D);\n\n /// LookupInstanceMethodInGlobalPool - Returns the method and warns if\n /// there are multiple signatures.\n ObjCMethodDecl *LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R,\n bool receiverIdOrClass=false) {\n return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,\n /*instance*/true);\n }\n\n /// LookupFactoryMethodInGlobalPool - Returns the method and warns if\n /// there are multiple signatures.\n ObjCMethodDecl *LookupFactoryMethodInGlobalPool(Selector Sel, SourceRange R,\n bool receiverIdOrClass=false) {\n return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,\n /*instance*/false);\n }\n\n const ObjCMethodDecl *SelectorsForTypoCorrection(Selector Sel,\n QualType ObjectType=QualType());\n /// LookupImplementedMethodInGlobalPool - Returns the method which has an\n /// implementation.\n ObjCMethodDecl *LookupImplementedMethodInGlobalPool(Selector Sel);\n\n /// CollectIvarsToConstructOrDestruct - Collect those ivars which require\n /// initialization.\n void CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI,\n SmallVectorImpl<ObjCIvarDecl*> &Ivars);\n\n //===--------------------------------------------------------------------===//\n // Statement Parsing Callbacks: SemaStmt.cpp.\npublic:\n class FullExprArg {\n public:\n FullExprArg() : E(nullptr) { }\n FullExprArg(Sema &actions) : E(nullptr) { }\n\n ExprResult release() {\n return E;\n }\n\n Expr *get() const { return E; }\n\n Expr *operator->() {\n return E;\n }\n\n private:\n // FIXME: No need to make the entire Sema class a friend when it's just\n // Sema::MakeFullExpr that needs access to the constructor below.\n friend class Sema;\n\n explicit FullExprArg(Expr *expr) : E(expr) {}\n\n Expr *E;\n };\n\n FullExprArg MakeFullExpr(Expr *Arg) {\n return MakeFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation());\n }\n FullExprArg MakeFullExpr(Expr *Arg, SourceLocation CC) {\n return FullExprArg(\n ActOnFinishFullExpr(Arg, CC, /*DiscardedValue*/ false).get());\n }\n FullExprArg MakeFullDiscardedValueExpr(Expr *Arg) {\n ExprResult FE =\n ActOnFinishFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation(),\n /*DiscardedValue*/ true);\n return FullExprArg(FE.get());\n }\n\n StmtResult ActOnExprStmt(ExprResult Arg, bool DiscardedValue = true);\n StmtResult ActOnExprStmtError();\n\n StmtResult ActOnNullStmt(SourceLocation SemiLoc,\n bool HasLeadingEmptyMacro = false);\n\n void ActOnStartOfCompoundStmt(bool IsStmtExpr);\n void ActOnAfterCompoundStatementLeadingPragmas();\n void ActOnFinishOfCompoundStmt();\n StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,\n ArrayRef<Stmt *> Elts, bool isStmtExpr);\n\n /// A RAII object to enter scope of a compound statement.\n class CompoundScopeRAII {\n public:\n CompoundScopeRAII(Sema &S, bool IsStmtExpr = false) : S(S) {\n S.ActOnStartOfCompoundStmt(IsStmtExpr);\n }\n\n ~CompoundScopeRAII() {\n S.ActOnFinishOfCompoundStmt();\n }\n\n private:\n Sema &S;\n };\n\n /// An RAII helper that pops function a function scope on exit.\n struct FunctionScopeRAII {\n Sema &S;\n bool Active;\n FunctionScopeRAII(Sema &S) : S(S), Active(true) {}\n ~FunctionScopeRAII() {\n if (Active)\n S.PopFunctionScopeInfo();\n }\n void disable() { Active = false; }\n };\n\n StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,\n SourceLocation StartLoc,\n SourceLocation EndLoc);\n void ActOnForEachDeclStmt(DeclGroupPtrTy Decl);\n StmtResult ActOnForEachLValueExpr(Expr *E);\n ExprResult ActOnCaseExpr(SourceLocation CaseLoc, ExprResult Val);\n StmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprResult LHS,\n SourceLocation DotDotDotLoc, ExprResult RHS,\n SourceLocation ColonLoc);\n void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt);\n\n StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,\n SourceLocation ColonLoc,\n Stmt *SubStmt, Scope *CurScope);\n StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,\n SourceLocation ColonLoc, Stmt *SubStmt);\n\n StmtResult ActOnAttributedStmt(SourceLocation AttrLoc,\n ArrayRef<const Attr*> Attrs,\n Stmt *SubStmt);\n\n class ConditionResult;\n StmtResult ActOnIfStmt(SourceLocation IfLoc, bool IsConstexpr,\n SourceLocation LParenLoc, Stmt *InitStmt,\n ConditionResult Cond, SourceLocation RParenLoc,\n Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal);\n StmtResult BuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,\n SourceLocation LParenLoc, Stmt *InitStmt,\n ConditionResult Cond, SourceLocation RParenLoc,\n Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal);\n StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,\n SourceLocation LParenLoc, Stmt *InitStmt,\n ConditionResult Cond,\n SourceLocation RParenLoc);\n StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,\n Stmt *Switch, Stmt *Body);\n StmtResult ActOnWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc,\n ConditionResult Cond, SourceLocation RParenLoc,\n Stmt *Body);\n StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,\n SourceLocation WhileLoc, SourceLocation CondLParen,\n Expr *Cond, SourceLocation CondRParen);\n\n StmtResult ActOnForStmt(SourceLocation ForLoc,\n SourceLocation LParenLoc,\n Stmt *First,\n ConditionResult Second,\n FullExprArg Third,\n SourceLocation RParenLoc,\n Stmt *Body);\n ExprResult CheckObjCForCollectionOperand(SourceLocation forLoc,\n Expr *collection);\n StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,\n Stmt *First, Expr *collection,\n SourceLocation RParenLoc);\n StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body);\n\n enum BuildForRangeKind {\n /// Initial building of a for-range statement.\n BFRK_Build,\n /// Instantiation or recovery rebuild of a for-range statement. Don't\n /// attempt any typo-correction.\n BFRK_Rebuild,\n /// Determining whether a for-range statement could be built. Avoid any\n /// unnecessary or irreversible actions.\n BFRK_Check\n };\n\n StmtResult ActOnCXXForRangeStmt(Scope *S, SourceLocation ForLoc,\n SourceLocation CoawaitLoc,\n Stmt *InitStmt,\n Stmt *LoopVar,\n SourceLocation ColonLoc, Expr *Collection,\n SourceLocation RParenLoc,\n BuildForRangeKind Kind);\n StmtResult BuildCXXForRangeStmt(SourceLocation ForLoc,\n SourceLocation CoawaitLoc,\n Stmt *InitStmt,\n SourceLocation ColonLoc,\n Stmt *RangeDecl, Stmt *Begin, Stmt *End,\n Expr *Cond, Expr *Inc,\n Stmt *LoopVarDecl,\n SourceLocation RParenLoc,\n BuildForRangeKind Kind);\n StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body);\n\n StmtResult ActOnGotoStmt(SourceLocation GotoLoc,\n SourceLocation LabelLoc,\n LabelDecl *TheDecl);\n StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,\n SourceLocation StarLoc,\n Expr *DestExp);\n StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope);\n StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope);\n\n void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,\n CapturedRegionKind Kind, unsigned NumParams);\n typedef std::pair<StringRef, QualType> CapturedParamNameType;\n void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,\n CapturedRegionKind Kind,\n ArrayRef<CapturedParamNameType> Params,\n unsigned OpenMPCaptureLevel = 0);\n StmtResult ActOnCapturedRegionEnd(Stmt *S);\n void ActOnCapturedRegionError();\n RecordDecl *CreateCapturedStmtRecordDecl(CapturedDecl *&CD,\n SourceLocation Loc,\n unsigned NumParams);\n\n enum CopyElisionSemanticsKind {\n CES_Strict = 0,\n CES_AllowParameters = 1,\n CES_AllowDifferentTypes = 2,\n CES_AllowExceptionVariables = 4,\n CES_AllowRValueReferenceType = 8,\n CES_ImplicitlyMovableCXX11CXX14CXX17 =\n (CES_AllowParameters | CES_AllowDifferentTypes),\n CES_ImplicitlyMovableCXX20 =\n (CES_AllowParameters | CES_AllowDifferentTypes |\n CES_AllowExceptionVariables | CES_AllowRValueReferenceType),\n };\n\n VarDecl *getCopyElisionCandidate(QualType ReturnType, Expr *E,\n CopyElisionSemanticsKind CESK);\n bool isCopyElisionCandidate(QualType ReturnType, const VarDecl *VD,\n CopyElisionSemanticsKind CESK);\n\n StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,\n Scope *CurScope);\n StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);\n StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);\n\n StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,\n bool IsVolatile, unsigned NumOutputs,\n unsigned NumInputs, IdentifierInfo **Names,\n MultiExprArg Constraints, MultiExprArg Exprs,\n Expr *AsmString, MultiExprArg Clobbers,\n unsigned NumLabels,\n SourceLocation RParenLoc);\n\n void FillInlineAsmIdentifierInfo(Expr *Res,\n llvm::InlineAsmIdentifierInfo &Info);\n ExprResult LookupInlineAsmIdentifier(CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n UnqualifiedId &Id,\n bool IsUnevaluatedContext);\n bool LookupInlineAsmField(StringRef Base, StringRef Member,\n unsigned &Offset, SourceLocation AsmLoc);\n ExprResult LookupInlineAsmVarDeclField(Expr *RefExpr, StringRef Member,\n SourceLocation AsmLoc);\n StmtResult ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,\n ArrayRef<Token> AsmToks,\n StringRef AsmString,\n unsigned NumOutputs, unsigned NumInputs,\n ArrayRef<StringRef> Constraints,\n ArrayRef<StringRef> Clobbers,\n ArrayRef<Expr*> Exprs,\n SourceLocation EndLoc);\n LabelDecl *GetOrCreateMSAsmLabel(StringRef ExternalLabelName,\n SourceLocation Location,\n bool AlwaysCreate);\n\n VarDecl *BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType,\n SourceLocation StartLoc,\n SourceLocation IdLoc, IdentifierInfo *Id,\n bool Invalid = false);\n\n Decl *ActOnObjCExceptionDecl(Scope *S, Declarator &D);\n\n StmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc, SourceLocation RParen,\n Decl *Parm, Stmt *Body);\n\n StmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body);\n\n StmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,\n MultiStmtArg Catch, Stmt *Finally);\n\n StmtResult BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw);\n StmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,\n Scope *CurScope);\n ExprResult ActOnObjCAtSynchronizedOperand(SourceLocation atLoc,\n Expr *operand);\n StmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,\n Expr *SynchExpr,\n Stmt *SynchBody);\n\n StmtResult ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body);\n\n VarDecl *BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo,\n SourceLocation StartLoc,\n SourceLocation IdLoc,\n IdentifierInfo *Id);\n\n Decl *ActOnExceptionDeclarator(Scope *S, Declarator &D);\n\n StmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,\n Decl *ExDecl, Stmt *HandlerBlock);\n StmtResult ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,\n ArrayRef<Stmt *> Handlers);\n\n StmtResult ActOnSEHTryBlock(bool IsCXXTry, // try (true) or __try (false) ?\n SourceLocation TryLoc, Stmt *TryBlock,\n Stmt *Handler);\n StmtResult ActOnSEHExceptBlock(SourceLocation Loc,\n Expr *FilterExpr,\n Stmt *Block);\n void ActOnStartSEHFinallyBlock();\n void ActOnAbortSEHFinallyBlock();\n StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block);\n StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope);\n\n void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);\n\n bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const;\n\n /// If it's a file scoped decl that must warn if not used, keep track\n /// of it.\n void MarkUnusedFileScopedDecl(const DeclaratorDecl *D);\n\n /// DiagnoseUnusedExprResult - If the statement passed in is an expression\n /// whose result is unused, warn.\n void DiagnoseUnusedExprResult(const Stmt *S);\n void DiagnoseUnusedNestedTypedefs(const RecordDecl *D);\n void DiagnoseUnusedDecl(const NamedDecl *ND);\n\n /// Emit \\p DiagID if statement located on \\p StmtLoc has a suspicious null\n /// statement as a \\p Body, and it is located on the same line.\n ///\n /// This helps prevent bugs due to typos, such as:\n /// if (condition);\n /// do_stuff();\n void DiagnoseEmptyStmtBody(SourceLocation StmtLoc,\n const Stmt *Body,\n unsigned DiagID);\n\n /// Warn if a for/while loop statement \\p S, which is followed by\n /// \\p PossibleBody, has a suspicious null statement as a body.\n void DiagnoseEmptyLoopBody(const Stmt *S,\n const Stmt *PossibleBody);\n\n /// Warn if a value is moved to itself.\n void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr,\n SourceLocation OpLoc);\n\n /// Warn if we're implicitly casting from a _Nullable pointer type to a\n /// _Nonnull one.\n void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType,\n SourceLocation Loc);\n\n /// Warn when implicitly casting 0 to nullptr.\n void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E);\n\n ParsingDeclState PushParsingDeclaration(sema::DelayedDiagnosticPool &pool) {\n return DelayedDiagnostics.push(pool);\n }\n void PopParsingDeclaration(ParsingDeclState state, Decl *decl);\n\n typedef ProcessingContextState ParsingClassState;\n ParsingClassState PushParsingClass() {\n ParsingClassDepth++;\n return DelayedDiagnostics.pushUndelayed();\n }\n void PopParsingClass(ParsingClassState state) {\n ParsingClassDepth--;\n DelayedDiagnostics.popUndelayed(state);\n }\n\n void redelayDiagnostics(sema::DelayedDiagnosticPool &pool);\n\n void DiagnoseAvailabilityOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,\n const ObjCInterfaceDecl *UnknownObjCClass,\n bool ObjCPropertyAccess,\n bool AvoidPartialAvailabilityChecks = false,\n ObjCInterfaceDecl *ClassReceiver = nullptr);\n\n bool makeUnavailableInSystemHeader(SourceLocation loc,\n UnavailableAttr::ImplicitReason reason);\n\n /// Issue any -Wunguarded-availability warnings in \\c FD\n void DiagnoseUnguardedAvailabilityViolations(Decl *FD);\n\n void handleDelayedAvailabilityCheck(sema::DelayedDiagnostic &DD, Decl *Ctx);\n\n //===--------------------------------------------------------------------===//\n // Expression Parsing Callbacks: SemaExpr.cpp.\n\n bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid);\n bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,\n const ObjCInterfaceDecl *UnknownObjCClass = nullptr,\n bool ObjCPropertyAccess = false,\n bool AvoidPartialAvailabilityChecks = false,\n ObjCInterfaceDecl *ClassReciever = nullptr);\n void NoteDeletedFunction(FunctionDecl *FD);\n void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD);\n bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,\n ObjCMethodDecl *Getter,\n SourceLocation Loc);\n void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,\n ArrayRef<Expr *> Args);\n\n void PushExpressionEvaluationContext(\n ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl = nullptr,\n ExpressionEvaluationContextRecord::ExpressionKind Type =\n ExpressionEvaluationContextRecord::EK_Other);\n enum ReuseLambdaContextDecl_t { ReuseLambdaContextDecl };\n void PushExpressionEvaluationContext(\n ExpressionEvaluationContext NewContext, ReuseLambdaContextDecl_t,\n ExpressionEvaluationContextRecord::ExpressionKind Type =\n ExpressionEvaluationContextRecord::EK_Other);\n void PopExpressionEvaluationContext();\n\n void DiscardCleanupsInEvaluationContext();\n\n ExprResult TransformToPotentiallyEvaluated(Expr *E);\n ExprResult HandleExprEvaluationContextForTypeof(Expr *E);\n\n ExprResult CheckUnevaluatedOperand(Expr *E);\n void CheckUnusedVolatileAssignment(Expr *E);\n\n ExprResult ActOnConstantExpression(ExprResult Res);\n\n // Functions for marking a declaration referenced. These functions also\n // contain the relevant logic for marking if a reference to a function or\n // variable is an odr-use (in the C++11 sense). There are separate variants\n // for expressions referring to a decl; these exist because odr-use marking\n // needs to be delayed for some constant variables when we build one of the\n // named expressions.\n //\n // MightBeOdrUse indicates whether the use could possibly be an odr-use, and\n // should usually be true. This only needs to be set to false if the lack of\n // odr-use cannot be determined from the current context (for instance,\n // because the name denotes a virtual function and was written without an\n // explicit nested-name-specifier).\n void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse);\n void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,\n bool MightBeOdrUse = true);\n void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var);\n void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base = nullptr);\n void MarkMemberReferenced(MemberExpr *E);\n void MarkFunctionParmPackReferenced(FunctionParmPackExpr *E);\n void MarkCaptureUsedInEnclosingContext(VarDecl *Capture, SourceLocation Loc,\n unsigned CapturingScopeIndex);\n\n ExprResult CheckLValueToRValueConversionOperand(Expr *E);\n void CleanupVarDeclMarking();\n\n enum TryCaptureKind {\n TryCapture_Implicit, TryCapture_ExplicitByVal, TryCapture_ExplicitByRef\n };\n\n /// Try to capture the given variable.\n ///\n /// \\param Var The variable to capture.\n ///\n /// \\param Loc The location at which the capture occurs.\n ///\n /// \\param Kind The kind of capture, which may be implicit (for either a\n /// block or a lambda), or explicit by-value or by-reference (for a lambda).\n ///\n /// \\param EllipsisLoc The location of the ellipsis, if one is provided in\n /// an explicit lambda capture.\n ///\n /// \\param BuildAndDiagnose Whether we are actually supposed to add the\n /// captures or diagnose errors. If false, this routine merely check whether\n /// the capture can occur without performing the capture itself or complaining\n /// if the variable cannot be captured.\n ///\n /// \\param CaptureType Will be set to the type of the field used to capture\n /// this variable in the innermost block or lambda. Only valid when the\n /// variable can be captured.\n ///\n /// \\param DeclRefType Will be set to the type of a reference to the capture\n /// from within the current scope. Only valid when the variable can be\n /// captured.\n ///\n /// \\param FunctionScopeIndexToStopAt If non-null, it points to the index\n /// of the FunctionScopeInfo stack beyond which we do not attempt to capture.\n /// This is useful when enclosing lambdas must speculatively capture\n /// variables that may or may not be used in certain specializations of\n /// a nested generic lambda.\n ///\n /// \\returns true if an error occurred (i.e., the variable cannot be\n /// captured) and false if the capture succeeded.\n bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, TryCaptureKind Kind,\n SourceLocation EllipsisLoc, bool BuildAndDiagnose,\n QualType &CaptureType,\n QualType &DeclRefType,\n const unsigned *const FunctionScopeIndexToStopAt);\n\n /// Try to capture the given variable.\n bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc,\n TryCaptureKind Kind = TryCapture_Implicit,\n SourceLocation EllipsisLoc = SourceLocation());\n\n /// Checks if the variable must be captured.\n bool NeedToCaptureVariable(VarDecl *Var, SourceLocation Loc);\n\n /// Given a variable, determine the type that a reference to that\n /// variable will have in the given scope.\n QualType getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc);\n\n /// Mark all of the declarations referenced within a particular AST node as\n /// referenced. Used when template instantiation instantiates a non-dependent\n /// type -- entities referenced by the type are now referenced.\n void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T);\n void MarkDeclarationsReferencedInExpr(Expr *E,\n bool SkipLocalVariables = false);\n\n /// Try to recover by turning the given expression into a\n /// call. Returns true if recovery was attempted or an error was\n /// emitted; this may also leave the ExprResult invalid.\n bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,\n bool ForceComplain = false,\n bool (*IsPlausibleResult)(QualType) = nullptr);\n\n /// Figure out if an expression could be turned into a call.\n bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,\n UnresolvedSetImpl &NonTemplateOverloads);\n\n /// Try to convert an expression \\p E to type \\p Ty. Returns the result of the\n /// conversion.\n ExprResult tryConvertExprToType(Expr *E, QualType Ty);\n\n /// Conditionally issue a diagnostic based on the current\n /// evaluation context.\n ///\n /// \\param Statement If Statement is non-null, delay reporting the\n /// diagnostic until the function body is parsed, and then do a basic\n /// reachability analysis to determine if the statement is reachable.\n /// If it is unreachable, the diagnostic will not be emitted.\n bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,\n const PartialDiagnostic &PD);\n /// Similar, but diagnostic is only produced if all the specified statements\n /// are reachable.\n bool DiagRuntimeBehavior(SourceLocation Loc, ArrayRef<const Stmt*> Stmts,\n const PartialDiagnostic &PD);\n\n // Primary Expressions.\n SourceRange getExprRange(Expr *E) const;\n\n ExprResult ActOnIdExpression(\n Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,\n UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand,\n CorrectionCandidateCallback *CCC = nullptr,\n bool IsInlineAsmIdentifier = false, Token *KeywordReplacement = nullptr);\n\n void DecomposeUnqualifiedId(const UnqualifiedId &Id,\n TemplateArgumentListInfo &Buffer,\n DeclarationNameInfo &NameInfo,\n const TemplateArgumentListInfo *&TemplateArgs);\n\n bool DiagnoseDependentMemberLookup(LookupResult &R);\n\n bool\n DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,\n CorrectionCandidateCallback &CCC,\n TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,\n ArrayRef<Expr *> Args = None, TypoExpr **Out = nullptr);\n\n DeclResult LookupIvarInObjCMethod(LookupResult &Lookup, Scope *S,\n IdentifierInfo *II);\n ExprResult BuildIvarRefExpr(Scope *S, SourceLocation Loc, ObjCIvarDecl *IV);\n\n ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S,\n IdentifierInfo *II,\n bool AllowBuiltinCreation=false);\n\n ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n const DeclarationNameInfo &NameInfo,\n bool isAddressOfOperand,\n const TemplateArgumentListInfo *TemplateArgs);\n\n /// If \\p D cannot be odr-used in the current expression evaluation context,\n /// return a reason explaining why. Otherwise, return NOUR_None.\n NonOdrUseReason getNonOdrUseReasonInCurrentContext(ValueDecl *D);\n\n DeclRefExpr *BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,\n SourceLocation Loc,\n const CXXScopeSpec *SS = nullptr);\n DeclRefExpr *\n BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,\n const DeclarationNameInfo &NameInfo,\n const CXXScopeSpec *SS = nullptr,\n NamedDecl *FoundD = nullptr,\n SourceLocation TemplateKWLoc = SourceLocation(),\n const TemplateArgumentListInfo *TemplateArgs = nullptr);\n DeclRefExpr *\n BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,\n const DeclarationNameInfo &NameInfo,\n NestedNameSpecifierLoc NNS,\n NamedDecl *FoundD = nullptr,\n SourceLocation TemplateKWLoc = SourceLocation(),\n const TemplateArgumentListInfo *TemplateArgs = nullptr);\n\n ExprResult\n BuildAnonymousStructUnionMemberReference(\n const CXXScopeSpec &SS,\n SourceLocation nameLoc,\n IndirectFieldDecl *indirectField,\n DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_none),\n Expr *baseObjectExpr = nullptr,\n SourceLocation opLoc = SourceLocation());\n\n ExprResult BuildPossibleImplicitMemberExpr(\n const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R,\n const TemplateArgumentListInfo *TemplateArgs, const Scope *S,\n UnresolvedLookupExpr *AsULE = nullptr);\n ExprResult BuildImplicitMemberExpr(const CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n LookupResult &R,\n const TemplateArgumentListInfo *TemplateArgs,\n bool IsDefiniteInstance,\n const Scope *S);\n bool UseArgumentDependentLookup(const CXXScopeSpec &SS,\n const LookupResult &R,\n bool HasTrailingLParen);\n\n ExprResult\n BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS,\n const DeclarationNameInfo &NameInfo,\n bool IsAddressOfOperand, const Scope *S,\n TypeSourceInfo **RecoveryTSI = nullptr);\n\n ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n const DeclarationNameInfo &NameInfo,\n const TemplateArgumentListInfo *TemplateArgs);\n\n ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS,\n LookupResult &R,\n bool NeedsADL,\n bool AcceptInvalidDecl = false);\n ExprResult BuildDeclarationNameExpr(\n const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D,\n NamedDecl *FoundD = nullptr,\n const TemplateArgumentListInfo *TemplateArgs = nullptr,\n bool AcceptInvalidDecl = false);\n\n ExprResult BuildLiteralOperatorCall(LookupResult &R,\n DeclarationNameInfo &SuffixInfo,\n ArrayRef<Expr *> Args,\n SourceLocation LitEndLoc,\n TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr);\n\n ExprResult BuildPredefinedExpr(SourceLocation Loc,\n PredefinedExpr::IdentKind IK);\n ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind);\n ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val);\n\n bool CheckLoopHintExpr(Expr *E, SourceLocation Loc);\n\n ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope = nullptr);\n ExprResult ActOnCharacterConstant(const Token &Tok,\n Scope *UDLScope = nullptr);\n ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E);\n ExprResult ActOnParenListExpr(SourceLocation L,\n SourceLocation R,\n MultiExprArg Val);\n\n /// ActOnStringLiteral - The specified tokens were lexed as pasted string\n /// fragments (e.g. \"foo\" \"bar\" L\"baz\").\n ExprResult ActOnStringLiteral(ArrayRef<Token> StringToks,\n Scope *UDLScope = nullptr);\n\n ExprResult ActOnGenericSelectionExpr(SourceLocation KeyLoc,\n SourceLocation DefaultLoc,\n SourceLocation RParenLoc,\n Expr *ControllingExpr,\n ArrayRef<ParsedType> ArgTypes,\n ArrayRef<Expr *> ArgExprs);\n ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc,\n SourceLocation DefaultLoc,\n SourceLocation RParenLoc,\n Expr *ControllingExpr,\n ArrayRef<TypeSourceInfo *> Types,\n ArrayRef<Expr *> Exprs);\n\n // Binary/Unary Operators. 'Tok' is the token for the operator.\n ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc,\n Expr *InputExpr);\n ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc,\n UnaryOperatorKind Opc, Expr *Input);\n ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,\n tok::TokenKind Op, Expr *Input);\n\n bool isQualifiedMemberAccess(Expr *E);\n QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc);\n\n ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo,\n SourceLocation OpLoc,\n UnaryExprOrTypeTrait ExprKind,\n SourceRange R);\n ExprResult CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,\n UnaryExprOrTypeTrait ExprKind);\n ExprResult\n ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc,\n UnaryExprOrTypeTrait ExprKind,\n bool IsType, void *TyOrEx,\n SourceRange ArgRange);\n\n ExprResult CheckPlaceholderExpr(Expr *E);\n bool CheckVecStepExpr(Expr *E);\n\n bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind);\n bool CheckUnaryExprOrTypeTraitOperand(QualType ExprType, SourceLocation OpLoc,\n SourceRange ExprRange,\n UnaryExprOrTypeTrait ExprKind);\n ExprResult ActOnSizeofParameterPackExpr(Scope *S,\n SourceLocation OpLoc,\n IdentifierInfo &Name,\n SourceLocation NameLoc,\n SourceLocation RParenLoc);\n ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,\n tok::TokenKind Kind, Expr *Input);\n\n ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc,\n Expr *Idx, SourceLocation RLoc);\n ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,\n Expr *Idx, SourceLocation RLoc);\n\n ExprResult CreateBuiltinMatrixSubscriptExpr(Expr *Base, Expr *RowIdx,\n Expr *ColumnIdx,\n SourceLocation RBLoc);\n\n ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc,\n Expr *LowerBound,\n SourceLocation ColonLocFirst,\n SourceLocation ColonLocSecond,\n Expr *Length, Expr *Stride,\n SourceLocation RBLoc);\n ExprResult ActOnOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc,\n SourceLocation RParenLoc,\n ArrayRef<Expr *> Dims,\n ArrayRef<SourceRange> Brackets);\n\n /// Data structure for iterator expression.\n struct OMPIteratorData {\n IdentifierInfo *DeclIdent = nullptr;\n SourceLocation DeclIdentLoc;\n ParsedType Type;\n OMPIteratorExpr::IteratorRange Range;\n SourceLocation AssignLoc;\n SourceLocation ColonLoc;\n SourceLocation SecColonLoc;\n };\n\n ExprResult ActOnOMPIteratorExpr(Scope *S, SourceLocation IteratorKwLoc,\n SourceLocation LLoc, SourceLocation RLoc,\n ArrayRef<OMPIteratorData> Data);\n\n // This struct is for use by ActOnMemberAccess to allow\n // BuildMemberReferenceExpr to be able to reinvoke ActOnMemberAccess after\n // changing the access operator from a '.' to a '->' (to see if that is the\n // change needed to fix an error about an unknown member, e.g. when the class\n // defines a custom operator->).\n struct ActOnMemberAccessExtraArgs {\n Scope *S;\n UnqualifiedId &Id;\n Decl *ObjCImpDecl;\n };\n\n ExprResult BuildMemberReferenceExpr(\n Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow,\n CXXScopeSpec &SS, SourceLocation TemplateKWLoc,\n NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo,\n const TemplateArgumentListInfo *TemplateArgs,\n const Scope *S,\n ActOnMemberAccessExtraArgs *ExtraArgs = nullptr);\n\n ExprResult\n BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc,\n bool IsArrow, const CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n NamedDecl *FirstQualifierInScope, LookupResult &R,\n const TemplateArgumentListInfo *TemplateArgs,\n const Scope *S,\n bool SuppressQualifierCheck = false,\n ActOnMemberAccessExtraArgs *ExtraArgs = nullptr);\n\n ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow,\n SourceLocation OpLoc,\n const CXXScopeSpec &SS, FieldDecl *Field,\n DeclAccessPair FoundDecl,\n const DeclarationNameInfo &MemberNameInfo);\n\n ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow);\n\n bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType,\n const CXXScopeSpec &SS,\n const LookupResult &R);\n\n ExprResult ActOnDependentMemberExpr(Expr *Base, QualType BaseType,\n bool IsArrow, SourceLocation OpLoc,\n const CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n NamedDecl *FirstQualifierInScope,\n const DeclarationNameInfo &NameInfo,\n const TemplateArgumentListInfo *TemplateArgs);\n\n ExprResult ActOnMemberAccessExpr(Scope *S, Expr *Base,\n SourceLocation OpLoc,\n tok::TokenKind OpKind,\n CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n UnqualifiedId &Member,\n Decl *ObjCImpDecl);\n\n MemberExpr *\n BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc,\n const CXXScopeSpec *SS, SourceLocation TemplateKWLoc,\n ValueDecl *Member, DeclAccessPair FoundDecl,\n bool HadMultipleCandidates,\n const DeclarationNameInfo &MemberNameInfo, QualType Ty,\n ExprValueKind VK, ExprObjectKind OK,\n const TemplateArgumentListInfo *TemplateArgs = nullptr);\n MemberExpr *\n BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc,\n NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc,\n ValueDecl *Member, DeclAccessPair FoundDecl,\n bool HadMultipleCandidates,\n const DeclarationNameInfo &MemberNameInfo, QualType Ty,\n ExprValueKind VK, ExprObjectKind OK,\n const TemplateArgumentListInfo *TemplateArgs = nullptr);\n\n void ActOnDefaultCtorInitializers(Decl *CDtorDecl);\n bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,\n FunctionDecl *FDecl,\n const FunctionProtoType *Proto,\n ArrayRef<Expr *> Args,\n SourceLocation RParenLoc,\n bool ExecConfig = false);\n void CheckStaticArrayArgument(SourceLocation CallLoc,\n ParmVarDecl *Param,\n const Expr *ArgExpr);\n\n /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.\n /// This provides the location of the left/right parens and a list of comma\n /// locations.\n ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,\n MultiExprArg ArgExprs, SourceLocation RParenLoc,\n Expr *ExecConfig = nullptr);\n ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,\n MultiExprArg ArgExprs, SourceLocation RParenLoc,\n Expr *ExecConfig = nullptr,\n bool IsExecConfig = false,\n bool AllowRecovery = false);\n enum class AtomicArgumentOrder { API, AST };\n ExprResult\n BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,\n SourceLocation RParenLoc, MultiExprArg Args,\n AtomicExpr::AtomicOp Op,\n AtomicArgumentOrder ArgOrder = AtomicArgumentOrder::API);\n ExprResult\n BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc,\n ArrayRef<Expr *> Arg, SourceLocation RParenLoc,\n Expr *Config = nullptr, bool IsExecConfig = false,\n ADLCallKind UsesADL = ADLCallKind::NotADL);\n\n ExprResult ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc,\n MultiExprArg ExecConfig,\n SourceLocation GGGLoc);\n\n ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,\n Declarator &D, ParsedType &Ty,\n SourceLocation RParenLoc, Expr *CastExpr);\n ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc,\n TypeSourceInfo *Ty,\n SourceLocation RParenLoc,\n Expr *Op);\n CastKind PrepareScalarCast(ExprResult &src, QualType destType);\n\n /// Build an altivec or OpenCL literal.\n ExprResult BuildVectorLiteral(SourceLocation LParenLoc,\n SourceLocation RParenLoc, Expr *E,\n TypeSourceInfo *TInfo);\n\n ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME);\n\n ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,\n ParsedType Ty,\n SourceLocation RParenLoc,\n Expr *InitExpr);\n\n ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc,\n TypeSourceInfo *TInfo,\n SourceLocation RParenLoc,\n Expr *LiteralExpr);\n\n ExprResult ActOnInitList(SourceLocation LBraceLoc,\n MultiExprArg InitArgList,\n SourceLocation RBraceLoc);\n\n ExprResult BuildInitList(SourceLocation LBraceLoc,\n MultiExprArg InitArgList,\n SourceLocation RBraceLoc);\n\n ExprResult ActOnDesignatedInitializer(Designation &Desig,\n SourceLocation EqualOrColonLoc,\n bool GNUSyntax,\n ExprResult Init);\n\nprivate:\n static BinaryOperatorKind ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind);\n\npublic:\n ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,\n tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr);\n ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc,\n BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr);\n ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc,\n Expr *LHSExpr, Expr *RHSExpr);\n void LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc,\n UnresolvedSetImpl &Functions);\n\n void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc);\n\n /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null\n /// in the case of a the GNU conditional expr extension.\n ExprResult ActOnConditionalOp(SourceLocation QuestionLoc,\n SourceLocation ColonLoc,\n Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr);\n\n /// ActOnAddrLabel - Parse the GNU address of label extension: \"&&foo\".\n ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc,\n LabelDecl *TheDecl);\n\n void ActOnStartStmtExpr();\n ExprResult ActOnStmtExpr(Scope *S, SourceLocation LPLoc, Stmt *SubStmt,\n SourceLocation RPLoc);\n ExprResult BuildStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,\n SourceLocation RPLoc, unsigned TemplateDepth);\n // Handle the final expression in a statement expression.\n ExprResult ActOnStmtExprResult(ExprResult E);\n void ActOnStmtExprError();\n\n // __builtin_offsetof(type, identifier(.identifier|[expr])*)\n struct OffsetOfComponent {\n SourceLocation LocStart, LocEnd;\n bool isBrackets; // true if [expr], false if .ident\n union {\n IdentifierInfo *IdentInfo;\n Expr *E;\n } U;\n };\n\n /// __builtin_offsetof(type, a.b[123][456].c)\n ExprResult BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,\n TypeSourceInfo *TInfo,\n ArrayRef<OffsetOfComponent> Components,\n SourceLocation RParenLoc);\n ExprResult ActOnBuiltinOffsetOf(Scope *S,\n SourceLocation BuiltinLoc,\n SourceLocation TypeLoc,\n ParsedType ParsedArgTy,\n ArrayRef<OffsetOfComponent> Components,\n SourceLocation RParenLoc);\n\n // __builtin_choose_expr(constExpr, expr1, expr2)\n ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,\n Expr *CondExpr, Expr *LHSExpr,\n Expr *RHSExpr, SourceLocation RPLoc);\n\n // __builtin_va_arg(expr, type)\n ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty,\n SourceLocation RPLoc);\n ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E,\n TypeSourceInfo *TInfo, SourceLocation RPLoc);\n\n // __builtin_LINE(), __builtin_FUNCTION(), __builtin_FILE(),\n // __builtin_COLUMN()\n ExprResult ActOnSourceLocExpr(SourceLocExpr::IdentKind Kind,\n SourceLocation BuiltinLoc,\n SourceLocation RPLoc);\n\n // Build a potentially resolved SourceLocExpr.\n ExprResult BuildSourceLocExpr(SourceLocExpr::IdentKind Kind,\n SourceLocation BuiltinLoc, SourceLocation RPLoc,\n DeclContext *ParentContext);\n\n // __null\n ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc);\n\n bool CheckCaseExpression(Expr *E);\n\n /// Describes the result of an \"if-exists\" condition check.\n enum IfExistsResult {\n /// The symbol exists.\n IER_Exists,\n\n /// The symbol does not exist.\n IER_DoesNotExist,\n\n /// The name is a dependent name, so the results will differ\n /// from one instantiation to the next.\n IER_Dependent,\n\n /// An error occurred.\n IER_Error\n };\n\n IfExistsResult\n CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS,\n const DeclarationNameInfo &TargetNameInfo);\n\n IfExistsResult\n CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc,\n bool IsIfExists, CXXScopeSpec &SS,\n UnqualifiedId &Name);\n\n StmtResult BuildMSDependentExistsStmt(SourceLocation KeywordLoc,\n bool IsIfExists,\n NestedNameSpecifierLoc QualifierLoc,\n DeclarationNameInfo NameInfo,\n Stmt *Nested);\n StmtResult ActOnMSDependentExistsStmt(SourceLocation KeywordLoc,\n bool IsIfExists,\n CXXScopeSpec &SS, UnqualifiedId &Name,\n Stmt *Nested);\n\n //===------------------------- \"Block\" Extension ------------------------===//\n\n /// ActOnBlockStart - This callback is invoked when a block literal is\n /// started.\n void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope);\n\n /// ActOnBlockArguments - This callback allows processing of block arguments.\n /// If there are no arguments, this is still invoked.\n void ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,\n Scope *CurScope);\n\n /// ActOnBlockError - If there is an error parsing a block, this callback\n /// is invoked to pop the information about the block from the action impl.\n void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope);\n\n /// ActOnBlockStmtExpr - This is called when the body of a block statement\n /// literal was successfully completed. ^(int x){...}\n ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,\n Scope *CurScope);\n\n //===---------------------------- Clang Extensions ----------------------===//\n\n /// __builtin_convertvector(...)\n ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy,\n SourceLocation BuiltinLoc,\n SourceLocation RParenLoc);\n\n //===---------------------------- OpenCL Features -----------------------===//\n\n /// __builtin_astype(...)\n ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,\n SourceLocation BuiltinLoc,\n SourceLocation RParenLoc);\n\n //===---------------------------- C++ Features --------------------------===//\n\n // Act on C++ namespaces\n Decl *ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc,\n SourceLocation NamespaceLoc,\n SourceLocation IdentLoc, IdentifierInfo *Ident,\n SourceLocation LBrace,\n const ParsedAttributesView &AttrList,\n UsingDirectiveDecl *&UsingDecl);\n void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace);\n\n NamespaceDecl *getStdNamespace() const;\n NamespaceDecl *getOrCreateStdNamespace();\n\n NamespaceDecl *lookupStdExperimentalNamespace();\n\n CXXRecordDecl *getStdBadAlloc() const;\n EnumDecl *getStdAlignValT() const;\n\nprivate:\n // A cache representing if we've fully checked the various comparison category\n // types stored in ASTContext. The bit-index corresponds to the integer value\n // of a ComparisonCategoryType enumerator.\n llvm::SmallBitVector FullyCheckedComparisonCategories;\n\n ValueDecl *tryLookupCtorInitMemberDecl(CXXRecordDecl *ClassDecl,\n CXXScopeSpec &SS,\n ParsedType TemplateTypeTy,\n IdentifierInfo *MemberOrBase);\n\npublic:\n enum class ComparisonCategoryUsage {\n /// The '<=>' operator was used in an expression and a builtin operator\n /// was selected.\n OperatorInExpression,\n /// A defaulted 'operator<=>' needed the comparison category. This\n /// typically only applies to 'std::strong_ordering', due to the implicit\n /// fallback return value.\n DefaultedOperator,\n };\n\n /// Lookup the specified comparison category types in the standard\n /// library, an check the VarDecls possibly returned by the operator<=>\n /// builtins for that type.\n ///\n /// \\return The type of the comparison category type corresponding to the\n /// specified Kind, or a null type if an error occurs\n QualType CheckComparisonCategoryType(ComparisonCategoryType Kind,\n SourceLocation Loc,\n ComparisonCategoryUsage Usage);\n\n /// Tests whether Ty is an instance of std::initializer_list and, if\n /// it is and Element is not NULL, assigns the element type to Element.\n bool isStdInitializerList(QualType Ty, QualType *Element);\n\n /// Looks for the std::initializer_list template and instantiates it\n /// with Element, or emits an error if it's not found.\n ///\n /// \\returns The instantiated template, or null on error.\n QualType BuildStdInitializerList(QualType Element, SourceLocation Loc);\n\n /// Determine whether Ctor is an initializer-list constructor, as\n /// defined in [dcl.init.list]p2.\n bool isInitListConstructor(const FunctionDecl *Ctor);\n\n Decl *ActOnUsingDirective(Scope *CurScope, SourceLocation UsingLoc,\n SourceLocation NamespcLoc, CXXScopeSpec &SS,\n SourceLocation IdentLoc,\n IdentifierInfo *NamespcName,\n const ParsedAttributesView &AttrList);\n\n void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir);\n\n Decl *ActOnNamespaceAliasDef(Scope *CurScope,\n SourceLocation NamespaceLoc,\n SourceLocation AliasLoc,\n IdentifierInfo *Alias,\n CXXScopeSpec &SS,\n SourceLocation IdentLoc,\n IdentifierInfo *Ident);\n\n void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow);\n bool CheckUsingShadowDecl(UsingDecl *UD, NamedDecl *Target,\n const LookupResult &PreviousDecls,\n UsingShadowDecl *&PrevShadow);\n UsingShadowDecl *BuildUsingShadowDecl(Scope *S, UsingDecl *UD,\n NamedDecl *Target,\n UsingShadowDecl *PrevDecl);\n\n bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc,\n bool HasTypenameKeyword,\n const CXXScopeSpec &SS,\n SourceLocation NameLoc,\n const LookupResult &Previous);\n bool CheckUsingDeclQualifier(SourceLocation UsingLoc,\n bool HasTypename,\n const CXXScopeSpec &SS,\n const DeclarationNameInfo &NameInfo,\n SourceLocation NameLoc);\n\n NamedDecl *BuildUsingDeclaration(\n Scope *S, AccessSpecifier AS, SourceLocation UsingLoc,\n bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS,\n DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc,\n const ParsedAttributesView &AttrList, bool IsInstantiation);\n NamedDecl *BuildUsingPackDecl(NamedDecl *InstantiatedFrom,\n ArrayRef<NamedDecl *> Expansions);\n\n bool CheckInheritingConstructorUsingDecl(UsingDecl *UD);\n\n /// Given a derived-class using shadow declaration for a constructor and the\n /// correspnding base class constructor, find or create the implicit\n /// synthesized derived class constructor to use for this initialization.\n CXXConstructorDecl *\n findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor,\n ConstructorUsingShadowDecl *DerivedShadow);\n\n Decl *ActOnUsingDeclaration(Scope *CurScope, AccessSpecifier AS,\n SourceLocation UsingLoc,\n SourceLocation TypenameLoc, CXXScopeSpec &SS,\n UnqualifiedId &Name, SourceLocation EllipsisLoc,\n const ParsedAttributesView &AttrList);\n Decl *ActOnAliasDeclaration(Scope *CurScope, AccessSpecifier AS,\n MultiTemplateParamsArg TemplateParams,\n SourceLocation UsingLoc, UnqualifiedId &Name,\n const ParsedAttributesView &AttrList,\n TypeResult Type, Decl *DeclFromDeclSpec);\n\n /// BuildCXXConstructExpr - Creates a complete call to a constructor,\n /// including handling of its default argument expressions.\n ///\n /// \\param ConstructKind - a CXXConstructExpr::ConstructionKind\n ExprResult\n BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,\n NamedDecl *FoundDecl,\n CXXConstructorDecl *Constructor, MultiExprArg Exprs,\n bool HadMultipleCandidates, bool IsListInitialization,\n bool IsStdInitListInitialization,\n bool RequiresZeroInit, unsigned ConstructKind,\n SourceRange ParenRange);\n\n /// Build a CXXConstructExpr whose constructor has already been resolved if\n /// it denotes an inherited constructor.\n ExprResult\n BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,\n CXXConstructorDecl *Constructor, bool Elidable,\n MultiExprArg Exprs,\n bool HadMultipleCandidates, bool IsListInitialization,\n bool IsStdInitListInitialization,\n bool RequiresZeroInit, unsigned ConstructKind,\n SourceRange ParenRange);\n\n // FIXME: Can we remove this and have the above BuildCXXConstructExpr check if\n // the constructor can be elidable?\n ExprResult\n BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,\n NamedDecl *FoundDecl,\n CXXConstructorDecl *Constructor, bool Elidable,\n MultiExprArg Exprs, bool HadMultipleCandidates,\n bool IsListInitialization,\n bool IsStdInitListInitialization, bool RequiresZeroInit,\n unsigned ConstructKind, SourceRange ParenRange);\n\n ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field);\n\n\n /// Instantiate or parse a C++ default argument expression as necessary.\n /// Return true on error.\n bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,\n ParmVarDecl *Param);\n\n /// BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating\n /// the default expr if needed.\n ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc,\n FunctionDecl *FD,\n ParmVarDecl *Param);\n\n /// FinalizeVarWithDestructor - Prepare for calling destructor on the\n /// constructed variable.\n void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType);\n\n /// Helper class that collects exception specifications for\n /// implicitly-declared special member functions.\n class ImplicitExceptionSpecification {\n // Pointer to allow copying\n Sema *Self;\n // We order exception specifications thus:\n // noexcept is the most restrictive, but is only used in C++11.\n // throw() comes next.\n // Then a throw(collected exceptions)\n // Finally no specification, which is expressed as noexcept(false).\n // throw(...) is used instead if any called function uses it.\n ExceptionSpecificationType ComputedEST;\n llvm::SmallPtrSet<CanQualType, 4> ExceptionsSeen;\n SmallVector<QualType, 4> Exceptions;\n\n void ClearExceptions() {\n ExceptionsSeen.clear();\n Exceptions.clear();\n }\n\n public:\n explicit ImplicitExceptionSpecification(Sema &Self)\n : Self(&Self), ComputedEST(EST_BasicNoexcept) {\n if (!Self.getLangOpts().CPlusPlus11)\n ComputedEST = EST_DynamicNone;\n }\n\n /// Get the computed exception specification type.\n ExceptionSpecificationType getExceptionSpecType() const {\n assert(!isComputedNoexcept(ComputedEST) &&\n \"noexcept(expr) should not be a possible result\");\n return ComputedEST;\n }\n\n /// The number of exceptions in the exception specification.\n unsigned size() const { return Exceptions.size(); }\n\n /// The set of exceptions in the exception specification.\n const QualType *data() const { return Exceptions.data(); }\n\n /// Integrate another called method into the collected data.\n void CalledDecl(SourceLocation CallLoc, const CXXMethodDecl *Method);\n\n /// Integrate an invoked expression into the collected data.\n void CalledExpr(Expr *E) { CalledStmt(E); }\n\n /// Integrate an invoked statement into the collected data.\n void CalledStmt(Stmt *S);\n\n /// Overwrite an EPI's exception specification with this\n /// computed exception specification.\n FunctionProtoType::ExceptionSpecInfo getExceptionSpec() const {\n FunctionProtoType::ExceptionSpecInfo ESI;\n ESI.Type = getExceptionSpecType();\n if (ESI.Type == EST_Dynamic) {\n ESI.Exceptions = Exceptions;\n } else if (ESI.Type == EST_None) {\n /// C++11 [except.spec]p14:\n /// The exception-specification is noexcept(false) if the set of\n /// potential exceptions of the special member function contains \"any\"\n ESI.Type = EST_NoexceptFalse;\n ESI.NoexceptExpr = Self->ActOnCXXBoolLiteral(SourceLocation(),\n tok::kw_false).get();\n }\n return ESI;\n }\n };\n\n /// Evaluate the implicit exception specification for a defaulted\n /// special member function.\n void EvaluateImplicitExceptionSpec(SourceLocation Loc, FunctionDecl *FD);\n\n /// Check the given noexcept-specifier, convert its expression, and compute\n /// the appropriate ExceptionSpecificationType.\n ExprResult ActOnNoexceptSpec(SourceLocation NoexceptLoc, Expr *NoexceptExpr,\n ExceptionSpecificationType &EST);\n\n /// Check the given exception-specification and update the\n /// exception specification information with the results.\n void checkExceptionSpecification(bool IsTopLevel,\n ExceptionSpecificationType EST,\n ArrayRef<ParsedType> DynamicExceptions,\n ArrayRef<SourceRange> DynamicExceptionRanges,\n Expr *NoexceptExpr,\n SmallVectorImpl<QualType> &Exceptions,\n FunctionProtoType::ExceptionSpecInfo &ESI);\n\n /// Determine if we're in a case where we need to (incorrectly) eagerly\n /// parse an exception specification to work around a libstdc++ bug.\n bool isLibstdcxxEagerExceptionSpecHack(const Declarator &D);\n\n /// Add an exception-specification to the given member function\n /// (or member function template). The exception-specification was parsed\n /// after the method itself was declared.\n void actOnDelayedExceptionSpecification(Decl *Method,\n ExceptionSpecificationType EST,\n SourceRange SpecificationRange,\n ArrayRef<ParsedType> DynamicExceptions,\n ArrayRef<SourceRange> DynamicExceptionRanges,\n Expr *NoexceptExpr);\n\n class InheritedConstructorInfo;\n\n /// Determine if a special member function should have a deleted\n /// definition when it is defaulted.\n bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM,\n InheritedConstructorInfo *ICI = nullptr,\n bool Diagnose = false);\n\n /// Produce notes explaining why a defaulted function was defined as deleted.\n void DiagnoseDeletedDefaultedFunction(FunctionDecl *FD);\n\n /// Declare the implicit default constructor for the given class.\n ///\n /// \\param ClassDecl The class declaration into which the implicit\n /// default constructor will be added.\n ///\n /// \\returns The implicitly-declared default constructor.\n CXXConstructorDecl *DeclareImplicitDefaultConstructor(\n CXXRecordDecl *ClassDecl);\n\n /// DefineImplicitDefaultConstructor - Checks for feasibility of\n /// defining this constructor as the default constructor.\n void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,\n CXXConstructorDecl *Constructor);\n\n /// Declare the implicit destructor for the given class.\n ///\n /// \\param ClassDecl The class declaration into which the implicit\n /// destructor will be added.\n ///\n /// \\returns The implicitly-declared destructor.\n CXXDestructorDecl *DeclareImplicitDestructor(CXXRecordDecl *ClassDecl);\n\n /// DefineImplicitDestructor - Checks for feasibility of\n /// defining this destructor as the default destructor.\n void DefineImplicitDestructor(SourceLocation CurrentLocation,\n CXXDestructorDecl *Destructor);\n\n /// Build an exception spec for destructors that don't have one.\n ///\n /// C++11 says that user-defined destructors with no exception spec get one\n /// that looks as if the destructor was implicitly declared.\n void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor);\n\n /// Define the specified inheriting constructor.\n void DefineInheritingConstructor(SourceLocation UseLoc,\n CXXConstructorDecl *Constructor);\n\n /// Declare the implicit copy constructor for the given class.\n ///\n /// \\param ClassDecl The class declaration into which the implicit\n /// copy constructor will be added.\n ///\n /// \\returns The implicitly-declared copy constructor.\n CXXConstructorDecl *DeclareImplicitCopyConstructor(CXXRecordDecl *ClassDecl);\n\n /// DefineImplicitCopyConstructor - Checks for feasibility of\n /// defining this constructor as the copy constructor.\n void DefineImplicitCopyConstructor(SourceLocation CurrentLocation,\n CXXConstructorDecl *Constructor);\n\n /// Declare the implicit move constructor for the given class.\n ///\n /// \\param ClassDecl The Class declaration into which the implicit\n /// move constructor will be added.\n ///\n /// \\returns The implicitly-declared move constructor, or NULL if it wasn't\n /// declared.\n CXXConstructorDecl *DeclareImplicitMoveConstructor(CXXRecordDecl *ClassDecl);\n\n /// DefineImplicitMoveConstructor - Checks for feasibility of\n /// defining this constructor as the move constructor.\n void DefineImplicitMoveConstructor(SourceLocation CurrentLocation,\n CXXConstructorDecl *Constructor);\n\n /// Declare the implicit copy assignment operator for the given class.\n ///\n /// \\param ClassDecl The class declaration into which the implicit\n /// copy assignment operator will be added.\n ///\n /// \\returns The implicitly-declared copy assignment operator.\n CXXMethodDecl *DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl);\n\n /// Defines an implicitly-declared copy assignment operator.\n void DefineImplicitCopyAssignment(SourceLocation CurrentLocation,\n CXXMethodDecl *MethodDecl);\n\n /// Declare the implicit move assignment operator for the given class.\n ///\n /// \\param ClassDecl The Class declaration into which the implicit\n /// move assignment operator will be added.\n ///\n /// \\returns The implicitly-declared move assignment operator, or NULL if it\n /// wasn't declared.\n CXXMethodDecl *DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl);\n\n /// Defines an implicitly-declared move assignment operator.\n void DefineImplicitMoveAssignment(SourceLocation CurrentLocation,\n CXXMethodDecl *MethodDecl);\n\n /// Force the declaration of any implicitly-declared members of this\n /// class.\n void ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class);\n\n /// Check a completed declaration of an implicit special member.\n void CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD);\n\n /// Determine whether the given function is an implicitly-deleted\n /// special member function.\n bool isImplicitlyDeleted(FunctionDecl *FD);\n\n /// Check whether 'this' shows up in the type of a static member\n /// function after the (naturally empty) cv-qualifier-seq would be.\n ///\n /// \\returns true if an error occurred.\n bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method);\n\n /// Whether this' shows up in the exception specification of a static\n /// member function.\n bool checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method);\n\n /// Check whether 'this' shows up in the attributes of the given\n /// static member function.\n ///\n /// \\returns true if an error occurred.\n bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method);\n\n /// MaybeBindToTemporary - If the passed in expression has a record type with\n /// a non-trivial destructor, this will return CXXBindTemporaryExpr. Otherwise\n /// it simply returns the passed in expression.\n ExprResult MaybeBindToTemporary(Expr *E);\n\n /// Wrap the expression in a ConstantExpr if it is a potential immediate\n /// invocation.\n ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl);\n\n bool CompleteConstructorCall(CXXConstructorDecl *Constructor,\n QualType DeclInitType, MultiExprArg ArgsPtr,\n SourceLocation Loc,\n SmallVectorImpl<Expr *> &ConvertedArgs,\n bool AllowExplicit = false,\n bool IsListInitialization = false);\n\n ParsedType getInheritingConstructorName(CXXScopeSpec &SS,\n SourceLocation NameLoc,\n IdentifierInfo &Name);\n\n ParsedType getConstructorName(IdentifierInfo &II, SourceLocation NameLoc,\n Scope *S, CXXScopeSpec &SS,\n bool EnteringContext);\n ParsedType getDestructorName(SourceLocation TildeLoc,\n IdentifierInfo &II, SourceLocation NameLoc,\n Scope *S, CXXScopeSpec &SS,\n ParsedType ObjectType,\n bool EnteringContext);\n\n ParsedType getDestructorTypeForDecltype(const DeclSpec &DS,\n ParsedType ObjectType);\n\n // Checks that reinterpret casts don't have undefined behavior.\n void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType,\n bool IsDereference, SourceRange Range);\n\n /// ActOnCXXNamedCast - Parse\n /// {dynamic,static,reinterpret,const,addrspace}_cast's.\n ExprResult ActOnCXXNamedCast(SourceLocation OpLoc,\n tok::TokenKind Kind,\n SourceLocation LAngleBracketLoc,\n Declarator &D,\n SourceLocation RAngleBracketLoc,\n SourceLocation LParenLoc,\n Expr *E,\n SourceLocation RParenLoc);\n\n ExprResult BuildCXXNamedCast(SourceLocation OpLoc,\n tok::TokenKind Kind,\n TypeSourceInfo *Ty,\n Expr *E,\n SourceRange AngleBrackets,\n SourceRange Parens);\n\n ExprResult ActOnBuiltinBitCastExpr(SourceLocation KWLoc, Declarator &Dcl,\n ExprResult Operand,\n SourceLocation RParenLoc);\n\n ExprResult BuildBuiltinBitCastExpr(SourceLocation KWLoc, TypeSourceInfo *TSI,\n Expr *Operand, SourceLocation RParenLoc);\n\n ExprResult BuildCXXTypeId(QualType TypeInfoType,\n SourceLocation TypeidLoc,\n TypeSourceInfo *Operand,\n SourceLocation RParenLoc);\n ExprResult BuildCXXTypeId(QualType TypeInfoType,\n SourceLocation TypeidLoc,\n Expr *Operand,\n SourceLocation RParenLoc);\n\n /// ActOnCXXTypeid - Parse typeid( something ).\n ExprResult ActOnCXXTypeid(SourceLocation OpLoc,\n SourceLocation LParenLoc, bool isType,\n void *TyOrExpr,\n SourceLocation RParenLoc);\n\n ExprResult BuildCXXUuidof(QualType TypeInfoType,\n SourceLocation TypeidLoc,\n TypeSourceInfo *Operand,\n SourceLocation RParenLoc);\n ExprResult BuildCXXUuidof(QualType TypeInfoType,\n SourceLocation TypeidLoc,\n Expr *Operand,\n SourceLocation RParenLoc);\n\n /// ActOnCXXUuidof - Parse __uuidof( something ).\n ExprResult ActOnCXXUuidof(SourceLocation OpLoc,\n SourceLocation LParenLoc, bool isType,\n void *TyOrExpr,\n SourceLocation RParenLoc);\n\n /// Handle a C++1z fold-expression: ( expr op ... op expr ).\n ExprResult ActOnCXXFoldExpr(Scope *S, SourceLocation LParenLoc, Expr *LHS,\n tok::TokenKind Operator,\n SourceLocation EllipsisLoc, Expr *RHS,\n SourceLocation RParenLoc);\n ExprResult BuildCXXFoldExpr(UnresolvedLookupExpr *Callee,\n SourceLocation LParenLoc, Expr *LHS,\n BinaryOperatorKind Operator,\n SourceLocation EllipsisLoc, Expr *RHS,\n SourceLocation RParenLoc,\n Optional<unsigned> NumExpansions);\n ExprResult BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,\n BinaryOperatorKind Operator);\n\n //// ActOnCXXThis - Parse 'this' pointer.\n ExprResult ActOnCXXThis(SourceLocation loc);\n\n /// Build a CXXThisExpr and mark it referenced in the current context.\n Expr *BuildCXXThisExpr(SourceLocation Loc, QualType Type, bool IsImplicit);\n void MarkThisReferenced(CXXThisExpr *This);\n\n /// Try to retrieve the type of the 'this' pointer.\n ///\n /// \\returns The type of 'this', if possible. Otherwise, returns a NULL type.\n QualType getCurrentThisType();\n\n /// When non-NULL, the C++ 'this' expression is allowed despite the\n /// current context not being a non-static member function. In such cases,\n /// this provides the type used for 'this'.\n QualType CXXThisTypeOverride;\n\n /// RAII object used to temporarily allow the C++ 'this' expression\n /// to be used, with the given qualifiers on the current class type.\n class CXXThisScopeRAII {\n Sema &S;\n QualType OldCXXThisTypeOverride;\n bool Enabled;\n\n public:\n /// Introduce a new scope where 'this' may be allowed (when enabled),\n /// using the given declaration (which is either a class template or a\n /// class) along with the given qualifiers.\n /// along with the qualifiers placed on '*this'.\n CXXThisScopeRAII(Sema &S, Decl *ContextDecl, Qualifiers CXXThisTypeQuals,\n bool Enabled = true);\n\n ~CXXThisScopeRAII();\n };\n\n /// Make sure the value of 'this' is actually available in the current\n /// context, if it is a potentially evaluated context.\n ///\n /// \\param Loc The location at which the capture of 'this' occurs.\n ///\n /// \\param Explicit Whether 'this' is explicitly captured in a lambda\n /// capture list.\n ///\n /// \\param FunctionScopeIndexToStopAt If non-null, it points to the index\n /// of the FunctionScopeInfo stack beyond which we do not attempt to capture.\n /// This is useful when enclosing lambdas must speculatively capture\n /// 'this' that may or may not be used in certain specializations of\n /// a nested generic lambda (depending on whether the name resolves to\n /// a non-static member function or a static function).\n /// \\return returns 'true' if failed, 'false' if success.\n bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit = false,\n bool BuildAndDiagnose = true,\n const unsigned *const FunctionScopeIndexToStopAt = nullptr,\n bool ByCopy = false);\n\n /// Determine whether the given type is the type of *this that is used\n /// outside of the body of a member function for a type that is currently\n /// being defined.\n bool isThisOutsideMemberFunctionBody(QualType BaseType);\n\n /// ActOnCXXBoolLiteral - Parse {true,false} literals.\n ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind);\n\n\n /// ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.\n ExprResult ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind);\n\n ExprResult\n ActOnObjCAvailabilityCheckExpr(llvm::ArrayRef<AvailabilitySpec> AvailSpecs,\n SourceLocation AtLoc, SourceLocation RParen);\n\n /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.\n ExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc);\n\n //// ActOnCXXThrow - Parse throw expressions.\n ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr);\n ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex,\n bool IsThrownVarInScope);\n bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E);\n\n /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.\n /// Can be interpreted either as function-style casting (\"int(x)\")\n /// or class type construction (\"ClassType(x,y,z)\")\n /// or creation of a value-initialized type (\"int()\").\n ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep,\n SourceLocation LParenOrBraceLoc,\n MultiExprArg Exprs,\n SourceLocation RParenOrBraceLoc,\n bool ListInitialization);\n\n ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type,\n SourceLocation LParenLoc,\n MultiExprArg Exprs,\n SourceLocation RParenLoc,\n bool ListInitialization);\n\n /// ActOnCXXNew - Parsed a C++ 'new' expression.\n ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,\n SourceLocation PlacementLParen,\n MultiExprArg PlacementArgs,\n SourceLocation PlacementRParen,\n SourceRange TypeIdParens, Declarator &D,\n Expr *Initializer);\n ExprResult BuildCXXNew(SourceRange Range, bool UseGlobal,\n SourceLocation PlacementLParen,\n MultiExprArg PlacementArgs,\n SourceLocation PlacementRParen,\n SourceRange TypeIdParens,\n QualType AllocType,\n TypeSourceInfo *AllocTypeInfo,\n Optional<Expr *> ArraySize,\n SourceRange DirectInitRange,\n Expr *Initializer);\n\n /// Determine whether \\p FD is an aligned allocation or deallocation\n /// function that is unavailable.\n bool isUnavailableAlignedAllocationFunction(const FunctionDecl &FD) const;\n\n /// Produce diagnostics if \\p FD is an aligned allocation or deallocation\n /// function that is unavailable.\n void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD,\n SourceLocation Loc);\n\n bool CheckAllocatedType(QualType AllocType, SourceLocation Loc,\n SourceRange R);\n\n /// The scope in which to find allocation functions.\n enum AllocationFunctionScope {\n /// Only look for allocation functions in the global scope.\n AFS_Global,\n /// Only look for allocation functions in the scope of the\n /// allocated class.\n AFS_Class,\n /// Look for allocation functions in both the global scope\n /// and in the scope of the allocated class.\n AFS_Both\n };\n\n /// Finds the overloads of operator new and delete that are appropriate\n /// for the allocation.\n bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,\n AllocationFunctionScope NewScope,\n AllocationFunctionScope DeleteScope,\n QualType AllocType, bool IsArray,\n bool &PassAlignment, MultiExprArg PlaceArgs,\n FunctionDecl *&OperatorNew,\n FunctionDecl *&OperatorDelete,\n bool Diagnose = true);\n void DeclareGlobalNewDelete();\n void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return,\n ArrayRef<QualType> Params);\n\n bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,\n DeclarationName Name, FunctionDecl* &Operator,\n bool Diagnose = true);\n FunctionDecl *FindUsualDeallocationFunction(SourceLocation StartLoc,\n bool CanProvideSize,\n bool Overaligned,\n DeclarationName Name);\n FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc,\n CXXRecordDecl *RD);\n\n /// ActOnCXXDelete - Parsed a C++ 'delete' expression\n ExprResult ActOnCXXDelete(SourceLocation StartLoc,\n bool UseGlobal, bool ArrayForm,\n Expr *Operand);\n void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc,\n bool IsDelete, bool CallCanBeVirtual,\n bool WarnOnNonAbstractTypes,\n SourceLocation DtorLoc);\n\n ExprResult ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation LParen,\n Expr *Operand, SourceLocation RParen);\n ExprResult BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand,\n SourceLocation RParen);\n\n /// Parsed one of the type trait support pseudo-functions.\n ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc,\n ArrayRef<ParsedType> Args,\n SourceLocation RParenLoc);\n ExprResult BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc,\n ArrayRef<TypeSourceInfo *> Args,\n SourceLocation RParenLoc);\n\n /// ActOnArrayTypeTrait - Parsed one of the binary type trait support\n /// pseudo-functions.\n ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT,\n SourceLocation KWLoc,\n ParsedType LhsTy,\n Expr *DimExpr,\n SourceLocation RParen);\n\n ExprResult BuildArrayTypeTrait(ArrayTypeTrait ATT,\n SourceLocation KWLoc,\n TypeSourceInfo *TSInfo,\n Expr *DimExpr,\n SourceLocation RParen);\n\n /// ActOnExpressionTrait - Parsed one of the unary type trait support\n /// pseudo-functions.\n ExprResult ActOnExpressionTrait(ExpressionTrait OET,\n SourceLocation KWLoc,\n Expr *Queried,\n SourceLocation RParen);\n\n ExprResult BuildExpressionTrait(ExpressionTrait OET,\n SourceLocation KWLoc,\n Expr *Queried,\n SourceLocation RParen);\n\n ExprResult ActOnStartCXXMemberReference(Scope *S,\n Expr *Base,\n SourceLocation OpLoc,\n tok::TokenKind OpKind,\n ParsedType &ObjectType,\n bool &MayBePseudoDestructor);\n\n ExprResult BuildPseudoDestructorExpr(Expr *Base,\n SourceLocation OpLoc,\n tok::TokenKind OpKind,\n const CXXScopeSpec &SS,\n TypeSourceInfo *ScopeType,\n SourceLocation CCLoc,\n SourceLocation TildeLoc,\n PseudoDestructorTypeStorage DestroyedType);\n\n ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,\n SourceLocation OpLoc,\n tok::TokenKind OpKind,\n CXXScopeSpec &SS,\n UnqualifiedId &FirstTypeName,\n SourceLocation CCLoc,\n SourceLocation TildeLoc,\n UnqualifiedId &SecondTypeName);\n\n ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,\n SourceLocation OpLoc,\n tok::TokenKind OpKind,\n SourceLocation TildeLoc,\n const DeclSpec& DS);\n\n /// MaybeCreateExprWithCleanups - If the current full-expression\n /// requires any cleanups, surround it with a ExprWithCleanups node.\n /// Otherwise, just returns the passed-in expression.\n Expr *MaybeCreateExprWithCleanups(Expr *SubExpr);\n Stmt *MaybeCreateStmtWithCleanups(Stmt *SubStmt);\n ExprResult MaybeCreateExprWithCleanups(ExprResult SubExpr);\n\n MaterializeTemporaryExpr *\n CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary,\n bool BoundToLvalueReference);\n\n ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue) {\n return ActOnFinishFullExpr(\n Expr, Expr ? Expr->getExprLoc() : SourceLocation(), DiscardedValue);\n }\n ExprResult ActOnFinishFullExpr(Expr *Expr, SourceLocation CC,\n bool DiscardedValue, bool IsConstexpr = false);\n StmtResult ActOnFinishFullStmt(Stmt *Stmt);\n\n // Marks SS invalid if it represents an incomplete type.\n bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC);\n\n DeclContext *computeDeclContext(QualType T);\n DeclContext *computeDeclContext(const CXXScopeSpec &SS,\n bool EnteringContext = false);\n bool isDependentScopeSpecifier(const CXXScopeSpec &SS);\n CXXRecordDecl *getCurrentInstantiationOf(NestedNameSpecifier *NNS);\n\n /// The parser has parsed a global nested-name-specifier '::'.\n ///\n /// \\param CCLoc The location of the '::'.\n ///\n /// \\param SS The nested-name-specifier, which will be updated in-place\n /// to reflect the parsed nested-name-specifier.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc, CXXScopeSpec &SS);\n\n /// The parser has parsed a '__super' nested-name-specifier.\n ///\n /// \\param SuperLoc The location of the '__super' keyword.\n ///\n /// \\param ColonColonLoc The location of the '::'.\n ///\n /// \\param SS The nested-name-specifier, which will be updated in-place\n /// to reflect the parsed nested-name-specifier.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool ActOnSuperScopeSpecifier(SourceLocation SuperLoc,\n SourceLocation ColonColonLoc, CXXScopeSpec &SS);\n\n bool isAcceptableNestedNameSpecifier(const NamedDecl *SD,\n bool *CanCorrect = nullptr);\n NamedDecl *FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS);\n\n /// Keeps information about an identifier in a nested-name-spec.\n ///\n struct NestedNameSpecInfo {\n /// The type of the object, if we're parsing nested-name-specifier in\n /// a member access expression.\n ParsedType ObjectType;\n\n /// The identifier preceding the '::'.\n IdentifierInfo *Identifier;\n\n /// The location of the identifier.\n SourceLocation IdentifierLoc;\n\n /// The location of the '::'.\n SourceLocation CCLoc;\n\n /// Creates info object for the most typical case.\n NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc,\n SourceLocation ColonColonLoc, ParsedType ObjectType = ParsedType())\n : ObjectType(ObjectType), Identifier(II), IdentifierLoc(IdLoc),\n CCLoc(ColonColonLoc) {\n }\n\n NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc,\n SourceLocation ColonColonLoc, QualType ObjectType)\n : ObjectType(ParsedType::make(ObjectType)), Identifier(II),\n IdentifierLoc(IdLoc), CCLoc(ColonColonLoc) {\n }\n };\n\n bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS,\n NestedNameSpecInfo &IdInfo);\n\n bool BuildCXXNestedNameSpecifier(Scope *S,\n NestedNameSpecInfo &IdInfo,\n bool EnteringContext,\n CXXScopeSpec &SS,\n NamedDecl *ScopeLookupResult,\n bool ErrorRecoveryLookup,\n bool *IsCorrectedToColon = nullptr,\n bool OnlyNamespace = false);\n\n /// The parser has parsed a nested-name-specifier 'identifier::'.\n ///\n /// \\param S The scope in which this nested-name-specifier occurs.\n ///\n /// \\param IdInfo Parser information about an identifier in the\n /// nested-name-spec.\n ///\n /// \\param EnteringContext Whether we're entering the context nominated by\n /// this nested-name-specifier.\n ///\n /// \\param SS The nested-name-specifier, which is both an input\n /// parameter (the nested-name-specifier before this type) and an\n /// output parameter (containing the full nested-name-specifier,\n /// including this new type).\n ///\n /// \\param ErrorRecoveryLookup If true, then this method is called to improve\n /// error recovery. In this case do not emit error message.\n ///\n /// \\param IsCorrectedToColon If not null, suggestions to replace '::' -> ':'\n /// are allowed. The bool value pointed by this parameter is set to 'true'\n /// if the identifier is treated as if it was followed by ':', not '::'.\n ///\n /// \\param OnlyNamespace If true, only considers namespaces in lookup.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool ActOnCXXNestedNameSpecifier(Scope *S,\n NestedNameSpecInfo &IdInfo,\n bool EnteringContext,\n CXXScopeSpec &SS,\n bool ErrorRecoveryLookup = false,\n bool *IsCorrectedToColon = nullptr,\n bool OnlyNamespace = false);\n\n ExprResult ActOnDecltypeExpression(Expr *E);\n\n bool ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS,\n const DeclSpec &DS,\n SourceLocation ColonColonLoc);\n\n bool IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS,\n NestedNameSpecInfo &IdInfo,\n bool EnteringContext);\n\n /// The parser has parsed a nested-name-specifier\n /// 'template[opt] template-name < template-args >::'.\n ///\n /// \\param S The scope in which this nested-name-specifier occurs.\n ///\n /// \\param SS The nested-name-specifier, which is both an input\n /// parameter (the nested-name-specifier before this type) and an\n /// output parameter (containing the full nested-name-specifier,\n /// including this new type).\n ///\n /// \\param TemplateKWLoc the location of the 'template' keyword, if any.\n /// \\param TemplateName the template name.\n /// \\param TemplateNameLoc The location of the template name.\n /// \\param LAngleLoc The location of the opening angle bracket ('<').\n /// \\param TemplateArgs The template arguments.\n /// \\param RAngleLoc The location of the closing angle bracket ('>').\n /// \\param CCLoc The location of the '::'.\n ///\n /// \\param EnteringContext Whether we're entering the context of the\n /// nested-name-specifier.\n ///\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool ActOnCXXNestedNameSpecifier(Scope *S,\n CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n TemplateTy TemplateName,\n SourceLocation TemplateNameLoc,\n SourceLocation LAngleLoc,\n ASTTemplateArgsPtr TemplateArgs,\n SourceLocation RAngleLoc,\n SourceLocation CCLoc,\n bool EnteringContext);\n\n /// Given a C++ nested-name-specifier, produce an annotation value\n /// that the parser can use later to reconstruct the given\n /// nested-name-specifier.\n ///\n /// \\param SS A nested-name-specifier.\n ///\n /// \\returns A pointer containing all of the information in the\n /// nested-name-specifier \\p SS.\n void *SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS);\n\n /// Given an annotation pointer for a nested-name-specifier, restore\n /// the nested-name-specifier structure.\n ///\n /// \\param Annotation The annotation pointer, produced by\n /// \\c SaveNestedNameSpecifierAnnotation().\n ///\n /// \\param AnnotationRange The source range corresponding to the annotation.\n ///\n /// \\param SS The nested-name-specifier that will be updated with the contents\n /// of the annotation pointer.\n void RestoreNestedNameSpecifierAnnotation(void *Annotation,\n SourceRange AnnotationRange,\n CXXScopeSpec &SS);\n\n bool ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS);\n\n /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global\n /// scope or nested-name-specifier) is parsed, part of a declarator-id.\n /// After this method is called, according to [C++ 3.4.3p3], names should be\n /// looked up in the declarator-id's scope, until the declarator is parsed and\n /// ActOnCXXExitDeclaratorScope is called.\n /// The 'SS' should be a non-empty valid CXXScopeSpec.\n bool ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS);\n\n /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously\n /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same\n /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.\n /// Used to indicate that names should revert to being looked up in the\n /// defining scope.\n void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS);\n\n /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an\n /// initializer for the declaration 'Dcl'.\n /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a\n /// static data member of class X, names should be looked up in the scope of\n /// class X.\n void ActOnCXXEnterDeclInitializer(Scope *S, Decl *Dcl);\n\n /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an\n /// initializer for the declaration 'Dcl'.\n void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl);\n\n /// Create a new lambda closure type.\n CXXRecordDecl *createLambdaClosureType(SourceRange IntroducerRange,\n TypeSourceInfo *Info,\n bool KnownDependent,\n LambdaCaptureDefault CaptureDefault);\n\n /// Start the definition of a lambda expression.\n CXXMethodDecl *startLambdaDefinition(CXXRecordDecl *Class,\n SourceRange IntroducerRange,\n TypeSourceInfo *MethodType,\n SourceLocation EndLoc,\n ArrayRef<ParmVarDecl *> Params,\n ConstexprSpecKind ConstexprKind,\n Expr *TrailingRequiresClause);\n\n /// Number lambda for linkage purposes if necessary.\n void handleLambdaNumbering(\n CXXRecordDecl *Class, CXXMethodDecl *Method,\n Optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling = None);\n\n /// Endow the lambda scope info with the relevant properties.\n void buildLambdaScope(sema::LambdaScopeInfo *LSI,\n CXXMethodDecl *CallOperator,\n SourceRange IntroducerRange,\n LambdaCaptureDefault CaptureDefault,\n SourceLocation CaptureDefaultLoc,\n bool ExplicitParams,\n bool ExplicitResultType,\n bool Mutable);\n\n /// Perform initialization analysis of the init-capture and perform\n /// any implicit conversions such as an lvalue-to-rvalue conversion if\n /// not being used to initialize a reference.\n ParsedType actOnLambdaInitCaptureInitialization(\n SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc,\n IdentifierInfo *Id, LambdaCaptureInitKind InitKind, Expr *&Init) {\n return ParsedType::make(buildLambdaInitCaptureInitialization(\n Loc, ByRef, EllipsisLoc, None, Id,\n InitKind != LambdaCaptureInitKind::CopyInit, Init));\n }\n QualType buildLambdaInitCaptureInitialization(\n SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc,\n Optional<unsigned> NumExpansions, IdentifierInfo *Id, bool DirectInit,\n Expr *&Init);\n\n /// Create a dummy variable within the declcontext of the lambda's\n /// call operator, for name lookup purposes for a lambda init capture.\n ///\n /// CodeGen handles emission of lambda captures, ignoring these dummy\n /// variables appropriately.\n VarDecl *createLambdaInitCaptureVarDecl(SourceLocation Loc,\n QualType InitCaptureType,\n SourceLocation EllipsisLoc,\n IdentifierInfo *Id,\n unsigned InitStyle, Expr *Init);\n\n /// Add an init-capture to a lambda scope.\n void addInitCapture(sema::LambdaScopeInfo *LSI, VarDecl *Var);\n\n /// Note that we have finished the explicit captures for the\n /// given lambda.\n void finishLambdaExplicitCaptures(sema::LambdaScopeInfo *LSI);\n\n /// \\brief This is called after parsing the explicit template parameter list\n /// on a lambda (if it exists) in C++2a.\n void ActOnLambdaExplicitTemplateParameterList(SourceLocation LAngleLoc,\n ArrayRef<NamedDecl *> TParams,\n SourceLocation RAngleLoc,\n ExprResult RequiresClause);\n\n /// Introduce the lambda parameters into scope.\n void addLambdaParameters(\n ArrayRef<LambdaIntroducer::LambdaCapture> Captures,\n CXXMethodDecl *CallOperator, Scope *CurScope);\n\n /// Deduce a block or lambda's return type based on the return\n /// statements present in the body.\n void deduceClosureReturnType(sema::CapturingScopeInfo &CSI);\n\n /// ActOnStartOfLambdaDefinition - This is called just before we start\n /// parsing the body of a lambda; it analyzes the explicit captures and\n /// arguments, and sets up various data-structures for the body of the\n /// lambda.\n void ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,\n Declarator &ParamInfo, Scope *CurScope);\n\n /// ActOnLambdaError - If there is an error parsing a lambda, this callback\n /// is invoked to pop the information about the lambda.\n void ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope,\n bool IsInstantiation = false);\n\n /// ActOnLambdaExpr - This is called when the body of a lambda expression\n /// was successfully completed.\n ExprResult ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body,\n Scope *CurScope);\n\n /// Does copying/destroying the captured variable have side effects?\n bool CaptureHasSideEffects(const sema::Capture &From);\n\n /// Diagnose if an explicit lambda capture is unused. Returns true if a\n /// diagnostic is emitted.\n bool DiagnoseUnusedLambdaCapture(SourceRange CaptureRange,\n const sema::Capture &From);\n\n /// Build a FieldDecl suitable to hold the given capture.\n FieldDecl *BuildCaptureField(RecordDecl *RD, const sema::Capture &Capture);\n\n /// Initialize the given capture with a suitable expression.\n ExprResult BuildCaptureInit(const sema::Capture &Capture,\n SourceLocation ImplicitCaptureLoc,\n bool IsOpenMPMapping = false);\n\n /// Complete a lambda-expression having processed and attached the\n /// lambda body.\n ExprResult BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc,\n sema::LambdaScopeInfo *LSI);\n\n /// Get the return type to use for a lambda's conversion function(s) to\n /// function pointer type, given the type of the call operator.\n QualType\n getLambdaConversionFunctionResultType(const FunctionProtoType *CallOpType,\n CallingConv CC);\n\n /// Define the \"body\" of the conversion from a lambda object to a\n /// function pointer.\n ///\n /// This routine doesn't actually define a sensible body; rather, it fills\n /// in the initialization expression needed to copy the lambda object into\n /// the block, and IR generation actually generates the real body of the\n /// block pointer conversion.\n void DefineImplicitLambdaToFunctionPointerConversion(\n SourceLocation CurrentLoc, CXXConversionDecl *Conv);\n\n /// Define the \"body\" of the conversion from a lambda object to a\n /// block pointer.\n ///\n /// This routine doesn't actually define a sensible body; rather, it fills\n /// in the initialization expression needed to copy the lambda object into\n /// the block, and IR generation actually generates the real body of the\n /// block pointer conversion.\n void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc,\n CXXConversionDecl *Conv);\n\n ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation,\n SourceLocation ConvLocation,\n CXXConversionDecl *Conv,\n Expr *Src);\n\n /// Check whether the given expression is a valid constraint expression.\n /// A diagnostic is emitted if it is not, false is returned, and\n /// PossibleNonPrimary will be set to true if the failure might be due to a\n /// non-primary expression being used as an atomic constraint.\n bool CheckConstraintExpression(const Expr *CE, Token NextToken = Token(),\n bool *PossibleNonPrimary = nullptr,\n bool IsTrailingRequiresClause = false);\n\nprivate:\n /// Caches pairs of template-like decls whose associated constraints were\n /// checked for subsumption and whether or not the first's constraints did in\n /// fact subsume the second's.\n llvm::DenseMap<std::pair<NamedDecl *, NamedDecl *>, bool> SubsumptionCache;\n /// Caches the normalized associated constraints of declarations (concepts or\n /// constrained declarations). If an error occurred while normalizing the\n /// associated constraints of the template or concept, nullptr will be cached\n /// here.\n llvm::DenseMap<NamedDecl *, NormalizedConstraint *>\n NormalizationCache;\n\n llvm::ContextualFoldingSet<ConstraintSatisfaction, const ASTContext &>\n SatisfactionCache;\n\npublic:\n const NormalizedConstraint *\n getNormalizedAssociatedConstraints(\n NamedDecl *ConstrainedDecl, ArrayRef<const Expr *> AssociatedConstraints);\n\n /// \\brief Check whether the given declaration's associated constraints are\n /// at least as constrained than another declaration's according to the\n /// partial ordering of constraints.\n ///\n /// \\param Result If no error occurred, receives the result of true if D1 is\n /// at least constrained than D2, and false otherwise.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool IsAtLeastAsConstrained(NamedDecl *D1, ArrayRef<const Expr *> AC1,\n NamedDecl *D2, ArrayRef<const Expr *> AC2,\n bool &Result);\n\n /// If D1 was not at least as constrained as D2, but would've been if a pair\n /// of atomic constraints involved had been declared in a concept and not\n /// repeated in two separate places in code.\n /// \\returns true if such a diagnostic was emitted, false otherwise.\n bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1,\n ArrayRef<const Expr *> AC1, NamedDecl *D2, ArrayRef<const Expr *> AC2);\n\n /// \\brief Check whether the given list of constraint expressions are\n /// satisfied (as if in a 'conjunction') given template arguments.\n /// \\param Template the template-like entity that triggered the constraints\n /// check (either a concept or a constrained entity).\n /// \\param ConstraintExprs a list of constraint expressions, treated as if\n /// they were 'AND'ed together.\n /// \\param TemplateArgs the list of template arguments to substitute into the\n /// constraint expression.\n /// \\param TemplateIDRange The source range of the template id that\n /// caused the constraints check.\n /// \\param Satisfaction if true is returned, will contain details of the\n /// satisfaction, with enough information to diagnose an unsatisfied\n /// expression.\n /// \\returns true if an error occurred and satisfaction could not be checked,\n /// false otherwise.\n bool CheckConstraintSatisfaction(\n const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs,\n ArrayRef<TemplateArgument> TemplateArgs,\n SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction);\n\n /// \\brief Check whether the given non-dependent constraint expression is\n /// satisfied. Returns false and updates Satisfaction with the satisfaction\n /// verdict if successful, emits a diagnostic and returns true if an error\n /// occured and satisfaction could not be determined.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool CheckConstraintSatisfaction(const Expr *ConstraintExpr,\n ConstraintSatisfaction &Satisfaction);\n\n /// Check whether the given function decl's trailing requires clause is\n /// satisfied, if any. Returns false and updates Satisfaction with the\n /// satisfaction verdict if successful, emits a diagnostic and returns true if\n /// an error occured and satisfaction could not be determined.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool CheckFunctionConstraints(const FunctionDecl *FD,\n ConstraintSatisfaction &Satisfaction,\n SourceLocation UsageLoc = SourceLocation());\n\n\n /// \\brief Ensure that the given template arguments satisfy the constraints\n /// associated with the given template, emitting a diagnostic if they do not.\n ///\n /// \\param Template The template to which the template arguments are being\n /// provided.\n ///\n /// \\param TemplateArgs The converted, canonicalized template arguments.\n ///\n /// \\param TemplateIDRange The source range of the template id that\n /// caused the constraints check.\n ///\n /// \\returns true if the constrains are not satisfied or could not be checked\n /// for satisfaction, false if the constraints are satisfied.\n bool EnsureTemplateArgumentListConstraints(TemplateDecl *Template,\n ArrayRef<TemplateArgument> TemplateArgs,\n SourceRange TemplateIDRange);\n\n /// \\brief Emit diagnostics explaining why a constraint expression was deemed\n /// unsatisfied.\n /// \\param First whether this is the first time an unsatisfied constraint is\n /// diagnosed for this error.\n void\n DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction,\n bool First = true);\n\n /// \\brief Emit diagnostics explaining why a constraint expression was deemed\n /// unsatisfied.\n void\n DiagnoseUnsatisfiedConstraint(const ASTConstraintSatisfaction &Satisfaction,\n bool First = true);\n\n // ParseObjCStringLiteral - Parse Objective-C string literals.\n ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,\n ArrayRef<Expr *> Strings);\n\n ExprResult BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S);\n\n /// BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the\n /// numeric literal expression. Type of the expression will be \"NSNumber *\"\n /// or \"id\" if NSNumber is unavailable.\n ExprResult BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number);\n ExprResult ActOnObjCBoolLiteral(SourceLocation AtLoc, SourceLocation ValueLoc,\n bool Value);\n ExprResult BuildObjCArrayLiteral(SourceRange SR, MultiExprArg Elements);\n\n /// BuildObjCBoxedExpr - builds an ObjCBoxedExpr AST node for the\n /// '@' prefixed parenthesized expression. The type of the expression will\n /// either be \"NSNumber *\", \"NSString *\" or \"NSValue *\" depending on the type\n /// of ValueType, which is allowed to be a built-in numeric type, \"char *\",\n /// \"const char *\" or C structure with attribute 'objc_boxable'.\n ExprResult BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr);\n\n ExprResult BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr,\n Expr *IndexExpr,\n ObjCMethodDecl *getterMethod,\n ObjCMethodDecl *setterMethod);\n\n ExprResult BuildObjCDictionaryLiteral(SourceRange SR,\n MutableArrayRef<ObjCDictionaryElement> Elements);\n\n ExprResult BuildObjCEncodeExpression(SourceLocation AtLoc,\n TypeSourceInfo *EncodedTypeInfo,\n SourceLocation RParenLoc);\n ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl,\n CXXConversionDecl *Method,\n bool HadMultipleCandidates);\n\n ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,\n SourceLocation EncodeLoc,\n SourceLocation LParenLoc,\n ParsedType Ty,\n SourceLocation RParenLoc);\n\n /// ParseObjCSelectorExpression - Build selector expression for \\@selector\n ExprResult ParseObjCSelectorExpression(Selector Sel,\n SourceLocation AtLoc,\n SourceLocation SelLoc,\n SourceLocation LParenLoc,\n SourceLocation RParenLoc,\n bool WarnMultipleSelectors);\n\n /// ParseObjCProtocolExpression - Build protocol expression for \\@protocol\n ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName,\n SourceLocation AtLoc,\n SourceLocation ProtoLoc,\n SourceLocation LParenLoc,\n SourceLocation ProtoIdLoc,\n SourceLocation RParenLoc);\n\n //===--------------------------------------------------------------------===//\n // C++ Declarations\n //\n Decl *ActOnStartLinkageSpecification(Scope *S,\n SourceLocation ExternLoc,\n Expr *LangStr,\n SourceLocation LBraceLoc);\n Decl *ActOnFinishLinkageSpecification(Scope *S,\n Decl *LinkageSpec,\n SourceLocation RBraceLoc);\n\n\n //===--------------------------------------------------------------------===//\n // C++ Classes\n //\n CXXRecordDecl *getCurrentClass(Scope *S, const CXXScopeSpec *SS);\n bool isCurrentClassName(const IdentifierInfo &II, Scope *S,\n const CXXScopeSpec *SS = nullptr);\n bool isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS);\n\n bool ActOnAccessSpecifier(AccessSpecifier Access, SourceLocation ASLoc,\n SourceLocation ColonLoc,\n const ParsedAttributesView &Attrs);\n\n NamedDecl *ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS,\n Declarator &D,\n MultiTemplateParamsArg TemplateParameterLists,\n Expr *BitfieldWidth, const VirtSpecifiers &VS,\n InClassInitStyle InitStyle);\n\n void ActOnStartCXXInClassMemberInitializer();\n void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl,\n SourceLocation EqualLoc,\n Expr *Init);\n\n MemInitResult ActOnMemInitializer(Decl *ConstructorD,\n Scope *S,\n CXXScopeSpec &SS,\n IdentifierInfo *MemberOrBase,\n ParsedType TemplateTypeTy,\n const DeclSpec &DS,\n SourceLocation IdLoc,\n SourceLocation LParenLoc,\n ArrayRef<Expr *> Args,\n SourceLocation RParenLoc,\n SourceLocation EllipsisLoc);\n\n MemInitResult ActOnMemInitializer(Decl *ConstructorD,\n Scope *S,\n CXXScopeSpec &SS,\n IdentifierInfo *MemberOrBase,\n ParsedType TemplateTypeTy,\n const DeclSpec &DS,\n SourceLocation IdLoc,\n Expr *InitList,\n SourceLocation EllipsisLoc);\n\n MemInitResult BuildMemInitializer(Decl *ConstructorD,\n Scope *S,\n CXXScopeSpec &SS,\n IdentifierInfo *MemberOrBase,\n ParsedType TemplateTypeTy,\n const DeclSpec &DS,\n SourceLocation IdLoc,\n Expr *Init,\n SourceLocation EllipsisLoc);\n\n MemInitResult BuildMemberInitializer(ValueDecl *Member,\n Expr *Init,\n SourceLocation IdLoc);\n\n MemInitResult BuildBaseInitializer(QualType BaseType,\n TypeSourceInfo *BaseTInfo,\n Expr *Init,\n CXXRecordDecl *ClassDecl,\n SourceLocation EllipsisLoc);\n\n MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo,\n Expr *Init,\n CXXRecordDecl *ClassDecl);\n\n bool SetDelegatingInitializer(CXXConstructorDecl *Constructor,\n CXXCtorInitializer *Initializer);\n\n bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors,\n ArrayRef<CXXCtorInitializer *> Initializers = None);\n\n void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation);\n\n\n /// MarkBaseAndMemberDestructorsReferenced - Given a record decl,\n /// mark all the non-trivial destructors of its members and bases as\n /// referenced.\n void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc,\n CXXRecordDecl *Record);\n\n /// Mark destructors of virtual bases of this class referenced. In the Itanium\n /// C++ ABI, this is done when emitting a destructor for any non-abstract\n /// class. In the Microsoft C++ ABI, this is done any time a class's\n /// destructor is referenced.\n void MarkVirtualBaseDestructorsReferenced(\n SourceLocation Location, CXXRecordDecl *ClassDecl,\n llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases = nullptr);\n\n /// Do semantic checks to allow the complete destructor variant to be emitted\n /// when the destructor is defined in another translation unit. In the Itanium\n /// C++ ABI, destructor variants are emitted together. In the MS C++ ABI, they\n /// can be emitted in separate TUs. To emit the complete variant, run a subset\n /// of the checks performed when emitting a regular destructor.\n void CheckCompleteDestructorVariant(SourceLocation CurrentLocation,\n CXXDestructorDecl *Dtor);\n\n /// The list of classes whose vtables have been used within\n /// this translation unit, and the source locations at which the\n /// first use occurred.\n typedef std::pair<CXXRecordDecl*, SourceLocation> VTableUse;\n\n /// The list of vtables that are required but have not yet been\n /// materialized.\n SmallVector<VTableUse, 16> VTableUses;\n\n /// The set of classes whose vtables have been used within\n /// this translation unit, and a bit that will be true if the vtable is\n /// required to be emitted (otherwise, it should be emitted only if needed\n /// by code generation).\n llvm::DenseMap<CXXRecordDecl *, bool> VTablesUsed;\n\n /// Load any externally-stored vtable uses.\n void LoadExternalVTableUses();\n\n /// Note that the vtable for the given class was used at the\n /// given location.\n void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class,\n bool DefinitionRequired = false);\n\n /// Mark the exception specifications of all virtual member functions\n /// in the given class as needed.\n void MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,\n const CXXRecordDecl *RD);\n\n /// MarkVirtualMembersReferenced - Will mark all members of the given\n /// CXXRecordDecl referenced.\n void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD,\n bool ConstexprOnly = false);\n\n /// Define all of the vtables that have been used in this\n /// translation unit and reference any virtual members used by those\n /// vtables.\n ///\n /// \\returns true if any work was done, false otherwise.\n bool DefineUsedVTables();\n\n void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl);\n\n void ActOnMemInitializers(Decl *ConstructorDecl,\n SourceLocation ColonLoc,\n ArrayRef<CXXCtorInitializer*> MemInits,\n bool AnyErrors);\n\n /// Check class-level dllimport/dllexport attribute. The caller must\n /// ensure that referenceDLLExportedClassMethods is called some point later\n /// when all outer classes of Class are complete.\n void checkClassLevelDLLAttribute(CXXRecordDecl *Class);\n void checkClassLevelCodeSegAttribute(CXXRecordDecl *Class);\n\n void referenceDLLExportedClassMethods();\n\n void propagateDLLAttrToBaseClassTemplate(\n CXXRecordDecl *Class, Attr *ClassAttr,\n ClassTemplateSpecializationDecl *BaseTemplateSpec,\n SourceLocation BaseLoc);\n\n /// Add gsl::Pointer attribute to std::container::iterator\n /// \\param ND The declaration that introduces the name\n /// std::container::iterator. \\param UnderlyingRecord The record named by ND.\n void inferGslPointerAttribute(NamedDecl *ND, CXXRecordDecl *UnderlyingRecord);\n\n /// Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types.\n void inferGslOwnerPointerAttribute(CXXRecordDecl *Record);\n\n /// Add [[gsl::Pointer]] attributes for std:: types.\n void inferGslPointerAttribute(TypedefNameDecl *TD);\n\n void CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record);\n\n /// Check that the C++ class annoated with \"trivial_abi\" satisfies all the\n /// conditions that are needed for the attribute to have an effect.\n void checkIllFormedTrivialABIStruct(CXXRecordDecl &RD);\n\n void ActOnFinishCXXMemberSpecification(Scope *S, SourceLocation RLoc,\n Decl *TagDecl, SourceLocation LBrac,\n SourceLocation RBrac,\n const ParsedAttributesView &AttrList);\n void ActOnFinishCXXMemberDecls();\n void ActOnFinishCXXNonNestedClass();\n\n void ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param);\n unsigned ActOnReenterTemplateScope(Decl *Template,\n llvm::function_ref<Scope *()> EnterScope);\n void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record);\n void ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *Method);\n void ActOnDelayedCXXMethodParameter(Scope *S, Decl *Param);\n void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record);\n void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method);\n void ActOnFinishDelayedMemberInitializers(Decl *Record);\n void MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD,\n CachedTokens &Toks);\n void UnmarkAsLateParsedTemplate(FunctionDecl *FD);\n bool IsInsideALocalClassWithinATemplateFunction();\n\n Decl *ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc,\n Expr *AssertExpr,\n Expr *AssertMessageExpr,\n SourceLocation RParenLoc);\n Decl *BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc,\n Expr *AssertExpr,\n StringLiteral *AssertMessageExpr,\n SourceLocation RParenLoc,\n bool Failed);\n\n FriendDecl *CheckFriendTypeDecl(SourceLocation LocStart,\n SourceLocation FriendLoc,\n TypeSourceInfo *TSInfo);\n Decl *ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,\n MultiTemplateParamsArg TemplateParams);\n NamedDecl *ActOnFriendFunctionDecl(Scope *S, Declarator &D,\n MultiTemplateParamsArg TemplateParams);\n\n QualType CheckConstructorDeclarator(Declarator &D, QualType R,\n StorageClass& SC);\n void CheckConstructor(CXXConstructorDecl *Constructor);\n QualType CheckDestructorDeclarator(Declarator &D, QualType R,\n StorageClass& SC);\n bool CheckDestructor(CXXDestructorDecl *Destructor);\n void CheckConversionDeclarator(Declarator &D, QualType &R,\n StorageClass& SC);\n Decl *ActOnConversionDeclarator(CXXConversionDecl *Conversion);\n void CheckDeductionGuideDeclarator(Declarator &D, QualType &R,\n StorageClass &SC);\n void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD);\n\n void CheckExplicitlyDefaultedFunction(Scope *S, FunctionDecl *MD);\n\n bool CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD,\n CXXSpecialMember CSM);\n void CheckDelayedMemberExceptionSpecs();\n\n bool CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *MD,\n DefaultedComparisonKind DCK);\n void DeclareImplicitEqualityComparison(CXXRecordDecl *RD,\n FunctionDecl *Spaceship);\n void DefineDefaultedComparison(SourceLocation Loc, FunctionDecl *FD,\n DefaultedComparisonKind DCK);\n\n //===--------------------------------------------------------------------===//\n // C++ Derived Classes\n //\n\n /// ActOnBaseSpecifier - Parsed a base specifier\n CXXBaseSpecifier *CheckBaseSpecifier(CXXRecordDecl *Class,\n SourceRange SpecifierRange,\n bool Virtual, AccessSpecifier Access,\n TypeSourceInfo *TInfo,\n SourceLocation EllipsisLoc);\n\n BaseResult ActOnBaseSpecifier(Decl *classdecl,\n SourceRange SpecifierRange,\n ParsedAttributes &Attrs,\n bool Virtual, AccessSpecifier Access,\n ParsedType basetype,\n SourceLocation BaseLoc,\n SourceLocation EllipsisLoc);\n\n bool AttachBaseSpecifiers(CXXRecordDecl *Class,\n MutableArrayRef<CXXBaseSpecifier *> Bases);\n void ActOnBaseSpecifiers(Decl *ClassDecl,\n MutableArrayRef<CXXBaseSpecifier *> Bases);\n\n bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base);\n bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base,\n CXXBasePaths &Paths);\n\n // FIXME: I don't like this name.\n void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath);\n\n bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,\n SourceLocation Loc, SourceRange Range,\n CXXCastPath *BasePath = nullptr,\n bool IgnoreAccess = false);\n bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,\n unsigned InaccessibleBaseID,\n unsigned AmbiguousBaseConvID,\n SourceLocation Loc, SourceRange Range,\n DeclarationName Name,\n CXXCastPath *BasePath,\n bool IgnoreAccess = false);\n\n std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths);\n\n bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New,\n const CXXMethodDecl *Old);\n\n /// CheckOverridingFunctionReturnType - Checks whether the return types are\n /// covariant, according to C++ [class.virtual]p5.\n bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New,\n const CXXMethodDecl *Old);\n\n /// CheckOverridingFunctionExceptionSpec - Checks whether the exception\n /// spec is a subset of base spec.\n bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New,\n const CXXMethodDecl *Old);\n\n bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange);\n\n /// CheckOverrideControl - Check C++11 override control semantics.\n void CheckOverrideControl(NamedDecl *D);\n\n /// DiagnoseAbsenceOfOverrideControl - Diagnose if 'override' keyword was\n /// not used in the declaration of an overriding method.\n void DiagnoseAbsenceOfOverrideControl(NamedDecl *D, bool Inconsistent);\n\n /// CheckForFunctionMarkedFinal - Checks whether a virtual member function\n /// overrides a virtual member function marked 'final', according to\n /// C++11 [class.virtual]p4.\n bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New,\n const CXXMethodDecl *Old);\n\n\n //===--------------------------------------------------------------------===//\n // C++ Access Control\n //\n\n enum AccessResult {\n AR_accessible,\n AR_inaccessible,\n AR_dependent,\n AR_delayed\n };\n\n bool SetMemberAccessSpecifier(NamedDecl *MemberDecl,\n NamedDecl *PrevMemberDecl,\n AccessSpecifier LexicalAS);\n\n AccessResult CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E,\n DeclAccessPair FoundDecl);\n AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E,\n DeclAccessPair FoundDecl);\n AccessResult CheckAllocationAccess(SourceLocation OperatorLoc,\n SourceRange PlacementRange,\n CXXRecordDecl *NamingClass,\n DeclAccessPair FoundDecl,\n bool Diagnose = true);\n AccessResult CheckConstructorAccess(SourceLocation Loc,\n CXXConstructorDecl *D,\n DeclAccessPair FoundDecl,\n const InitializedEntity &Entity,\n bool IsCopyBindingRefToTemp = false);\n AccessResult CheckConstructorAccess(SourceLocation Loc,\n CXXConstructorDecl *D,\n DeclAccessPair FoundDecl,\n const InitializedEntity &Entity,\n const PartialDiagnostic &PDiag);\n AccessResult CheckDestructorAccess(SourceLocation Loc,\n CXXDestructorDecl *Dtor,\n const PartialDiagnostic &PDiag,\n QualType objectType = QualType());\n AccessResult CheckFriendAccess(NamedDecl *D);\n AccessResult CheckMemberAccess(SourceLocation UseLoc,\n CXXRecordDecl *NamingClass,\n DeclAccessPair Found);\n AccessResult\n CheckStructuredBindingMemberAccess(SourceLocation UseLoc,\n CXXRecordDecl *DecomposedClass,\n DeclAccessPair Field);\n AccessResult CheckMemberOperatorAccess(SourceLocation Loc,\n Expr *ObjectExpr,\n Expr *ArgExpr,\n DeclAccessPair FoundDecl);\n AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr,\n DeclAccessPair FoundDecl);\n AccessResult CheckBaseClassAccess(SourceLocation AccessLoc,\n QualType Base, QualType Derived,\n const CXXBasePath &Path,\n unsigned DiagID,\n bool ForceCheck = false,\n bool ForceUnprivileged = false);\n void CheckLookupAccess(const LookupResult &R);\n bool IsSimplyAccessible(NamedDecl *Decl, CXXRecordDecl *NamingClass,\n QualType BaseType);\n bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass,\n DeclAccessPair Found, QualType ObjectType,\n SourceLocation Loc,\n const PartialDiagnostic &Diag);\n bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass,\n DeclAccessPair Found,\n QualType ObjectType) {\n return isMemberAccessibleForDeletion(NamingClass, Found, ObjectType,\n SourceLocation(), PDiag());\n }\n\n void HandleDependentAccessCheck(const DependentDiagnostic &DD,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n void PerformDependentDiagnostics(const DeclContext *Pattern,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n void HandleDelayedAccessCheck(sema::DelayedDiagnostic &DD, Decl *Ctx);\n\n /// When true, access checking violations are treated as SFINAE\n /// failures rather than hard errors.\n bool AccessCheckingSFINAE;\n\n enum AbstractDiagSelID {\n AbstractNone = -1,\n AbstractReturnType,\n AbstractParamType,\n AbstractVariableType,\n AbstractFieldType,\n AbstractIvarType,\n AbstractSynthesizedIvarType,\n AbstractArrayType\n };\n\n bool isAbstractType(SourceLocation Loc, QualType T);\n bool RequireNonAbstractType(SourceLocation Loc, QualType T,\n TypeDiagnoser &Diagnoser);\n template <typename... Ts>\n bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID,\n const Ts &...Args) {\n BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);\n return RequireNonAbstractType(Loc, T, Diagnoser);\n }\n\n void DiagnoseAbstractType(const CXXRecordDecl *RD);\n\n //===--------------------------------------------------------------------===//\n // C++ Overloaded Operators [C++ 13.5]\n //\n\n bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl);\n\n bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl);\n\n //===--------------------------------------------------------------------===//\n // C++ Templates [C++ 14]\n //\n void FilterAcceptableTemplateNames(LookupResult &R,\n bool AllowFunctionTemplates = true,\n bool AllowDependent = true);\n bool hasAnyAcceptableTemplateNames(LookupResult &R,\n bool AllowFunctionTemplates = true,\n bool AllowDependent = true,\n bool AllowNonTemplateFunctions = false);\n /// Try to interpret the lookup result D as a template-name.\n ///\n /// \\param D A declaration found by name lookup.\n /// \\param AllowFunctionTemplates Whether function templates should be\n /// considered valid results.\n /// \\param AllowDependent Whether unresolved using declarations (that might\n /// name templates) should be considered valid results.\n static NamedDecl *getAsTemplateNameDecl(NamedDecl *D,\n bool AllowFunctionTemplates = true,\n bool AllowDependent = true);\n\n enum TemplateNameIsRequiredTag { TemplateNameIsRequired };\n /// Whether and why a template name is required in this lookup.\n class RequiredTemplateKind {\n public:\n /// Template name is required if TemplateKWLoc is valid.\n RequiredTemplateKind(SourceLocation TemplateKWLoc = SourceLocation())\n : TemplateKW(TemplateKWLoc) {}\n /// Template name is unconditionally required.\n RequiredTemplateKind(TemplateNameIsRequiredTag) : TemplateKW() {}\n\n SourceLocation getTemplateKeywordLoc() const {\n return TemplateKW.getValueOr(SourceLocation());\n }\n bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }\n bool isRequired() const { return TemplateKW != SourceLocation(); }\n explicit operator bool() const { return isRequired(); }\n\n private:\n llvm::Optional<SourceLocation> TemplateKW;\n };\n\n enum class AssumedTemplateKind {\n /// This is not assumed to be a template name.\n None,\n /// This is assumed to be a template name because lookup found nothing.\n FoundNothing,\n /// This is assumed to be a template name because lookup found one or more\n /// functions (but no function templates).\n FoundFunctions,\n };\n bool LookupTemplateName(\n LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType,\n bool EnteringContext, bool &MemberOfUnknownSpecialization,\n RequiredTemplateKind RequiredTemplate = SourceLocation(),\n AssumedTemplateKind *ATK = nullptr, bool AllowTypoCorrection = true);\n\n TemplateNameKind isTemplateName(Scope *S,\n CXXScopeSpec &SS,\n bool hasTemplateKeyword,\n const UnqualifiedId &Name,\n ParsedType ObjectType,\n bool EnteringContext,\n TemplateTy &Template,\n bool &MemberOfUnknownSpecialization,\n bool Disambiguation = false);\n\n /// Try to resolve an undeclared template name as a type template.\n ///\n /// Sets II to the identifier corresponding to the template name, and updates\n /// Name to a corresponding (typo-corrected) type template name and TNK to\n /// the corresponding kind, if possible.\n void ActOnUndeclaredTypeTemplateName(Scope *S, TemplateTy &Name,\n TemplateNameKind &TNK,\n SourceLocation NameLoc,\n IdentifierInfo *&II);\n\n bool resolveAssumedTemplateNameAsType(Scope *S, TemplateName &Name,\n SourceLocation NameLoc,\n bool Diagnose = true);\n\n /// Determine whether a particular identifier might be the name in a C++1z\n /// deduction-guide declaration.\n bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name,\n SourceLocation NameLoc,\n ParsedTemplateTy *Template = nullptr);\n\n bool DiagnoseUnknownTemplateName(const IdentifierInfo &II,\n SourceLocation IILoc,\n Scope *S,\n const CXXScopeSpec *SS,\n TemplateTy &SuggestedTemplate,\n TemplateNameKind &SuggestedKind);\n\n bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation,\n NamedDecl *Instantiation,\n bool InstantiatedFromMember,\n const NamedDecl *Pattern,\n const NamedDecl *PatternDef,\n TemplateSpecializationKind TSK,\n bool Complain = true);\n\n void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl);\n TemplateDecl *AdjustDeclIfTemplate(Decl *&Decl);\n\n NamedDecl *ActOnTypeParameter(Scope *S, bool Typename,\n SourceLocation EllipsisLoc,\n SourceLocation KeyLoc,\n IdentifierInfo *ParamName,\n SourceLocation ParamNameLoc,\n unsigned Depth, unsigned Position,\n SourceLocation EqualLoc,\n ParsedType DefaultArg, bool HasTypeConstraint);\n\n bool ActOnTypeConstraint(const CXXScopeSpec &SS,\n TemplateIdAnnotation *TypeConstraint,\n TemplateTypeParmDecl *ConstrainedParameter,\n SourceLocation EllipsisLoc);\n\n bool AttachTypeConstraint(NestedNameSpecifierLoc NS,\n DeclarationNameInfo NameInfo,\n ConceptDecl *NamedConcept,\n const TemplateArgumentListInfo *TemplateArgs,\n TemplateTypeParmDecl *ConstrainedParameter,\n SourceLocation EllipsisLoc);\n\n bool AttachTypeConstraint(AutoTypeLoc TL,\n NonTypeTemplateParmDecl *ConstrainedParameter,\n SourceLocation EllipsisLoc);\n\n bool RequireStructuralType(QualType T, SourceLocation Loc);\n\n QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI,\n SourceLocation Loc);\n QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);\n\n NamedDecl *ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,\n unsigned Depth,\n unsigned Position,\n SourceLocation EqualLoc,\n Expr *DefaultArg);\n NamedDecl *ActOnTemplateTemplateParameter(Scope *S,\n SourceLocation TmpLoc,\n TemplateParameterList *Params,\n SourceLocation EllipsisLoc,\n IdentifierInfo *ParamName,\n SourceLocation ParamNameLoc,\n unsigned Depth,\n unsigned Position,\n SourceLocation EqualLoc,\n ParsedTemplateArgument DefaultArg);\n\n TemplateParameterList *\n ActOnTemplateParameterList(unsigned Depth,\n SourceLocation ExportLoc,\n SourceLocation TemplateLoc,\n SourceLocation LAngleLoc,\n ArrayRef<NamedDecl *> Params,\n SourceLocation RAngleLoc,\n Expr *RequiresClause);\n\n /// The context in which we are checking a template parameter list.\n enum TemplateParamListContext {\n TPC_ClassTemplate,\n TPC_VarTemplate,\n TPC_FunctionTemplate,\n TPC_ClassTemplateMember,\n TPC_FriendClassTemplate,\n TPC_FriendFunctionTemplate,\n TPC_FriendFunctionTemplateDefinition,\n TPC_TypeAliasTemplate\n };\n\n bool CheckTemplateParameterList(TemplateParameterList *NewParams,\n TemplateParameterList *OldParams,\n TemplateParamListContext TPC,\n SkipBodyInfo *SkipBody = nullptr);\n TemplateParameterList *MatchTemplateParametersToScopeSpecifier(\n SourceLocation DeclStartLoc, SourceLocation DeclLoc,\n const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId,\n ArrayRef<TemplateParameterList *> ParamLists,\n bool IsFriend, bool &IsMemberSpecialization, bool &Invalid,\n bool SuppressDiagnostic = false);\n\n DeclResult CheckClassTemplate(\n Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,\n CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc,\n const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams,\n AccessSpecifier AS, SourceLocation ModulePrivateLoc,\n SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists,\n TemplateParameterList **OuterTemplateParamLists,\n SkipBodyInfo *SkipBody = nullptr);\n\n TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg,\n QualType NTTPType,\n SourceLocation Loc);\n\n /// Get a template argument mapping the given template parameter to itself,\n /// e.g. for X in \\c template<int X>, this would return an expression template\n /// argument referencing X.\n TemplateArgumentLoc getIdentityTemplateArgumentLoc(NamedDecl *Param,\n SourceLocation Location);\n\n void translateTemplateArguments(const ASTTemplateArgsPtr &In,\n TemplateArgumentListInfo &Out);\n\n ParsedTemplateArgument ActOnTemplateTypeArgument(TypeResult ParsedType);\n\n void NoteAllFoundTemplates(TemplateName Name);\n\n QualType CheckTemplateIdType(TemplateName Template,\n SourceLocation TemplateLoc,\n TemplateArgumentListInfo &TemplateArgs);\n\n TypeResult\n ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,\n TemplateTy Template, IdentifierInfo *TemplateII,\n SourceLocation TemplateIILoc, SourceLocation LAngleLoc,\n ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc,\n bool IsCtorOrDtorName = false, bool IsClassName = false);\n\n /// Parsed an elaborated-type-specifier that refers to a template-id,\n /// such as \\c class T::template apply<U>.\n TypeResult ActOnTagTemplateIdType(TagUseKind TUK,\n TypeSpecifierType TagSpec,\n SourceLocation TagLoc,\n CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n TemplateTy TemplateD,\n SourceLocation TemplateLoc,\n SourceLocation LAngleLoc,\n ASTTemplateArgsPtr TemplateArgsIn,\n SourceLocation RAngleLoc);\n\n DeclResult ActOnVarTemplateSpecialization(\n Scope *S, Declarator &D, TypeSourceInfo *DI,\n SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams,\n StorageClass SC, bool IsPartialSpecialization);\n\n /// Get the specialization of the given variable template corresponding to\n /// the specified argument list, or a null-but-valid result if the arguments\n /// are dependent.\n DeclResult CheckVarTemplateId(VarTemplateDecl *Template,\n SourceLocation TemplateLoc,\n SourceLocation TemplateNameLoc,\n const TemplateArgumentListInfo &TemplateArgs);\n\n /// Form a reference to the specialization of the given variable template\n /// corresponding to the specified argument list, or a null-but-valid result\n /// if the arguments are dependent.\n ExprResult CheckVarTemplateId(const CXXScopeSpec &SS,\n const DeclarationNameInfo &NameInfo,\n VarTemplateDecl *Template,\n SourceLocation TemplateLoc,\n const TemplateArgumentListInfo *TemplateArgs);\n\n ExprResult\n CheckConceptTemplateId(const CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n const DeclarationNameInfo &ConceptNameInfo,\n NamedDecl *FoundDecl, ConceptDecl *NamedConcept,\n const TemplateArgumentListInfo *TemplateArgs);\n\n void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc);\n\n ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n LookupResult &R,\n bool RequiresADL,\n const TemplateArgumentListInfo *TemplateArgs);\n\n ExprResult BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n const DeclarationNameInfo &NameInfo,\n const TemplateArgumentListInfo *TemplateArgs);\n\n TemplateNameKind ActOnTemplateName(\n Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,\n const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext,\n TemplateTy &Template, bool AllowInjectedClassName = false);\n\n DeclResult ActOnClassTemplateSpecialization(\n Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,\n SourceLocation ModulePrivateLoc, CXXScopeSpec &SS,\n TemplateIdAnnotation &TemplateId, const ParsedAttributesView &Attr,\n MultiTemplateParamsArg TemplateParameterLists,\n SkipBodyInfo *SkipBody = nullptr);\n\n bool CheckTemplatePartialSpecializationArgs(SourceLocation Loc,\n TemplateDecl *PrimaryTemplate,\n unsigned NumExplicitArgs,\n ArrayRef<TemplateArgument> Args);\n void CheckTemplatePartialSpecialization(\n ClassTemplatePartialSpecializationDecl *Partial);\n void CheckTemplatePartialSpecialization(\n VarTemplatePartialSpecializationDecl *Partial);\n\n Decl *ActOnTemplateDeclarator(Scope *S,\n MultiTemplateParamsArg TemplateParameterLists,\n Declarator &D);\n\n bool\n CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,\n TemplateSpecializationKind NewTSK,\n NamedDecl *PrevDecl,\n TemplateSpecializationKind PrevTSK,\n SourceLocation PrevPtOfInstantiation,\n bool &SuppressNew);\n\n bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD,\n const TemplateArgumentListInfo &ExplicitTemplateArgs,\n LookupResult &Previous);\n\n bool CheckFunctionTemplateSpecialization(\n FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs,\n LookupResult &Previous, bool QualifiedFriend = false);\n bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous);\n void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous);\n\n DeclResult ActOnExplicitInstantiation(\n Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc,\n unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS,\n TemplateTy Template, SourceLocation TemplateNameLoc,\n SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs,\n SourceLocation RAngleLoc, const ParsedAttributesView &Attr);\n\n DeclResult ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc,\n SourceLocation TemplateLoc,\n unsigned TagSpec, SourceLocation KWLoc,\n CXXScopeSpec &SS, IdentifierInfo *Name,\n SourceLocation NameLoc,\n const ParsedAttributesView &Attr);\n\n DeclResult ActOnExplicitInstantiation(Scope *S,\n SourceLocation ExternLoc,\n SourceLocation TemplateLoc,\n Declarator &D);\n\n TemplateArgumentLoc\n SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,\n SourceLocation TemplateLoc,\n SourceLocation RAngleLoc,\n Decl *Param,\n SmallVectorImpl<TemplateArgument>\n &Converted,\n bool &HasDefaultArg);\n\n /// Specifies the context in which a particular template\n /// argument is being checked.\n enum CheckTemplateArgumentKind {\n /// The template argument was specified in the code or was\n /// instantiated with some deduced template arguments.\n CTAK_Specified,\n\n /// The template argument was deduced via template argument\n /// deduction.\n CTAK_Deduced,\n\n /// The template argument was deduced from an array bound\n /// via template argument deduction.\n CTAK_DeducedFromArrayBound\n };\n\n bool CheckTemplateArgument(NamedDecl *Param,\n TemplateArgumentLoc &Arg,\n NamedDecl *Template,\n SourceLocation TemplateLoc,\n SourceLocation RAngleLoc,\n unsigned ArgumentPackIndex,\n SmallVectorImpl<TemplateArgument> &Converted,\n CheckTemplateArgumentKind CTAK = CTAK_Specified);\n\n /// Check that the given template arguments can be be provided to\n /// the given template, converting the arguments along the way.\n ///\n /// \\param Template The template to which the template arguments are being\n /// provided.\n ///\n /// \\param TemplateLoc The location of the template name in the source.\n ///\n /// \\param TemplateArgs The list of template arguments. If the template is\n /// a template template parameter, this function may extend the set of\n /// template arguments to also include substituted, defaulted template\n /// arguments.\n ///\n /// \\param PartialTemplateArgs True if the list of template arguments is\n /// intentionally partial, e.g., because we're checking just the initial\n /// set of template arguments.\n ///\n /// \\param Converted Will receive the converted, canonicalized template\n /// arguments.\n ///\n /// \\param UpdateArgsWithConversions If \\c true, update \\p TemplateArgs to\n /// contain the converted forms of the template arguments as written.\n /// Otherwise, \\p TemplateArgs will not be modified.\n ///\n /// \\param ConstraintsNotSatisfied If provided, and an error occured, will\n /// receive true if the cause for the error is the associated constraints of\n /// the template not being satisfied by the template arguments.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool CheckTemplateArgumentList(TemplateDecl *Template,\n SourceLocation TemplateLoc,\n TemplateArgumentListInfo &TemplateArgs,\n bool PartialTemplateArgs,\n SmallVectorImpl<TemplateArgument> &Converted,\n bool UpdateArgsWithConversions = true,\n bool *ConstraintsNotSatisfied = nullptr);\n\n bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,\n TemplateArgumentLoc &Arg,\n SmallVectorImpl<TemplateArgument> &Converted);\n\n bool CheckTemplateArgument(TemplateTypeParmDecl *Param,\n TypeSourceInfo *Arg);\n ExprResult CheckTemplateArgument(NonTypeTemplateParmDecl *Param,\n QualType InstantiatedParamType, Expr *Arg,\n TemplateArgument &Converted,\n CheckTemplateArgumentKind CTAK = CTAK_Specified);\n bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,\n TemplateParameterList *Params,\n TemplateArgumentLoc &Arg);\n\n ExprResult\n BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,\n QualType ParamType,\n SourceLocation Loc);\n ExprResult\n BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,\n SourceLocation Loc);\n\n /// Enumeration describing how template parameter lists are compared\n /// for equality.\n enum TemplateParameterListEqualKind {\n /// We are matching the template parameter lists of two templates\n /// that might be redeclarations.\n ///\n /// \\code\n /// template<typename T> struct X;\n /// template<typename T> struct X;\n /// \\endcode\n TPL_TemplateMatch,\n\n /// We are matching the template parameter lists of two template\n /// template parameters as part of matching the template parameter lists\n /// of two templates that might be redeclarations.\n ///\n /// \\code\n /// template<template<int I> class TT> struct X;\n /// template<template<int Value> class Other> struct X;\n /// \\endcode\n TPL_TemplateTemplateParmMatch,\n\n /// We are matching the template parameter lists of a template\n /// template argument against the template parameter lists of a template\n /// template parameter.\n ///\n /// \\code\n /// template<template<int Value> class Metafun> struct X;\n /// template<int Value> struct integer_c;\n /// X<integer_c> xic;\n /// \\endcode\n TPL_TemplateTemplateArgumentMatch\n };\n\n bool TemplateParameterListsAreEqual(TemplateParameterList *New,\n TemplateParameterList *Old,\n bool Complain,\n TemplateParameterListEqualKind Kind,\n SourceLocation TemplateArgLoc\n = SourceLocation());\n\n bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams);\n\n /// Called when the parser has parsed a C++ typename\n /// specifier, e.g., \"typename T::type\".\n ///\n /// \\param S The scope in which this typename type occurs.\n /// \\param TypenameLoc the location of the 'typename' keyword\n /// \\param SS the nested-name-specifier following the typename (e.g., 'T::').\n /// \\param II the identifier we're retrieving (e.g., 'type' in the example).\n /// \\param IdLoc the location of the identifier.\n TypeResult\n ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,\n const CXXScopeSpec &SS, const IdentifierInfo &II,\n SourceLocation IdLoc);\n\n /// Called when the parser has parsed a C++ typename\n /// specifier that ends in a template-id, e.g.,\n /// \"typename MetaFun::template apply<T1, T2>\".\n ///\n /// \\param S The scope in which this typename type occurs.\n /// \\param TypenameLoc the location of the 'typename' keyword\n /// \\param SS the nested-name-specifier following the typename (e.g., 'T::').\n /// \\param TemplateLoc the location of the 'template' keyword, if any.\n /// \\param TemplateName The template name.\n /// \\param TemplateII The identifier used to name the template.\n /// \\param TemplateIILoc The location of the template name.\n /// \\param LAngleLoc The location of the opening angle bracket ('<').\n /// \\param TemplateArgs The template arguments.\n /// \\param RAngleLoc The location of the closing angle bracket ('>').\n TypeResult\n ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,\n const CXXScopeSpec &SS,\n SourceLocation TemplateLoc,\n TemplateTy TemplateName,\n IdentifierInfo *TemplateII,\n SourceLocation TemplateIILoc,\n SourceLocation LAngleLoc,\n ASTTemplateArgsPtr TemplateArgs,\n SourceLocation RAngleLoc);\n\n QualType CheckTypenameType(ElaboratedTypeKeyword Keyword,\n SourceLocation KeywordLoc,\n NestedNameSpecifierLoc QualifierLoc,\n const IdentifierInfo &II,\n SourceLocation IILoc,\n TypeSourceInfo **TSI,\n bool DeducedTSTContext);\n\n QualType CheckTypenameType(ElaboratedTypeKeyword Keyword,\n SourceLocation KeywordLoc,\n NestedNameSpecifierLoc QualifierLoc,\n const IdentifierInfo &II,\n SourceLocation IILoc,\n bool DeducedTSTContext = true);\n\n\n TypeSourceInfo *RebuildTypeInCurrentInstantiation(TypeSourceInfo *T,\n SourceLocation Loc,\n DeclarationName Name);\n bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS);\n\n ExprResult RebuildExprInCurrentInstantiation(Expr *E);\n bool RebuildTemplateParamsInCurrentInstantiation(\n TemplateParameterList *Params);\n\n std::string\n getTemplateArgumentBindingsText(const TemplateParameterList *Params,\n const TemplateArgumentList &Args);\n\n std::string\n getTemplateArgumentBindingsText(const TemplateParameterList *Params,\n const TemplateArgument *Args,\n unsigned NumArgs);\n\n //===--------------------------------------------------------------------===//\n // C++ Concepts\n //===--------------------------------------------------------------------===//\n Decl *ActOnConceptDefinition(\n Scope *S, MultiTemplateParamsArg TemplateParameterLists,\n IdentifierInfo *Name, SourceLocation NameLoc, Expr *ConstraintExpr);\n\n RequiresExprBodyDecl *\n ActOnStartRequiresExpr(SourceLocation RequiresKWLoc,\n ArrayRef<ParmVarDecl *> LocalParameters,\n Scope *BodyScope);\n void ActOnFinishRequiresExpr();\n concepts::Requirement *ActOnSimpleRequirement(Expr *E);\n concepts::Requirement *ActOnTypeRequirement(\n SourceLocation TypenameKWLoc, CXXScopeSpec &SS, SourceLocation NameLoc,\n IdentifierInfo *TypeName, TemplateIdAnnotation *TemplateId);\n concepts::Requirement *ActOnCompoundRequirement(Expr *E,\n SourceLocation NoexceptLoc);\n concepts::Requirement *\n ActOnCompoundRequirement(\n Expr *E, SourceLocation NoexceptLoc, CXXScopeSpec &SS,\n TemplateIdAnnotation *TypeConstraint, unsigned Depth);\n concepts::Requirement *ActOnNestedRequirement(Expr *Constraint);\n concepts::ExprRequirement *\n BuildExprRequirement(\n Expr *E, bool IsSatisfied, SourceLocation NoexceptLoc,\n concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement);\n concepts::ExprRequirement *\n BuildExprRequirement(\n concepts::Requirement::SubstitutionDiagnostic *ExprSubstDiag,\n bool IsSatisfied, SourceLocation NoexceptLoc,\n concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement);\n concepts::TypeRequirement *BuildTypeRequirement(TypeSourceInfo *Type);\n concepts::TypeRequirement *\n BuildTypeRequirement(\n concepts::Requirement::SubstitutionDiagnostic *SubstDiag);\n concepts::NestedRequirement *BuildNestedRequirement(Expr *E);\n concepts::NestedRequirement *\n BuildNestedRequirement(\n concepts::Requirement::SubstitutionDiagnostic *SubstDiag);\n ExprResult ActOnRequiresExpr(SourceLocation RequiresKWLoc,\n RequiresExprBodyDecl *Body,\n ArrayRef<ParmVarDecl *> LocalParameters,\n ArrayRef<concepts::Requirement *> Requirements,\n SourceLocation ClosingBraceLoc);\n\n //===--------------------------------------------------------------------===//\n // C++ Variadic Templates (C++0x [temp.variadic])\n //===--------------------------------------------------------------------===//\n\n /// Determine whether an unexpanded parameter pack might be permitted in this\n /// location. Useful for error recovery.\n bool isUnexpandedParameterPackPermitted();\n\n /// The context in which an unexpanded parameter pack is\n /// being diagnosed.\n ///\n /// Note that the values of this enumeration line up with the first\n /// argument to the \\c err_unexpanded_parameter_pack diagnostic.\n enum UnexpandedParameterPackContext {\n /// An arbitrary expression.\n UPPC_Expression = 0,\n\n /// The base type of a class type.\n UPPC_BaseType,\n\n /// The type of an arbitrary declaration.\n UPPC_DeclarationType,\n\n /// The type of a data member.\n UPPC_DataMemberType,\n\n /// The size of a bit-field.\n UPPC_BitFieldWidth,\n\n /// The expression in a static assertion.\n UPPC_StaticAssertExpression,\n\n /// The fixed underlying type of an enumeration.\n UPPC_FixedUnderlyingType,\n\n /// The enumerator value.\n UPPC_EnumeratorValue,\n\n /// A using declaration.\n UPPC_UsingDeclaration,\n\n /// A friend declaration.\n UPPC_FriendDeclaration,\n\n /// A declaration qualifier.\n UPPC_DeclarationQualifier,\n\n /// An initializer.\n UPPC_Initializer,\n\n /// A default argument.\n UPPC_DefaultArgument,\n\n /// The type of a non-type template parameter.\n UPPC_NonTypeTemplateParameterType,\n\n /// The type of an exception.\n UPPC_ExceptionType,\n\n /// Partial specialization.\n UPPC_PartialSpecialization,\n\n /// Microsoft __if_exists.\n UPPC_IfExists,\n\n /// Microsoft __if_not_exists.\n UPPC_IfNotExists,\n\n /// Lambda expression.\n UPPC_Lambda,\n\n /// Block expression.\n UPPC_Block,\n\n /// A type constraint.\n UPPC_TypeConstraint,\n\n // A requirement in a requires-expression.\n UPPC_Requirement,\n\n // A requires-clause.\n UPPC_RequiresClause,\n };\n\n /// Diagnose unexpanded parameter packs.\n ///\n /// \\param Loc The location at which we should emit the diagnostic.\n ///\n /// \\param UPPC The context in which we are diagnosing unexpanded\n /// parameter packs.\n ///\n /// \\param Unexpanded the set of unexpanded parameter packs.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc,\n UnexpandedParameterPackContext UPPC,\n ArrayRef<UnexpandedParameterPack> Unexpanded);\n\n /// If the given type contains an unexpanded parameter pack,\n /// diagnose the error.\n ///\n /// \\param Loc The source location where a diagnostc should be emitted.\n ///\n /// \\param T The type that is being checked for unexpanded parameter\n /// packs.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T,\n UnexpandedParameterPackContext UPPC);\n\n /// If the given expression contains an unexpanded parameter\n /// pack, diagnose the error.\n ///\n /// \\param E The expression that is being checked for unexpanded\n /// parameter packs.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool DiagnoseUnexpandedParameterPack(Expr *E,\n UnexpandedParameterPackContext UPPC = UPPC_Expression);\n\n /// If the given requirees-expression contains an unexpanded reference to one\n /// of its own parameter packs, diagnose the error.\n ///\n /// \\param RE The requiress-expression that is being checked for unexpanded\n /// parameter packs.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool DiagnoseUnexpandedParameterPackInRequiresExpr(RequiresExpr *RE);\n\n /// If the given nested-name-specifier contains an unexpanded\n /// parameter pack, diagnose the error.\n ///\n /// \\param SS The nested-name-specifier that is being checked for\n /// unexpanded parameter packs.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool DiagnoseUnexpandedParameterPack(const CXXScopeSpec &SS,\n UnexpandedParameterPackContext UPPC);\n\n /// If the given name contains an unexpanded parameter pack,\n /// diagnose the error.\n ///\n /// \\param NameInfo The name (with source location information) that\n /// is being checked for unexpanded parameter packs.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool DiagnoseUnexpandedParameterPack(const DeclarationNameInfo &NameInfo,\n UnexpandedParameterPackContext UPPC);\n\n /// If the given template name contains an unexpanded parameter pack,\n /// diagnose the error.\n ///\n /// \\param Loc The location of the template name.\n ///\n /// \\param Template The template name that is being checked for unexpanded\n /// parameter packs.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool DiagnoseUnexpandedParameterPack(SourceLocation Loc,\n TemplateName Template,\n UnexpandedParameterPackContext UPPC);\n\n /// If the given template argument contains an unexpanded parameter\n /// pack, diagnose the error.\n ///\n /// \\param Arg The template argument that is being checked for unexpanded\n /// parameter packs.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool DiagnoseUnexpandedParameterPack(TemplateArgumentLoc Arg,\n UnexpandedParameterPackContext UPPC);\n\n /// Collect the set of unexpanded parameter packs within the given\n /// template argument.\n ///\n /// \\param Arg The template argument that will be traversed to find\n /// unexpanded parameter packs.\n void collectUnexpandedParameterPacks(TemplateArgument Arg,\n SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);\n\n /// Collect the set of unexpanded parameter packs within the given\n /// template argument.\n ///\n /// \\param Arg The template argument that will be traversed to find\n /// unexpanded parameter packs.\n void collectUnexpandedParameterPacks(TemplateArgumentLoc Arg,\n SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);\n\n /// Collect the set of unexpanded parameter packs within the given\n /// type.\n ///\n /// \\param T The type that will be traversed to find\n /// unexpanded parameter packs.\n void collectUnexpandedParameterPacks(QualType T,\n SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);\n\n /// Collect the set of unexpanded parameter packs within the given\n /// type.\n ///\n /// \\param TL The type that will be traversed to find\n /// unexpanded parameter packs.\n void collectUnexpandedParameterPacks(TypeLoc TL,\n SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);\n\n /// Collect the set of unexpanded parameter packs within the given\n /// nested-name-specifier.\n ///\n /// \\param NNS The nested-name-specifier that will be traversed to find\n /// unexpanded parameter packs.\n void collectUnexpandedParameterPacks(NestedNameSpecifierLoc NNS,\n SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);\n\n /// Collect the set of unexpanded parameter packs within the given\n /// name.\n ///\n /// \\param NameInfo The name that will be traversed to find\n /// unexpanded parameter packs.\n void collectUnexpandedParameterPacks(const DeclarationNameInfo &NameInfo,\n SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);\n\n /// Invoked when parsing a template argument followed by an\n /// ellipsis, which creates a pack expansion.\n ///\n /// \\param Arg The template argument preceding the ellipsis, which\n /// may already be invalid.\n ///\n /// \\param EllipsisLoc The location of the ellipsis.\n ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg,\n SourceLocation EllipsisLoc);\n\n /// Invoked when parsing a type followed by an ellipsis, which\n /// creates a pack expansion.\n ///\n /// \\param Type The type preceding the ellipsis, which will become\n /// the pattern of the pack expansion.\n ///\n /// \\param EllipsisLoc The location of the ellipsis.\n TypeResult ActOnPackExpansion(ParsedType Type, SourceLocation EllipsisLoc);\n\n /// Construct a pack expansion type from the pattern of the pack\n /// expansion.\n TypeSourceInfo *CheckPackExpansion(TypeSourceInfo *Pattern,\n SourceLocation EllipsisLoc,\n Optional<unsigned> NumExpansions);\n\n /// Construct a pack expansion type from the pattern of the pack\n /// expansion.\n QualType CheckPackExpansion(QualType Pattern,\n SourceRange PatternRange,\n SourceLocation EllipsisLoc,\n Optional<unsigned> NumExpansions);\n\n /// Invoked when parsing an expression followed by an ellipsis, which\n /// creates a pack expansion.\n ///\n /// \\param Pattern The expression preceding the ellipsis, which will become\n /// the pattern of the pack expansion.\n ///\n /// \\param EllipsisLoc The location of the ellipsis.\n ExprResult ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc);\n\n /// Invoked when parsing an expression followed by an ellipsis, which\n /// creates a pack expansion.\n ///\n /// \\param Pattern The expression preceding the ellipsis, which will become\n /// the pattern of the pack expansion.\n ///\n /// \\param EllipsisLoc The location of the ellipsis.\n ExprResult CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,\n Optional<unsigned> NumExpansions);\n\n /// Determine whether we could expand a pack expansion with the\n /// given set of parameter packs into separate arguments by repeatedly\n /// transforming the pattern.\n ///\n /// \\param EllipsisLoc The location of the ellipsis that identifies the\n /// pack expansion.\n ///\n /// \\param PatternRange The source range that covers the entire pattern of\n /// the pack expansion.\n ///\n /// \\param Unexpanded The set of unexpanded parameter packs within the\n /// pattern.\n ///\n /// \\param ShouldExpand Will be set to \\c true if the transformer should\n /// expand the corresponding pack expansions into separate arguments. When\n /// set, \\c NumExpansions must also be set.\n ///\n /// \\param RetainExpansion Whether the caller should add an unexpanded\n /// pack expansion after all of the expanded arguments. This is used\n /// when extending explicitly-specified template argument packs per\n /// C++0x [temp.arg.explicit]p9.\n ///\n /// \\param NumExpansions The number of separate arguments that will be in\n /// the expanded form of the corresponding pack expansion. This is both an\n /// input and an output parameter, which can be set by the caller if the\n /// number of expansions is known a priori (e.g., due to a prior substitution)\n /// and will be set by the callee when the number of expansions is known.\n /// The callee must set this value when \\c ShouldExpand is \\c true; it may\n /// set this value in other cases.\n ///\n /// \\returns true if an error occurred (e.g., because the parameter packs\n /// are to be instantiated with arguments of different lengths), false\n /// otherwise. If false, \\c ShouldExpand (and possibly \\c NumExpansions)\n /// must be set.\n bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc,\n SourceRange PatternRange,\n ArrayRef<UnexpandedParameterPack> Unexpanded,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n bool &ShouldExpand,\n bool &RetainExpansion,\n Optional<unsigned> &NumExpansions);\n\n /// Determine the number of arguments in the given pack expansion\n /// type.\n ///\n /// This routine assumes that the number of arguments in the expansion is\n /// consistent across all of the unexpanded parameter packs in its pattern.\n ///\n /// Returns an empty Optional if the type can't be expanded.\n Optional<unsigned> getNumArgumentsInExpansion(QualType T,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n /// Determine whether the given declarator contains any unexpanded\n /// parameter packs.\n ///\n /// This routine is used by the parser to disambiguate function declarators\n /// with an ellipsis prior to the ')', e.g.,\n ///\n /// \\code\n /// void f(T...);\n /// \\endcode\n ///\n /// To determine whether we have an (unnamed) function parameter pack or\n /// a variadic function.\n ///\n /// \\returns true if the declarator contains any unexpanded parameter packs,\n /// false otherwise.\n bool containsUnexpandedParameterPacks(Declarator &D);\n\n /// Returns the pattern of the pack expansion for a template argument.\n ///\n /// \\param OrigLoc The template argument to expand.\n ///\n /// \\param Ellipsis Will be set to the location of the ellipsis.\n ///\n /// \\param NumExpansions Will be set to the number of expansions that will\n /// be generated from this pack expansion, if known a priori.\n TemplateArgumentLoc getTemplateArgumentPackExpansionPattern(\n TemplateArgumentLoc OrigLoc,\n SourceLocation &Ellipsis,\n Optional<unsigned> &NumExpansions) const;\n\n /// Given a template argument that contains an unexpanded parameter pack, but\n /// which has already been substituted, attempt to determine the number of\n /// elements that will be produced once this argument is fully-expanded.\n ///\n /// This is intended for use when transforming 'sizeof...(Arg)' in order to\n /// avoid actually expanding the pack where possible.\n Optional<unsigned> getFullyPackExpandedSize(TemplateArgument Arg);\n\n //===--------------------------------------------------------------------===//\n // C++ Template Argument Deduction (C++ [temp.deduct])\n //===--------------------------------------------------------------------===//\n\n /// Adjust the type \\p ArgFunctionType to match the calling convention,\n /// noreturn, and optionally the exception specification of \\p FunctionType.\n /// Deduction often wants to ignore these properties when matching function\n /// types.\n QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType,\n bool AdjustExceptionSpec = false);\n\n /// Describes the result of template argument deduction.\n ///\n /// The TemplateDeductionResult enumeration describes the result of\n /// template argument deduction, as returned from\n /// DeduceTemplateArguments(). The separate TemplateDeductionInfo\n /// structure provides additional information about the results of\n /// template argument deduction, e.g., the deduced template argument\n /// list (if successful) or the specific template parameters or\n /// deduced arguments that were involved in the failure.\n enum TemplateDeductionResult {\n /// Template argument deduction was successful.\n TDK_Success = 0,\n /// The declaration was invalid; do nothing.\n TDK_Invalid,\n /// Template argument deduction exceeded the maximum template\n /// instantiation depth (which has already been diagnosed).\n TDK_InstantiationDepth,\n /// Template argument deduction did not deduce a value\n /// for every template parameter.\n TDK_Incomplete,\n /// Template argument deduction did not deduce a value for every\n /// expansion of an expanded template parameter pack.\n TDK_IncompletePack,\n /// Template argument deduction produced inconsistent\n /// deduced values for the given template parameter.\n TDK_Inconsistent,\n /// Template argument deduction failed due to inconsistent\n /// cv-qualifiers on a template parameter type that would\n /// otherwise be deduced, e.g., we tried to deduce T in \"const T\"\n /// but were given a non-const \"X\".\n TDK_Underqualified,\n /// Substitution of the deduced template argument values\n /// resulted in an error.\n TDK_SubstitutionFailure,\n /// After substituting deduced template arguments, a dependent\n /// parameter type did not match the corresponding argument.\n TDK_DeducedMismatch,\n /// After substituting deduced template arguments, an element of\n /// a dependent parameter type did not match the corresponding element\n /// of the corresponding argument (when deducing from an initializer list).\n TDK_DeducedMismatchNested,\n /// A non-depnedent component of the parameter did not match the\n /// corresponding component of the argument.\n TDK_NonDeducedMismatch,\n /// When performing template argument deduction for a function\n /// template, there were too many call arguments.\n TDK_TooManyArguments,\n /// When performing template argument deduction for a function\n /// template, there were too few call arguments.\n TDK_TooFewArguments,\n /// The explicitly-specified template arguments were not valid\n /// template arguments for the given template.\n TDK_InvalidExplicitArguments,\n /// Checking non-dependent argument conversions failed.\n TDK_NonDependentConversionFailure,\n /// The deduced arguments did not satisfy the constraints associated\n /// with the template.\n TDK_ConstraintsNotSatisfied,\n /// Deduction failed; that's all we know.\n TDK_MiscellaneousDeductionFailure,\n /// CUDA Target attributes do not match.\n TDK_CUDATargetMismatch\n };\n\n TemplateDeductionResult\n DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,\n const TemplateArgumentList &TemplateArgs,\n sema::TemplateDeductionInfo &Info);\n\n TemplateDeductionResult\n DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial,\n const TemplateArgumentList &TemplateArgs,\n sema::TemplateDeductionInfo &Info);\n\n TemplateDeductionResult SubstituteExplicitTemplateArguments(\n FunctionTemplateDecl *FunctionTemplate,\n TemplateArgumentListInfo &ExplicitTemplateArgs,\n SmallVectorImpl<DeducedTemplateArgument> &Deduced,\n SmallVectorImpl<QualType> &ParamTypes, QualType *FunctionType,\n sema::TemplateDeductionInfo &Info);\n\n /// brief A function argument from which we performed template argument\n // deduction for a call.\n struct OriginalCallArg {\n OriginalCallArg(QualType OriginalParamType, bool DecomposedParam,\n unsigned ArgIdx, QualType OriginalArgType)\n : OriginalParamType(OriginalParamType),\n DecomposedParam(DecomposedParam), ArgIdx(ArgIdx),\n OriginalArgType(OriginalArgType) {}\n\n QualType OriginalParamType;\n bool DecomposedParam;\n unsigned ArgIdx;\n QualType OriginalArgType;\n };\n\n TemplateDeductionResult FinishTemplateArgumentDeduction(\n FunctionTemplateDecl *FunctionTemplate,\n SmallVectorImpl<DeducedTemplateArgument> &Deduced,\n unsigned NumExplicitlySpecified, FunctionDecl *&Specialization,\n sema::TemplateDeductionInfo &Info,\n SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs = nullptr,\n bool PartialOverloading = false,\n llvm::function_ref<bool()> CheckNonDependent = []{ return false; });\n\n TemplateDeductionResult DeduceTemplateArguments(\n FunctionTemplateDecl *FunctionTemplate,\n TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,\n FunctionDecl *&Specialization, sema::TemplateDeductionInfo &Info,\n bool PartialOverloading,\n llvm::function_ref<bool(ArrayRef<QualType>)> CheckNonDependent);\n\n TemplateDeductionResult\n DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,\n TemplateArgumentListInfo *ExplicitTemplateArgs,\n QualType ArgFunctionType,\n FunctionDecl *&Specialization,\n sema::TemplateDeductionInfo &Info,\n bool IsAddressOfFunction = false);\n\n TemplateDeductionResult\n DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,\n QualType ToType,\n CXXConversionDecl *&Specialization,\n sema::TemplateDeductionInfo &Info);\n\n TemplateDeductionResult\n DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,\n TemplateArgumentListInfo *ExplicitTemplateArgs,\n FunctionDecl *&Specialization,\n sema::TemplateDeductionInfo &Info,\n bool IsAddressOfFunction = false);\n\n /// Substitute Replacement for \\p auto in \\p TypeWithAuto\n QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement);\n /// Substitute Replacement for auto in TypeWithAuto\n TypeSourceInfo* SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,\n QualType Replacement);\n /// Completely replace the \\c auto in \\p TypeWithAuto by\n /// \\p Replacement. This does not retain any \\c auto type sugar.\n QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement);\n TypeSourceInfo *ReplaceAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,\n QualType Replacement);\n\n /// Result type of DeduceAutoType.\n enum DeduceAutoResult {\n DAR_Succeeded,\n DAR_Failed,\n DAR_FailedAlreadyDiagnosed\n };\n\n DeduceAutoResult\n DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result,\n Optional<unsigned> DependentDeductionDepth = None,\n bool IgnoreConstraints = false);\n DeduceAutoResult\n DeduceAutoType(TypeLoc AutoTypeLoc, Expr *&Initializer, QualType &Result,\n Optional<unsigned> DependentDeductionDepth = None,\n bool IgnoreConstraints = false);\n void DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init);\n bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc,\n bool Diagnose = true);\n\n /// Declare implicit deduction guides for a class template if we've\n /// not already done so.\n void DeclareImplicitDeductionGuides(TemplateDecl *Template,\n SourceLocation Loc);\n\n QualType DeduceTemplateSpecializationFromInitializer(\n TypeSourceInfo *TInfo, const InitializedEntity &Entity,\n const InitializationKind &Kind, MultiExprArg Init);\n\n QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name,\n QualType Type, TypeSourceInfo *TSI,\n SourceRange Range, bool DirectInit,\n Expr *Init);\n\n TypeLoc getReturnTypeLoc(FunctionDecl *FD) const;\n\n bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD,\n SourceLocation ReturnLoc,\n Expr *&RetExpr, AutoType *AT);\n\n FunctionTemplateDecl *getMoreSpecializedTemplate(\n FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc,\n TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1,\n unsigned NumCallArguments2, bool Reversed = false);\n UnresolvedSetIterator\n getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd,\n TemplateSpecCandidateSet &FailedCandidates,\n SourceLocation Loc,\n const PartialDiagnostic &NoneDiag,\n const PartialDiagnostic &AmbigDiag,\n const PartialDiagnostic &CandidateDiag,\n bool Complain = true, QualType TargetType = QualType());\n\n ClassTemplatePartialSpecializationDecl *\n getMoreSpecializedPartialSpecialization(\n ClassTemplatePartialSpecializationDecl *PS1,\n ClassTemplatePartialSpecializationDecl *PS2,\n SourceLocation Loc);\n\n bool isMoreSpecializedThanPrimary(ClassTemplatePartialSpecializationDecl *T,\n sema::TemplateDeductionInfo &Info);\n\n VarTemplatePartialSpecializationDecl *getMoreSpecializedPartialSpecialization(\n VarTemplatePartialSpecializationDecl *PS1,\n VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc);\n\n bool isMoreSpecializedThanPrimary(VarTemplatePartialSpecializationDecl *T,\n sema::TemplateDeductionInfo &Info);\n\n bool isTemplateTemplateParameterAtLeastAsSpecializedAs(\n TemplateParameterList *PParam, TemplateDecl *AArg, SourceLocation Loc);\n\n void MarkUsedTemplateParameters(const Expr *E, bool OnlyDeduced,\n unsigned Depth, llvm::SmallBitVector &Used);\n\n void MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,\n bool OnlyDeduced,\n unsigned Depth,\n llvm::SmallBitVector &Used);\n void MarkDeducedTemplateParameters(\n const FunctionTemplateDecl *FunctionTemplate,\n llvm::SmallBitVector &Deduced) {\n return MarkDeducedTemplateParameters(Context, FunctionTemplate, Deduced);\n }\n static void MarkDeducedTemplateParameters(ASTContext &Ctx,\n const FunctionTemplateDecl *FunctionTemplate,\n llvm::SmallBitVector &Deduced);\n\n //===--------------------------------------------------------------------===//\n // C++ Template Instantiation\n //\n\n MultiLevelTemplateArgumentList\n getTemplateInstantiationArgs(NamedDecl *D,\n const TemplateArgumentList *Innermost = nullptr,\n bool RelativeToPrimary = false,\n const FunctionDecl *Pattern = nullptr);\n\n /// A context in which code is being synthesized (where a source location\n /// alone is not sufficient to identify the context). This covers template\n /// instantiation and various forms of implicitly-generated functions.\n struct CodeSynthesisContext {\n /// The kind of template instantiation we are performing\n enum SynthesisKind {\n /// We are instantiating a template declaration. The entity is\n /// the declaration we're instantiating (e.g., a CXXRecordDecl).\n TemplateInstantiation,\n\n /// We are instantiating a default argument for a template\n /// parameter. The Entity is the template parameter whose argument is\n /// being instantiated, the Template is the template, and the\n /// TemplateArgs/NumTemplateArguments provide the template arguments as\n /// specified.\n DefaultTemplateArgumentInstantiation,\n\n /// We are instantiating a default argument for a function.\n /// The Entity is the ParmVarDecl, and TemplateArgs/NumTemplateArgs\n /// provides the template arguments as specified.\n DefaultFunctionArgumentInstantiation,\n\n /// We are substituting explicit template arguments provided for\n /// a function template. The entity is a FunctionTemplateDecl.\n ExplicitTemplateArgumentSubstitution,\n\n /// We are substituting template argument determined as part of\n /// template argument deduction for either a class template\n /// partial specialization or a function template. The\n /// Entity is either a {Class|Var}TemplatePartialSpecializationDecl or\n /// a TemplateDecl.\n DeducedTemplateArgumentSubstitution,\n\n /// We are substituting prior template arguments into a new\n /// template parameter. The template parameter itself is either a\n /// NonTypeTemplateParmDecl or a TemplateTemplateParmDecl.\n PriorTemplateArgumentSubstitution,\n\n /// We are checking the validity of a default template argument that\n /// has been used when naming a template-id.\n DefaultTemplateArgumentChecking,\n\n /// We are computing the exception specification for a defaulted special\n /// member function.\n ExceptionSpecEvaluation,\n\n /// We are instantiating the exception specification for a function\n /// template which was deferred until it was needed.\n ExceptionSpecInstantiation,\n\n /// We are instantiating a requirement of a requires expression.\n RequirementInstantiation,\n\n /// We are checking the satisfaction of a nested requirement of a requires\n /// expression.\n NestedRequirementConstraintsCheck,\n\n /// We are declaring an implicit special member function.\n DeclaringSpecialMember,\n\n /// We are declaring an implicit 'operator==' for a defaulted\n /// 'operator<=>'.\n DeclaringImplicitEqualityComparison,\n\n /// We are defining a synthesized function (such as a defaulted special\n /// member).\n DefiningSynthesizedFunction,\n\n // We are checking the constraints associated with a constrained entity or\n // the constraint expression of a concept. This includes the checks that\n // atomic constraints have the type 'bool' and that they can be constant\n // evaluated.\n ConstraintsCheck,\n\n // We are substituting template arguments into a constraint expression.\n ConstraintSubstitution,\n\n // We are normalizing a constraint expression.\n ConstraintNormalization,\n\n // We are substituting into the parameter mapping of an atomic constraint\n // during normalization.\n ParameterMappingSubstitution,\n\n /// We are rewriting a comparison operator in terms of an operator<=>.\n RewritingOperatorAsSpaceship,\n\n /// We are initializing a structured binding.\n InitializingStructuredBinding,\n\n /// We are marking a class as __dllexport.\n MarkingClassDllexported,\n\n /// Added for Template instantiation observation.\n /// Memoization means we are _not_ instantiating a template because\n /// it is already instantiated (but we entered a context where we\n /// would have had to if it was not already instantiated).\n Memoization\n } Kind;\n\n /// Was the enclosing context a non-instantiation SFINAE context?\n bool SavedInNonInstantiationSFINAEContext;\n\n /// The point of instantiation or synthesis within the source code.\n SourceLocation PointOfInstantiation;\n\n /// The entity that is being synthesized.\n Decl *Entity;\n\n /// The template (or partial specialization) in which we are\n /// performing the instantiation, for substitutions of prior template\n /// arguments.\n NamedDecl *Template;\n\n /// The list of template arguments we are substituting, if they\n /// are not part of the entity.\n const TemplateArgument *TemplateArgs;\n\n // FIXME: Wrap this union around more members, or perhaps store the\n // kind-specific members in the RAII object owning the context.\n union {\n /// The number of template arguments in TemplateArgs.\n unsigned NumTemplateArgs;\n\n /// The special member being declared or defined.\n CXXSpecialMember SpecialMember;\n };\n\n ArrayRef<TemplateArgument> template_arguments() const {\n assert(Kind != DeclaringSpecialMember);\n return {TemplateArgs, NumTemplateArgs};\n }\n\n /// The template deduction info object associated with the\n /// substitution or checking of explicit or deduced template arguments.\n sema::TemplateDeductionInfo *DeductionInfo;\n\n /// The source range that covers the construct that cause\n /// the instantiation, e.g., the template-id that causes a class\n /// template instantiation.\n SourceRange InstantiationRange;\n\n CodeSynthesisContext()\n : Kind(TemplateInstantiation),\n SavedInNonInstantiationSFINAEContext(false), Entity(nullptr),\n Template(nullptr), TemplateArgs(nullptr), NumTemplateArgs(0),\n DeductionInfo(nullptr) {}\n\n /// Determines whether this template is an actual instantiation\n /// that should be counted toward the maximum instantiation depth.\n bool isInstantiationRecord() const;\n };\n\n /// List of active code synthesis contexts.\n ///\n /// This vector is treated as a stack. As synthesis of one entity requires\n /// synthesis of another, additional contexts are pushed onto the stack.\n SmallVector<CodeSynthesisContext, 16> CodeSynthesisContexts;\n\n /// Specializations whose definitions are currently being instantiated.\n llvm::DenseSet<std::pair<Decl *, unsigned>> InstantiatingSpecializations;\n\n /// Non-dependent types used in templates that have already been instantiated\n /// by some template instantiation.\n llvm::DenseSet<QualType> InstantiatedNonDependentTypes;\n\n /// Extra modules inspected when performing a lookup during a template\n /// instantiation. Computed lazily.\n SmallVector<Module*, 16> CodeSynthesisContextLookupModules;\n\n /// Cache of additional modules that should be used for name lookup\n /// within the current template instantiation. Computed lazily; use\n /// getLookupModules() to get a complete set.\n llvm::DenseSet<Module*> LookupModulesCache;\n\n /// Get the set of additional modules that should be checked during\n /// name lookup. A module and its imports become visible when instanting a\n /// template defined within it.\n llvm::DenseSet<Module*> &getLookupModules();\n\n /// Map from the most recent declaration of a namespace to the most\n /// recent visible declaration of that namespace.\n llvm::DenseMap<NamedDecl*, NamedDecl*> VisibleNamespaceCache;\n\n /// Whether we are in a SFINAE context that is not associated with\n /// template instantiation.\n ///\n /// This is used when setting up a SFINAE trap (\\c see SFINAETrap) outside\n /// of a template instantiation or template argument deduction.\n bool InNonInstantiationSFINAEContext;\n\n /// The number of \\p CodeSynthesisContexts that are not template\n /// instantiations and, therefore, should not be counted as part of the\n /// instantiation depth.\n ///\n /// When the instantiation depth reaches the user-configurable limit\n /// \\p LangOptions::InstantiationDepth we will abort instantiation.\n // FIXME: Should we have a similar limit for other forms of synthesis?\n unsigned NonInstantiationEntries;\n\n /// The depth of the context stack at the point when the most recent\n /// error or warning was produced.\n ///\n /// This value is used to suppress printing of redundant context stacks\n /// when there are multiple errors or warnings in the same instantiation.\n // FIXME: Does this belong in Sema? It's tough to implement it anywhere else.\n unsigned LastEmittedCodeSynthesisContextDepth = 0;\n\n /// The template instantiation callbacks to trace or track\n /// instantiations (objects can be chained).\n ///\n /// This callbacks is used to print, trace or track template\n /// instantiations as they are being constructed.\n std::vector<std::unique_ptr<TemplateInstantiationCallback>>\n TemplateInstCallbacks;\n\n /// The current index into pack expansion arguments that will be\n /// used for substitution of parameter packs.\n ///\n /// The pack expansion index will be -1 to indicate that parameter packs\n /// should be instantiated as themselves. Otherwise, the index specifies\n /// which argument within the parameter pack will be used for substitution.\n int ArgumentPackSubstitutionIndex;\n\n /// RAII object used to change the argument pack substitution index\n /// within a \\c Sema object.\n ///\n /// See \\c ArgumentPackSubstitutionIndex for more information.\n class ArgumentPackSubstitutionIndexRAII {\n Sema &Self;\n int OldSubstitutionIndex;\n\n public:\n ArgumentPackSubstitutionIndexRAII(Sema &Self, int NewSubstitutionIndex)\n : Self(Self), OldSubstitutionIndex(Self.ArgumentPackSubstitutionIndex) {\n Self.ArgumentPackSubstitutionIndex = NewSubstitutionIndex;\n }\n\n ~ArgumentPackSubstitutionIndexRAII() {\n Self.ArgumentPackSubstitutionIndex = OldSubstitutionIndex;\n }\n };\n\n friend class ArgumentPackSubstitutionRAII;\n\n /// For each declaration that involved template argument deduction, the\n /// set of diagnostics that were suppressed during that template argument\n /// deduction.\n ///\n /// FIXME: Serialize this structure to the AST file.\n typedef llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, 1> >\n SuppressedDiagnosticsMap;\n SuppressedDiagnosticsMap SuppressedDiagnostics;\n\n /// A stack object to be created when performing template\n /// instantiation.\n ///\n /// Construction of an object of type \\c InstantiatingTemplate\n /// pushes the current instantiation onto the stack of active\n /// instantiations. If the size of this stack exceeds the maximum\n /// number of recursive template instantiations, construction\n /// produces an error and evaluates true.\n ///\n /// Destruction of this object will pop the named instantiation off\n /// the stack.\n struct InstantiatingTemplate {\n /// Note that we are instantiating a class template,\n /// function template, variable template, alias template,\n /// or a member thereof.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n Decl *Entity,\n SourceRange InstantiationRange = SourceRange());\n\n struct ExceptionSpecification {};\n /// Note that we are instantiating an exception specification\n /// of a function template.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n FunctionDecl *Entity, ExceptionSpecification,\n SourceRange InstantiationRange = SourceRange());\n\n /// Note that we are instantiating a default argument in a\n /// template-id.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n TemplateParameter Param, TemplateDecl *Template,\n ArrayRef<TemplateArgument> TemplateArgs,\n SourceRange InstantiationRange = SourceRange());\n\n /// Note that we are substituting either explicitly-specified or\n /// deduced template arguments during function template argument deduction.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n FunctionTemplateDecl *FunctionTemplate,\n ArrayRef<TemplateArgument> TemplateArgs,\n CodeSynthesisContext::SynthesisKind Kind,\n sema::TemplateDeductionInfo &DeductionInfo,\n SourceRange InstantiationRange = SourceRange());\n\n /// Note that we are instantiating as part of template\n /// argument deduction for a class template declaration.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n TemplateDecl *Template,\n ArrayRef<TemplateArgument> TemplateArgs,\n sema::TemplateDeductionInfo &DeductionInfo,\n SourceRange InstantiationRange = SourceRange());\n\n /// Note that we are instantiating as part of template\n /// argument deduction for a class template partial\n /// specialization.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n ClassTemplatePartialSpecializationDecl *PartialSpec,\n ArrayRef<TemplateArgument> TemplateArgs,\n sema::TemplateDeductionInfo &DeductionInfo,\n SourceRange InstantiationRange = SourceRange());\n\n /// Note that we are instantiating as part of template\n /// argument deduction for a variable template partial\n /// specialization.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n VarTemplatePartialSpecializationDecl *PartialSpec,\n ArrayRef<TemplateArgument> TemplateArgs,\n sema::TemplateDeductionInfo &DeductionInfo,\n SourceRange InstantiationRange = SourceRange());\n\n /// Note that we are instantiating a default argument for a function\n /// parameter.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n ParmVarDecl *Param,\n ArrayRef<TemplateArgument> TemplateArgs,\n SourceRange InstantiationRange = SourceRange());\n\n /// Note that we are substituting prior template arguments into a\n /// non-type parameter.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n NamedDecl *Template,\n NonTypeTemplateParmDecl *Param,\n ArrayRef<TemplateArgument> TemplateArgs,\n SourceRange InstantiationRange);\n\n /// Note that we are substituting prior template arguments into a\n /// template template parameter.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n NamedDecl *Template,\n TemplateTemplateParmDecl *Param,\n ArrayRef<TemplateArgument> TemplateArgs,\n SourceRange InstantiationRange);\n\n /// Note that we are checking the default template argument\n /// against the template parameter for a given template-id.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n TemplateDecl *Template,\n NamedDecl *Param,\n ArrayRef<TemplateArgument> TemplateArgs,\n SourceRange InstantiationRange);\n\n struct ConstraintsCheck {};\n /// \\brief Note that we are checking the constraints associated with some\n /// constrained entity (a concept declaration or a template with associated\n /// constraints).\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n ConstraintsCheck, NamedDecl *Template,\n ArrayRef<TemplateArgument> TemplateArgs,\n SourceRange InstantiationRange);\n\n struct ConstraintSubstitution {};\n /// \\brief Note that we are checking a constraint expression associated\n /// with a template declaration or as part of the satisfaction check of a\n /// concept.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n ConstraintSubstitution, NamedDecl *Template,\n sema::TemplateDeductionInfo &DeductionInfo,\n SourceRange InstantiationRange);\n\n struct ConstraintNormalization {};\n /// \\brief Note that we are normalizing a constraint expression.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n ConstraintNormalization, NamedDecl *Template,\n SourceRange InstantiationRange);\n\n struct ParameterMappingSubstitution {};\n /// \\brief Note that we are subtituting into the parameter mapping of an\n /// atomic constraint during constraint normalization.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n ParameterMappingSubstitution, NamedDecl *Template,\n SourceRange InstantiationRange);\n\n /// \\brief Note that we are substituting template arguments into a part of\n /// a requirement of a requires expression.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n concepts::Requirement *Req,\n sema::TemplateDeductionInfo &DeductionInfo,\n SourceRange InstantiationRange = SourceRange());\n\n /// \\brief Note that we are checking the satisfaction of the constraint\n /// expression inside of a nested requirement.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n concepts::NestedRequirement *Req, ConstraintsCheck,\n SourceRange InstantiationRange = SourceRange());\n\n /// Note that we have finished instantiating this template.\n void Clear();\n\n ~InstantiatingTemplate() { Clear(); }\n\n /// Determines whether we have exceeded the maximum\n /// recursive template instantiations.\n bool isInvalid() const { return Invalid; }\n\n /// Determine whether we are already instantiating this\n /// specialization in some surrounding active instantiation.\n bool isAlreadyInstantiating() const { return AlreadyInstantiating; }\n\n private:\n Sema &SemaRef;\n bool Invalid;\n bool AlreadyInstantiating;\n bool CheckInstantiationDepth(SourceLocation PointOfInstantiation,\n SourceRange InstantiationRange);\n\n InstantiatingTemplate(\n Sema &SemaRef, CodeSynthesisContext::SynthesisKind Kind,\n SourceLocation PointOfInstantiation, SourceRange InstantiationRange,\n Decl *Entity, NamedDecl *Template = nullptr,\n ArrayRef<TemplateArgument> TemplateArgs = None,\n sema::TemplateDeductionInfo *DeductionInfo = nullptr);\n\n InstantiatingTemplate(const InstantiatingTemplate&) = delete;\n\n InstantiatingTemplate&\n operator=(const InstantiatingTemplate&) = delete;\n };\n\n void pushCodeSynthesisContext(CodeSynthesisContext Ctx);\n void popCodeSynthesisContext();\n\n /// Determine whether we are currently performing template instantiation.\n bool inTemplateInstantiation() const {\n return CodeSynthesisContexts.size() > NonInstantiationEntries;\n }\n\n void PrintContextStack() {\n if (!CodeSynthesisContexts.empty() &&\n CodeSynthesisContexts.size() != LastEmittedCodeSynthesisContextDepth) {\n PrintInstantiationStack();\n LastEmittedCodeSynthesisContextDepth = CodeSynthesisContexts.size();\n }\n if (PragmaAttributeCurrentTargetDecl)\n PrintPragmaAttributeInstantiationPoint();\n }\n void PrintInstantiationStack();\n\n void PrintPragmaAttributeInstantiationPoint();\n\n /// Determines whether we are currently in a context where\n /// template argument substitution failures are not considered\n /// errors.\n ///\n /// \\returns An empty \\c Optional if we're not in a SFINAE context.\n /// Otherwise, contains a pointer that, if non-NULL, contains the nearest\n /// template-deduction context object, which can be used to capture\n /// diagnostics that will be suppressed.\n Optional<sema::TemplateDeductionInfo *> isSFINAEContext() const;\n\n /// Determines whether we are currently in a context that\n /// is not evaluated as per C++ [expr] p5.\n bool isUnevaluatedContext() const {\n assert(!ExprEvalContexts.empty() &&\n \"Must be in an expression evaluation context\");\n return ExprEvalContexts.back().isUnevaluated();\n }\n\n /// RAII class used to determine whether SFINAE has\n /// trapped any errors that occur during template argument\n /// deduction.\n class SFINAETrap {\n Sema &SemaRef;\n unsigned PrevSFINAEErrors;\n bool PrevInNonInstantiationSFINAEContext;\n bool PrevAccessCheckingSFINAE;\n bool PrevLastDiagnosticIgnored;\n\n public:\n explicit SFINAETrap(Sema &SemaRef, bool AccessCheckingSFINAE = false)\n : SemaRef(SemaRef), PrevSFINAEErrors(SemaRef.NumSFINAEErrors),\n PrevInNonInstantiationSFINAEContext(\n SemaRef.InNonInstantiationSFINAEContext),\n PrevAccessCheckingSFINAE(SemaRef.AccessCheckingSFINAE),\n PrevLastDiagnosticIgnored(\n SemaRef.getDiagnostics().isLastDiagnosticIgnored())\n {\n if (!SemaRef.isSFINAEContext())\n SemaRef.InNonInstantiationSFINAEContext = true;\n SemaRef.AccessCheckingSFINAE = AccessCheckingSFINAE;\n }\n\n ~SFINAETrap() {\n SemaRef.NumSFINAEErrors = PrevSFINAEErrors;\n SemaRef.InNonInstantiationSFINAEContext\n = PrevInNonInstantiationSFINAEContext;\n SemaRef.AccessCheckingSFINAE = PrevAccessCheckingSFINAE;\n SemaRef.getDiagnostics().setLastDiagnosticIgnored(\n PrevLastDiagnosticIgnored);\n }\n\n /// Determine whether any SFINAE errors have been trapped.\n bool hasErrorOccurred() const {\n return SemaRef.NumSFINAEErrors > PrevSFINAEErrors;\n }\n };\n\n /// RAII class used to indicate that we are performing provisional\n /// semantic analysis to determine the validity of a construct, so\n /// typo-correction and diagnostics in the immediate context (not within\n /// implicitly-instantiated templates) should be suppressed.\n class TentativeAnalysisScope {\n Sema &SemaRef;\n // FIXME: Using a SFINAETrap for this is a hack.\n SFINAETrap Trap;\n bool PrevDisableTypoCorrection;\n public:\n explicit TentativeAnalysisScope(Sema &SemaRef)\n : SemaRef(SemaRef), Trap(SemaRef, true),\n PrevDisableTypoCorrection(SemaRef.DisableTypoCorrection) {\n SemaRef.DisableTypoCorrection = true;\n }\n ~TentativeAnalysisScope() {\n SemaRef.DisableTypoCorrection = PrevDisableTypoCorrection;\n }\n };\n\n /// The current instantiation scope used to store local\n /// variables.\n LocalInstantiationScope *CurrentInstantiationScope;\n\n /// Tracks whether we are in a context where typo correction is\n /// disabled.\n bool DisableTypoCorrection;\n\n /// The number of typos corrected by CorrectTypo.\n unsigned TyposCorrected;\n\n typedef llvm::SmallSet<SourceLocation, 2> SrcLocSet;\n typedef llvm::DenseMap<IdentifierInfo *, SrcLocSet> IdentifierSourceLocations;\n\n /// A cache containing identifiers for which typo correction failed and\n /// their locations, so that repeated attempts to correct an identifier in a\n /// given location are ignored if typo correction already failed for it.\n IdentifierSourceLocations TypoCorrectionFailures;\n\n /// Worker object for performing CFG-based warnings.\n sema::AnalysisBasedWarnings AnalysisWarnings;\n threadSafety::BeforeSet *ThreadSafetyDeclCache;\n\n /// An entity for which implicit template instantiation is required.\n ///\n /// The source location associated with the declaration is the first place in\n /// the source code where the declaration was \"used\". It is not necessarily\n /// the point of instantiation (which will be either before or after the\n /// namespace-scope declaration that triggered this implicit instantiation),\n /// However, it is the location that diagnostics should generally refer to,\n /// because users will need to know what code triggered the instantiation.\n typedef std::pair<ValueDecl *, SourceLocation> PendingImplicitInstantiation;\n\n /// The queue of implicit template instantiations that are required\n /// but have not yet been performed.\n std::deque<PendingImplicitInstantiation> PendingInstantiations;\n\n /// Queue of implicit template instantiations that cannot be performed\n /// eagerly.\n SmallVector<PendingImplicitInstantiation, 1> LateParsedInstantiations;\n\n class GlobalEagerInstantiationScope {\n public:\n GlobalEagerInstantiationScope(Sema &S, bool Enabled)\n : S(S), Enabled(Enabled) {\n if (!Enabled) return;\n\n SavedPendingInstantiations.swap(S.PendingInstantiations);\n SavedVTableUses.swap(S.VTableUses);\n }\n\n void perform() {\n if (Enabled) {\n S.DefineUsedVTables();\n S.PerformPendingInstantiations();\n }\n }\n\n ~GlobalEagerInstantiationScope() {\n if (!Enabled) return;\n\n // Restore the set of pending vtables.\n assert(S.VTableUses.empty() &&\n \"VTableUses should be empty before it is discarded.\");\n S.VTableUses.swap(SavedVTableUses);\n\n // Restore the set of pending implicit instantiations.\n if (S.TUKind != TU_Prefix || !S.LangOpts.PCHInstantiateTemplates) {\n assert(S.PendingInstantiations.empty() &&\n \"PendingInstantiations should be empty before it is discarded.\");\n S.PendingInstantiations.swap(SavedPendingInstantiations);\n } else {\n // Template instantiations in the PCH may be delayed until the TU.\n S.PendingInstantiations.swap(SavedPendingInstantiations);\n S.PendingInstantiations.insert(S.PendingInstantiations.end(),\n SavedPendingInstantiations.begin(),\n SavedPendingInstantiations.end());\n }\n }\n\n private:\n Sema &S;\n SmallVector<VTableUse, 16> SavedVTableUses;\n std::deque<PendingImplicitInstantiation> SavedPendingInstantiations;\n bool Enabled;\n };\n\n /// The queue of implicit template instantiations that are required\n /// and must be performed within the current local scope.\n ///\n /// This queue is only used for member functions of local classes in\n /// templates, which must be instantiated in the same scope as their\n /// enclosing function, so that they can reference function-local\n /// types, static variables, enumerators, etc.\n std::deque<PendingImplicitInstantiation> PendingLocalImplicitInstantiations;\n\n class LocalEagerInstantiationScope {\n public:\n LocalEagerInstantiationScope(Sema &S) : S(S) {\n SavedPendingLocalImplicitInstantiations.swap(\n S.PendingLocalImplicitInstantiations);\n }\n\n void perform() { S.PerformPendingInstantiations(/*LocalOnly=*/true); }\n\n ~LocalEagerInstantiationScope() {\n assert(S.PendingLocalImplicitInstantiations.empty() &&\n \"there shouldn't be any pending local implicit instantiations\");\n SavedPendingLocalImplicitInstantiations.swap(\n S.PendingLocalImplicitInstantiations);\n }\n\n private:\n Sema &S;\n std::deque<PendingImplicitInstantiation>\n SavedPendingLocalImplicitInstantiations;\n };\n\n /// A helper class for building up ExtParameterInfos.\n class ExtParameterInfoBuilder {\n SmallVector<FunctionProtoType::ExtParameterInfo, 16> Infos;\n bool HasInteresting = false;\n\n public:\n /// Set the ExtParameterInfo for the parameter at the given index,\n ///\n void set(unsigned index, FunctionProtoType::ExtParameterInfo info) {\n assert(Infos.size() <= index);\n Infos.resize(index);\n Infos.push_back(info);\n\n if (!HasInteresting)\n HasInteresting = (info != FunctionProtoType::ExtParameterInfo());\n }\n\n /// Return a pointer (suitable for setting in an ExtProtoInfo) to the\n /// ExtParameterInfo array we've built up.\n const FunctionProtoType::ExtParameterInfo *\n getPointerOrNull(unsigned numParams) {\n if (!HasInteresting) return nullptr;\n Infos.resize(numParams);\n return Infos.data();\n }\n };\n\n void PerformPendingInstantiations(bool LocalOnly = false);\n\n TypeSourceInfo *SubstType(TypeSourceInfo *T,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n SourceLocation Loc, DeclarationName Entity,\n bool AllowDeducedTST = false);\n\n QualType SubstType(QualType T,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n SourceLocation Loc, DeclarationName Entity);\n\n TypeSourceInfo *SubstType(TypeLoc TL,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n SourceLocation Loc, DeclarationName Entity);\n\n TypeSourceInfo *SubstFunctionDeclType(TypeSourceInfo *T,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n SourceLocation Loc,\n DeclarationName Entity,\n CXXRecordDecl *ThisContext,\n Qualifiers ThisTypeQuals);\n void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto,\n const MultiLevelTemplateArgumentList &Args);\n bool SubstExceptionSpec(SourceLocation Loc,\n FunctionProtoType::ExceptionSpecInfo &ESI,\n SmallVectorImpl<QualType> &ExceptionStorage,\n const MultiLevelTemplateArgumentList &Args);\n ParmVarDecl *SubstParmVarDecl(ParmVarDecl *D,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n int indexAdjustment,\n Optional<unsigned> NumExpansions,\n bool ExpectParameterPack);\n bool SubstParmTypes(SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,\n const FunctionProtoType::ExtParameterInfo *ExtParamInfos,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n SmallVectorImpl<QualType> &ParamTypes,\n SmallVectorImpl<ParmVarDecl *> *OutParams,\n ExtParameterInfoBuilder &ParamInfos);\n ExprResult SubstExpr(Expr *E,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n /// Substitute the given template arguments into a list of\n /// expressions, expanding pack expansions if required.\n ///\n /// \\param Exprs The list of expressions to substitute into.\n ///\n /// \\param IsCall Whether this is some form of call, in which case\n /// default arguments will be dropped.\n ///\n /// \\param TemplateArgs The set of template arguments to substitute.\n ///\n /// \\param Outputs Will receive all of the substituted arguments.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n SmallVectorImpl<Expr *> &Outputs);\n\n StmtResult SubstStmt(Stmt *S,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n TemplateParameterList *\n SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n bool\n SubstTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n TemplateArgumentListInfo &Outputs);\n\n\n Decl *SubstDecl(Decl *D, DeclContext *Owner,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n /// Substitute the name and return type of a defaulted 'operator<=>' to form\n /// an implicit 'operator=='.\n FunctionDecl *SubstSpaceshipAsEqualEqual(CXXRecordDecl *RD,\n FunctionDecl *Spaceship);\n\n ExprResult SubstInitializer(Expr *E,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n bool CXXDirectInit);\n\n bool\n SubstBaseSpecifiers(CXXRecordDecl *Instantiation,\n CXXRecordDecl *Pattern,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n bool\n InstantiateClass(SourceLocation PointOfInstantiation,\n CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n TemplateSpecializationKind TSK,\n bool Complain = true);\n\n bool InstantiateEnum(SourceLocation PointOfInstantiation,\n EnumDecl *Instantiation, EnumDecl *Pattern,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n TemplateSpecializationKind TSK);\n\n bool InstantiateInClassInitializer(\n SourceLocation PointOfInstantiation, FieldDecl *Instantiation,\n FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs);\n\n struct LateInstantiatedAttribute {\n const Attr *TmplAttr;\n LocalInstantiationScope *Scope;\n Decl *NewDecl;\n\n LateInstantiatedAttribute(const Attr *A, LocalInstantiationScope *S,\n Decl *D)\n : TmplAttr(A), Scope(S), NewDecl(D)\n { }\n };\n typedef SmallVector<LateInstantiatedAttribute, 16> LateInstantiatedAttrVec;\n\n void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,\n const Decl *Pattern, Decl *Inst,\n LateInstantiatedAttrVec *LateAttrs = nullptr,\n LocalInstantiationScope *OuterMostScope = nullptr);\n\n void\n InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs,\n const Decl *Pattern, Decl *Inst,\n LateInstantiatedAttrVec *LateAttrs = nullptr,\n LocalInstantiationScope *OuterMostScope = nullptr);\n\n void InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor);\n\n bool usesPartialOrExplicitSpecialization(\n SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec);\n\n bool\n InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation,\n ClassTemplateSpecializationDecl *ClassTemplateSpec,\n TemplateSpecializationKind TSK,\n bool Complain = true);\n\n void InstantiateClassMembers(SourceLocation PointOfInstantiation,\n CXXRecordDecl *Instantiation,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n TemplateSpecializationKind TSK);\n\n void InstantiateClassTemplateSpecializationMembers(\n SourceLocation PointOfInstantiation,\n ClassTemplateSpecializationDecl *ClassTemplateSpec,\n TemplateSpecializationKind TSK);\n\n NestedNameSpecifierLoc\n SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n DeclarationNameInfo\n SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n TemplateName\n SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name,\n SourceLocation Loc,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs,\n TemplateArgumentListInfo &Result,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n bool InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD,\n ParmVarDecl *Param);\n void InstantiateExceptionSpec(SourceLocation PointOfInstantiation,\n FunctionDecl *Function);\n bool CheckInstantiatedFunctionTemplateConstraints(\n SourceLocation PointOfInstantiation, FunctionDecl *Decl,\n ArrayRef<TemplateArgument> TemplateArgs,\n ConstraintSatisfaction &Satisfaction);\n FunctionDecl *InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD,\n const TemplateArgumentList *Args,\n SourceLocation Loc);\n void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,\n FunctionDecl *Function,\n bool Recursive = false,\n bool DefinitionRequired = false,\n bool AtEndOfTU = false);\n VarTemplateSpecializationDecl *BuildVarTemplateInstantiation(\n VarTemplateDecl *VarTemplate, VarDecl *FromVar,\n const TemplateArgumentList &TemplateArgList,\n const TemplateArgumentListInfo &TemplateArgsInfo,\n SmallVectorImpl<TemplateArgument> &Converted,\n SourceLocation PointOfInstantiation,\n LateInstantiatedAttrVec *LateAttrs = nullptr,\n LocalInstantiationScope *StartingScope = nullptr);\n VarTemplateSpecializationDecl *CompleteVarTemplateSpecializationDecl(\n VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n void\n BuildVariableInstantiation(VarDecl *NewVar, VarDecl *OldVar,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n LateInstantiatedAttrVec *LateAttrs,\n DeclContext *Owner,\n LocalInstantiationScope *StartingScope,\n bool InstantiatingVarTemplate = false,\n VarTemplateSpecializationDecl *PrevVTSD = nullptr);\n\n void InstantiateVariableInitializer(\n VarDecl *Var, VarDecl *OldVar,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n void InstantiateVariableDefinition(SourceLocation PointOfInstantiation,\n VarDecl *Var, bool Recursive = false,\n bool DefinitionRequired = false,\n bool AtEndOfTU = false);\n\n void InstantiateMemInitializers(CXXConstructorDecl *New,\n const CXXConstructorDecl *Tmpl,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n NamedDecl *FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n bool FindingInstantiatedContext = false);\n DeclContext *FindInstantiatedContext(SourceLocation Loc, DeclContext *DC,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n // Objective-C declarations.\n enum ObjCContainerKind {\n OCK_None = -1,\n OCK_Interface = 0,\n OCK_Protocol,\n OCK_Category,\n OCK_ClassExtension,\n OCK_Implementation,\n OCK_CategoryImplementation\n };\n ObjCContainerKind getObjCContainerKind() const;\n\n DeclResult actOnObjCTypeParam(Scope *S,\n ObjCTypeParamVariance variance,\n SourceLocation varianceLoc,\n unsigned index,\n IdentifierInfo *paramName,\n SourceLocation paramLoc,\n SourceLocation colonLoc,\n ParsedType typeBound);\n\n ObjCTypeParamList *actOnObjCTypeParamList(Scope *S, SourceLocation lAngleLoc,\n ArrayRef<Decl *> typeParams,\n SourceLocation rAngleLoc);\n void popObjCTypeParamList(Scope *S, ObjCTypeParamList *typeParamList);\n\n Decl *ActOnStartClassInterface(\n Scope *S, SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName,\n SourceLocation ClassLoc, ObjCTypeParamList *typeParamList,\n IdentifierInfo *SuperName, SourceLocation SuperLoc,\n ArrayRef<ParsedType> SuperTypeArgs, SourceRange SuperTypeArgsRange,\n Decl *const *ProtoRefs, unsigned NumProtoRefs,\n const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc,\n const ParsedAttributesView &AttrList);\n\n void ActOnSuperClassOfClassInterface(Scope *S,\n SourceLocation AtInterfaceLoc,\n ObjCInterfaceDecl *IDecl,\n IdentifierInfo *ClassName,\n SourceLocation ClassLoc,\n IdentifierInfo *SuperName,\n SourceLocation SuperLoc,\n ArrayRef<ParsedType> SuperTypeArgs,\n SourceRange SuperTypeArgsRange);\n\n void ActOnTypedefedProtocols(SmallVectorImpl<Decl *> &ProtocolRefs,\n SmallVectorImpl<SourceLocation> &ProtocolLocs,\n IdentifierInfo *SuperName,\n SourceLocation SuperLoc);\n\n Decl *ActOnCompatibilityAlias(\n SourceLocation AtCompatibilityAliasLoc,\n IdentifierInfo *AliasName, SourceLocation AliasLocation,\n IdentifierInfo *ClassName, SourceLocation ClassLocation);\n\n bool CheckForwardProtocolDeclarationForCircularDependency(\n IdentifierInfo *PName,\n SourceLocation &PLoc, SourceLocation PrevLoc,\n const ObjCList<ObjCProtocolDecl> &PList);\n\n Decl *ActOnStartProtocolInterface(\n SourceLocation AtProtoInterfaceLoc, IdentifierInfo *ProtocolName,\n SourceLocation ProtocolLoc, Decl *const *ProtoRefNames,\n unsigned NumProtoRefs, const SourceLocation *ProtoLocs,\n SourceLocation EndProtoLoc, const ParsedAttributesView &AttrList);\n\n Decl *ActOnStartCategoryInterface(\n SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName,\n SourceLocation ClassLoc, ObjCTypeParamList *typeParamList,\n IdentifierInfo *CategoryName, SourceLocation CategoryLoc,\n Decl *const *ProtoRefs, unsigned NumProtoRefs,\n const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc,\n const ParsedAttributesView &AttrList);\n\n Decl *ActOnStartClassImplementation(SourceLocation AtClassImplLoc,\n IdentifierInfo *ClassName,\n SourceLocation ClassLoc,\n IdentifierInfo *SuperClassname,\n SourceLocation SuperClassLoc,\n const ParsedAttributesView &AttrList);\n\n Decl *ActOnStartCategoryImplementation(SourceLocation AtCatImplLoc,\n IdentifierInfo *ClassName,\n SourceLocation ClassLoc,\n IdentifierInfo *CatName,\n SourceLocation CatLoc,\n const ParsedAttributesView &AttrList);\n\n DeclGroupPtrTy ActOnFinishObjCImplementation(Decl *ObjCImpDecl,\n ArrayRef<Decl *> Decls);\n\n DeclGroupPtrTy ActOnForwardClassDeclaration(SourceLocation Loc,\n IdentifierInfo **IdentList,\n SourceLocation *IdentLocs,\n ArrayRef<ObjCTypeParamList *> TypeParamLists,\n unsigned NumElts);\n\n DeclGroupPtrTy\n ActOnForwardProtocolDeclaration(SourceLocation AtProtoclLoc,\n ArrayRef<IdentifierLocPair> IdentList,\n const ParsedAttributesView &attrList);\n\n void FindProtocolDeclaration(bool WarnOnDeclarations, bool ForObjCContainer,\n ArrayRef<IdentifierLocPair> ProtocolId,\n SmallVectorImpl<Decl *> &Protocols);\n\n void DiagnoseTypeArgsAndProtocols(IdentifierInfo *ProtocolId,\n SourceLocation ProtocolLoc,\n IdentifierInfo *TypeArgId,\n SourceLocation TypeArgLoc,\n bool SelectProtocolFirst = false);\n\n /// Given a list of identifiers (and their locations), resolve the\n /// names to either Objective-C protocol qualifiers or type\n /// arguments, as appropriate.\n void actOnObjCTypeArgsOrProtocolQualifiers(\n Scope *S,\n ParsedType baseType,\n SourceLocation lAngleLoc,\n ArrayRef<IdentifierInfo *> identifiers,\n ArrayRef<SourceLocation> identifierLocs,\n SourceLocation rAngleLoc,\n SourceLocation &typeArgsLAngleLoc,\n SmallVectorImpl<ParsedType> &typeArgs,\n SourceLocation &typeArgsRAngleLoc,\n SourceLocation &protocolLAngleLoc,\n SmallVectorImpl<Decl *> &protocols,\n SourceLocation &protocolRAngleLoc,\n bool warnOnIncompleteProtocols);\n\n /// Build a an Objective-C protocol-qualified 'id' type where no\n /// base type was specified.\n TypeResult actOnObjCProtocolQualifierType(\n SourceLocation lAngleLoc,\n ArrayRef<Decl *> protocols,\n ArrayRef<SourceLocation> protocolLocs,\n SourceLocation rAngleLoc);\n\n /// Build a specialized and/or protocol-qualified Objective-C type.\n TypeResult actOnObjCTypeArgsAndProtocolQualifiers(\n Scope *S,\n SourceLocation Loc,\n ParsedType BaseType,\n SourceLocation TypeArgsLAngleLoc,\n ArrayRef<ParsedType> TypeArgs,\n SourceLocation TypeArgsRAngleLoc,\n SourceLocation ProtocolLAngleLoc,\n ArrayRef<Decl *> Protocols,\n ArrayRef<SourceLocation> ProtocolLocs,\n SourceLocation ProtocolRAngleLoc);\n\n /// Build an Objective-C type parameter type.\n QualType BuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,\n SourceLocation ProtocolLAngleLoc,\n ArrayRef<ObjCProtocolDecl *> Protocols,\n ArrayRef<SourceLocation> ProtocolLocs,\n SourceLocation ProtocolRAngleLoc,\n bool FailOnError = false);\n\n /// Build an Objective-C object pointer type.\n QualType BuildObjCObjectType(QualType BaseType,\n SourceLocation Loc,\n SourceLocation TypeArgsLAngleLoc,\n ArrayRef<TypeSourceInfo *> TypeArgs,\n SourceLocation TypeArgsRAngleLoc,\n SourceLocation ProtocolLAngleLoc,\n ArrayRef<ObjCProtocolDecl *> Protocols,\n ArrayRef<SourceLocation> ProtocolLocs,\n SourceLocation ProtocolRAngleLoc,\n bool FailOnError = false);\n\n /// Ensure attributes are consistent with type.\n /// \\param [in, out] Attributes The attributes to check; they will\n /// be modified to be consistent with \\p PropertyTy.\n void CheckObjCPropertyAttributes(Decl *PropertyPtrTy,\n SourceLocation Loc,\n unsigned &Attributes,\n bool propertyInPrimaryClass);\n\n /// Process the specified property declaration and create decls for the\n /// setters and getters as needed.\n /// \\param property The property declaration being processed\n void ProcessPropertyDecl(ObjCPropertyDecl *property);\n\n\n void DiagnosePropertyMismatch(ObjCPropertyDecl *Property,\n ObjCPropertyDecl *SuperProperty,\n const IdentifierInfo *Name,\n bool OverridingProtocolProperty);\n\n void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,\n ObjCInterfaceDecl *ID);\n\n Decl *ActOnAtEnd(Scope *S, SourceRange AtEnd,\n ArrayRef<Decl *> allMethods = None,\n ArrayRef<DeclGroupPtrTy> allTUVars = None);\n\n Decl *ActOnProperty(Scope *S, SourceLocation AtLoc,\n SourceLocation LParenLoc,\n FieldDeclarator &FD, ObjCDeclSpec &ODS,\n Selector GetterSel, Selector SetterSel,\n tok::ObjCKeywordKind MethodImplKind,\n DeclContext *lexicalDC = nullptr);\n\n Decl *ActOnPropertyImplDecl(Scope *S,\n SourceLocation AtLoc,\n SourceLocation PropertyLoc,\n bool ImplKind,\n IdentifierInfo *PropertyId,\n IdentifierInfo *PropertyIvar,\n SourceLocation PropertyIvarLoc,\n ObjCPropertyQueryKind QueryKind);\n\n enum ObjCSpecialMethodKind {\n OSMK_None,\n OSMK_Alloc,\n OSMK_New,\n OSMK_Copy,\n OSMK_RetainingInit,\n OSMK_NonRetainingInit\n };\n\n struct ObjCArgInfo {\n IdentifierInfo *Name;\n SourceLocation NameLoc;\n // The Type is null if no type was specified, and the DeclSpec is invalid\n // in this case.\n ParsedType Type;\n ObjCDeclSpec DeclSpec;\n\n /// ArgAttrs - Attribute list for this argument.\n ParsedAttributesView ArgAttrs;\n };\n\n Decl *ActOnMethodDeclaration(\n Scope *S,\n SourceLocation BeginLoc, // location of the + or -.\n SourceLocation EndLoc, // location of the ; or {.\n tok::TokenKind MethodType, ObjCDeclSpec &ReturnQT, ParsedType ReturnType,\n ArrayRef<SourceLocation> SelectorLocs, Selector Sel,\n // optional arguments. The number of types/arguments is obtained\n // from the Sel.getNumArgs().\n ObjCArgInfo *ArgInfo, DeclaratorChunk::ParamInfo *CParamInfo,\n unsigned CNumArgs, // c-style args\n const ParsedAttributesView &AttrList, tok::ObjCKeywordKind MethodImplKind,\n bool isVariadic, bool MethodDefinition);\n\n ObjCMethodDecl *LookupMethodInQualifiedType(Selector Sel,\n const ObjCObjectPointerType *OPT,\n bool IsInstance);\n ObjCMethodDecl *LookupMethodInObjectType(Selector Sel, QualType Ty,\n bool IsInstance);\n\n bool CheckARCMethodDecl(ObjCMethodDecl *method);\n bool inferObjCARCLifetime(ValueDecl *decl);\n\n void deduceOpenCLAddressSpace(ValueDecl *decl);\n\n ExprResult\n HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT,\n Expr *BaseExpr,\n SourceLocation OpLoc,\n DeclarationName MemberName,\n SourceLocation MemberLoc,\n SourceLocation SuperLoc, QualType SuperType,\n bool Super);\n\n ExprResult\n ActOnClassPropertyRefExpr(IdentifierInfo &receiverName,\n IdentifierInfo &propertyName,\n SourceLocation receiverNameLoc,\n SourceLocation propertyNameLoc);\n\n ObjCMethodDecl *tryCaptureObjCSelf(SourceLocation Loc);\n\n /// Describes the kind of message expression indicated by a message\n /// send that starts with an identifier.\n enum ObjCMessageKind {\n /// The message is sent to 'super'.\n ObjCSuperMessage,\n /// The message is an instance message.\n ObjCInstanceMessage,\n /// The message is a class message, and the identifier is a type\n /// name.\n ObjCClassMessage\n };\n\n ObjCMessageKind getObjCMessageKind(Scope *S,\n IdentifierInfo *Name,\n SourceLocation NameLoc,\n bool IsSuper,\n bool HasTrailingDot,\n ParsedType &ReceiverType);\n\n ExprResult ActOnSuperMessage(Scope *S, SourceLocation SuperLoc,\n Selector Sel,\n SourceLocation LBracLoc,\n ArrayRef<SourceLocation> SelectorLocs,\n SourceLocation RBracLoc,\n MultiExprArg Args);\n\n ExprResult BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo,\n QualType ReceiverType,\n SourceLocation SuperLoc,\n Selector Sel,\n ObjCMethodDecl *Method,\n SourceLocation LBracLoc,\n ArrayRef<SourceLocation> SelectorLocs,\n SourceLocation RBracLoc,\n MultiExprArg Args,\n bool isImplicit = false);\n\n ExprResult BuildClassMessageImplicit(QualType ReceiverType,\n bool isSuperReceiver,\n SourceLocation Loc,\n Selector Sel,\n ObjCMethodDecl *Method,\n MultiExprArg Args);\n\n ExprResult ActOnClassMessage(Scope *S,\n ParsedType Receiver,\n Selector Sel,\n SourceLocation LBracLoc,\n ArrayRef<SourceLocation> SelectorLocs,\n SourceLocation RBracLoc,\n MultiExprArg Args);\n\n ExprResult BuildInstanceMessage(Expr *Receiver,\n QualType ReceiverType,\n SourceLocation SuperLoc,\n Selector Sel,\n ObjCMethodDecl *Method,\n SourceLocation LBracLoc,\n ArrayRef<SourceLocation> SelectorLocs,\n SourceLocation RBracLoc,\n MultiExprArg Args,\n bool isImplicit = false);\n\n ExprResult BuildInstanceMessageImplicit(Expr *Receiver,\n QualType ReceiverType,\n SourceLocation Loc,\n Selector Sel,\n ObjCMethodDecl *Method,\n MultiExprArg Args);\n\n ExprResult ActOnInstanceMessage(Scope *S,\n Expr *Receiver,\n Selector Sel,\n SourceLocation LBracLoc,\n ArrayRef<SourceLocation> SelectorLocs,\n SourceLocation RBracLoc,\n MultiExprArg Args);\n\n ExprResult BuildObjCBridgedCast(SourceLocation LParenLoc,\n ObjCBridgeCastKind Kind,\n SourceLocation BridgeKeywordLoc,\n TypeSourceInfo *TSInfo,\n Expr *SubExpr);\n\n ExprResult ActOnObjCBridgedCast(Scope *S,\n SourceLocation LParenLoc,\n ObjCBridgeCastKind Kind,\n SourceLocation BridgeKeywordLoc,\n ParsedType Type,\n SourceLocation RParenLoc,\n Expr *SubExpr);\n\n void CheckTollFreeBridgeCast(QualType castType, Expr *castExpr);\n\n void CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr);\n\n bool CheckTollFreeBridgeStaticCast(QualType castType, Expr *castExpr,\n CastKind &Kind);\n\n bool checkObjCBridgeRelatedComponents(SourceLocation Loc,\n QualType DestType, QualType SrcType,\n ObjCInterfaceDecl *&RelatedClass,\n ObjCMethodDecl *&ClassMethod,\n ObjCMethodDecl *&InstanceMethod,\n TypedefNameDecl *&TDNDecl,\n bool CfToNs, bool Diagnose = true);\n\n bool CheckObjCBridgeRelatedConversions(SourceLocation Loc,\n QualType DestType, QualType SrcType,\n Expr *&SrcExpr, bool Diagnose = true);\n\n bool CheckConversionToObjCLiteral(QualType DstType, Expr *&SrcExpr,\n bool Diagnose = true);\n\n bool checkInitMethod(ObjCMethodDecl *method, QualType receiverTypeIfCall);\n\n /// Check whether the given new method is a valid override of the\n /// given overridden method, and set any properties that should be inherited.\n void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod,\n const ObjCMethodDecl *Overridden);\n\n /// Describes the compatibility of a result type with its method.\n enum ResultTypeCompatibilityKind {\n RTC_Compatible,\n RTC_Incompatible,\n RTC_Unknown\n };\n\n void CheckObjCMethodDirectOverrides(ObjCMethodDecl *method,\n ObjCMethodDecl *overridden);\n\n void CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod,\n ObjCInterfaceDecl *CurrentClass,\n ResultTypeCompatibilityKind RTC);\n\n enum PragmaOptionsAlignKind {\n POAK_Native, // #pragma options align=native\n POAK_Natural, // #pragma options align=natural\n POAK_Packed, // #pragma options align=packed\n POAK_Power, // #pragma options align=power\n POAK_Mac68k, // #pragma options align=mac68k\n POAK_Reset // #pragma options align=reset\n };\n\n /// ActOnPragmaClangSection - Called on well formed \\#pragma clang section\n void ActOnPragmaClangSection(SourceLocation PragmaLoc,\n PragmaClangSectionAction Action,\n PragmaClangSectionKind SecKind, StringRef SecName);\n\n /// ActOnPragmaOptionsAlign - Called on well formed \\#pragma options align.\n void ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,\n SourceLocation PragmaLoc);\n\n /// ActOnPragmaPack - Called on well formed \\#pragma pack(...).\n void ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action,\n StringRef SlotLabel, Expr *Alignment);\n\n enum class PragmaAlignPackDiagnoseKind {\n NonDefaultStateAtInclude,\n ChangedStateAtExit\n };\n\n void DiagnoseNonDefaultPragmaAlignPack(PragmaAlignPackDiagnoseKind Kind,\n SourceLocation IncludeLoc);\n void DiagnoseUnterminatedPragmaAlignPack();\n\n /// ActOnPragmaMSStruct - Called on well formed \\#pragma ms_struct [on|off].\n void ActOnPragmaMSStruct(PragmaMSStructKind Kind);\n\n /// ActOnPragmaMSComment - Called on well formed\n /// \\#pragma comment(kind, \"arg\").\n void ActOnPragmaMSComment(SourceLocation CommentLoc, PragmaMSCommentKind Kind,\n StringRef Arg);\n\n /// ActOnPragmaMSPointersToMembers - called on well formed \\#pragma\n /// pointers_to_members(representation method[, general purpose\n /// representation]).\n void ActOnPragmaMSPointersToMembers(\n LangOptions::PragmaMSPointersToMembersKind Kind,\n SourceLocation PragmaLoc);\n\n /// Called on well formed \\#pragma vtordisp().\n void ActOnPragmaMSVtorDisp(PragmaMsStackAction Action,\n SourceLocation PragmaLoc,\n MSVtorDispMode Value);\n\n enum PragmaSectionKind {\n PSK_DataSeg,\n PSK_BSSSeg,\n PSK_ConstSeg,\n PSK_CodeSeg,\n };\n\n bool UnifySection(StringRef SectionName, int SectionFlags,\n NamedDecl *TheDecl);\n bool UnifySection(StringRef SectionName,\n int SectionFlags,\n SourceLocation PragmaSectionLocation);\n\n /// Called on well formed \\#pragma bss_seg/data_seg/const_seg/code_seg.\n void ActOnPragmaMSSeg(SourceLocation PragmaLocation,\n PragmaMsStackAction Action,\n llvm::StringRef StackSlotLabel,\n StringLiteral *SegmentName,\n llvm::StringRef PragmaName);\n\n /// Called on well formed \\#pragma section().\n void ActOnPragmaMSSection(SourceLocation PragmaLocation,\n int SectionFlags, StringLiteral *SegmentName);\n\n /// Called on well-formed \\#pragma init_seg().\n void ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,\n StringLiteral *SegmentName);\n\n /// Called on #pragma clang __debug dump II\n void ActOnPragmaDump(Scope *S, SourceLocation Loc, IdentifierInfo *II);\n\n /// ActOnPragmaDetectMismatch - Call on well-formed \\#pragma detect_mismatch\n void ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name,\n StringRef Value);\n\n /// Are precise floating point semantics currently enabled?\n bool isPreciseFPEnabled() {\n return !CurFPFeatures.getAllowFPReassociate() &&\n !CurFPFeatures.getNoSignedZero() &&\n !CurFPFeatures.getAllowReciprocal() &&\n !CurFPFeatures.getAllowApproxFunc();\n }\n\n /// ActOnPragmaFloatControl - Call on well-formed \\#pragma float_control\n void ActOnPragmaFloatControl(SourceLocation Loc, PragmaMsStackAction Action,\n PragmaFloatControlKind Value);\n\n /// ActOnPragmaUnused - Called on well-formed '\\#pragma unused'.\n void ActOnPragmaUnused(const Token &Identifier,\n Scope *curScope,\n SourceLocation PragmaLoc);\n\n /// ActOnPragmaVisibility - Called on well formed \\#pragma GCC visibility... .\n void ActOnPragmaVisibility(const IdentifierInfo* VisType,\n SourceLocation PragmaLoc);\n\n NamedDecl *DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II,\n SourceLocation Loc);\n void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W);\n\n /// ActOnPragmaWeakID - Called on well formed \\#pragma weak ident.\n void ActOnPragmaWeakID(IdentifierInfo* WeakName,\n SourceLocation PragmaLoc,\n SourceLocation WeakNameLoc);\n\n /// ActOnPragmaRedefineExtname - Called on well formed\n /// \\#pragma redefine_extname oldname newname.\n void ActOnPragmaRedefineExtname(IdentifierInfo* WeakName,\n IdentifierInfo* AliasName,\n SourceLocation PragmaLoc,\n SourceLocation WeakNameLoc,\n SourceLocation AliasNameLoc);\n\n /// ActOnPragmaWeakAlias - Called on well formed \\#pragma weak ident = ident.\n void ActOnPragmaWeakAlias(IdentifierInfo* WeakName,\n IdentifierInfo* AliasName,\n SourceLocation PragmaLoc,\n SourceLocation WeakNameLoc,\n SourceLocation AliasNameLoc);\n\n /// ActOnPragmaFPContract - Called on well formed\n /// \\#pragma {STDC,OPENCL} FP_CONTRACT and\n /// \\#pragma clang fp contract\n void ActOnPragmaFPContract(SourceLocation Loc, LangOptions::FPModeKind FPC);\n\n /// Called on well formed\n /// \\#pragma clang fp reassociate\n void ActOnPragmaFPReassociate(SourceLocation Loc, bool IsEnabled);\n\n /// ActOnPragmaFenvAccess - Called on well formed\n /// \\#pragma STDC FENV_ACCESS\n void ActOnPragmaFEnvAccess(SourceLocation Loc, bool IsEnabled);\n\n /// Called on well formed '\\#pragma clang fp' that has option 'exceptions'.\n void ActOnPragmaFPExceptions(SourceLocation Loc,\n LangOptions::FPExceptionModeKind);\n\n /// Called to set constant rounding mode for floating point operations.\n void setRoundingMode(SourceLocation Loc, llvm::RoundingMode);\n\n /// Called to set exception behavior for floating point operations.\n void setExceptionMode(SourceLocation Loc, LangOptions::FPExceptionModeKind);\n\n /// AddAlignmentAttributesForRecord - Adds any needed alignment attributes to\n /// a the record decl, to handle '\\#pragma pack' and '\\#pragma options align'.\n void AddAlignmentAttributesForRecord(RecordDecl *RD);\n\n /// AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record.\n void AddMsStructLayoutForRecord(RecordDecl *RD);\n\n /// PushNamespaceVisibilityAttr - Note that we've entered a\n /// namespace with a visibility attribute.\n void PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,\n SourceLocation Loc);\n\n /// AddPushedVisibilityAttribute - If '\\#pragma GCC visibility' was used,\n /// add an appropriate visibility attribute.\n void AddPushedVisibilityAttribute(Decl *RD);\n\n /// PopPragmaVisibility - Pop the top element of the visibility stack; used\n /// for '\\#pragma GCC visibility' and visibility attributes on namespaces.\n void PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc);\n\n /// FreeVisContext - Deallocate and null out VisContext.\n void FreeVisContext();\n\n /// AddCFAuditedAttribute - Check whether we're currently within\n /// '\\#pragma clang arc_cf_code_audited' and, if so, consider adding\n /// the appropriate attribute.\n void AddCFAuditedAttribute(Decl *D);\n\n void ActOnPragmaAttributeAttribute(ParsedAttr &Attribute,\n SourceLocation PragmaLoc,\n attr::ParsedSubjectMatchRuleSet Rules);\n void ActOnPragmaAttributeEmptyPush(SourceLocation PragmaLoc,\n const IdentifierInfo *Namespace);\n\n /// Called on well-formed '\\#pragma clang attribute pop'.\n void ActOnPragmaAttributePop(SourceLocation PragmaLoc,\n const IdentifierInfo *Namespace);\n\n /// Adds the attributes that have been specified using the\n /// '\\#pragma clang attribute push' directives to the given declaration.\n void AddPragmaAttributes(Scope *S, Decl *D);\n\n void DiagnoseUnterminatedPragmaAttribute();\n\n /// Called on well formed \\#pragma clang optimize.\n void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc);\n\n /// Get the location for the currently active \"\\#pragma clang optimize\n /// off\". If this location is invalid, then the state of the pragma is \"on\".\n SourceLocation getOptimizeOffPragmaLocation() const {\n return OptimizeOffPragmaLocation;\n }\n\n /// Only called on function definitions; if there is a pragma in scope\n /// with the effect of a range-based optnone, consider marking the function\n /// with attribute optnone.\n void AddRangeBasedOptnone(FunctionDecl *FD);\n\n /// Adds the 'optnone' attribute to the function declaration if there\n /// are no conflicts; Loc represents the location causing the 'optnone'\n /// attribute to be added (usually because of a pragma).\n void AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc);\n\n /// AddAlignedAttr - Adds an aligned attribute to a particular declaration.\n void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,\n bool IsPackExpansion);\n void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, TypeSourceInfo *T,\n bool IsPackExpansion);\n\n /// AddAssumeAlignedAttr - Adds an assume_aligned attribute to a particular\n /// declaration.\n void AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,\n Expr *OE);\n\n /// AddAllocAlignAttr - Adds an alloc_align attribute to a particular\n /// declaration.\n void AddAllocAlignAttr(Decl *D, const AttributeCommonInfo &CI,\n Expr *ParamExpr);\n\n /// AddAlignValueAttr - Adds an align_value attribute to a particular\n /// declaration.\n void AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E);\n\n /// AddAnnotationAttr - Adds an annotation Annot with Args arguments to D.\n void AddAnnotationAttr(Decl *D, const AttributeCommonInfo &CI,\n StringRef Annot, MutableArrayRef<Expr *> Args);\n\n /// AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular\n /// declaration.\n void AddLaunchBoundsAttr(Decl *D, const AttributeCommonInfo &CI,\n Expr *MaxThreads, Expr *MinBlocks);\n\n /// AddModeAttr - Adds a mode attribute to a particular declaration.\n void AddModeAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Name,\n bool InInstantiation = false);\n\n void AddParameterABIAttr(Decl *D, const AttributeCommonInfo &CI,\n ParameterABI ABI);\n\n enum class RetainOwnershipKind {NS, CF, OS};\n void AddXConsumedAttr(Decl *D, const AttributeCommonInfo &CI,\n RetainOwnershipKind K, bool IsTemplateInstantiation);\n\n /// addAMDGPUFlatWorkGroupSizeAttr - Adds an amdgpu_flat_work_group_size\n /// attribute to a particular declaration.\n void addAMDGPUFlatWorkGroupSizeAttr(Decl *D, const AttributeCommonInfo &CI,\n Expr *Min, Expr *Max);\n\n /// addAMDGPUWavePersEUAttr - Adds an amdgpu_waves_per_eu attribute to a\n /// particular declaration.\n void addAMDGPUWavesPerEUAttr(Decl *D, const AttributeCommonInfo &CI,\n Expr *Min, Expr *Max);\n\n bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type);\n\n //===--------------------------------------------------------------------===//\n // C++ Coroutines TS\n //\n bool ActOnCoroutineBodyStart(Scope *S, SourceLocation KwLoc,\n StringRef Keyword);\n ExprResult ActOnCoawaitExpr(Scope *S, SourceLocation KwLoc, Expr *E);\n ExprResult ActOnCoyieldExpr(Scope *S, SourceLocation KwLoc, Expr *E);\n StmtResult ActOnCoreturnStmt(Scope *S, SourceLocation KwLoc, Expr *E);\n\n ExprResult BuildResolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,\n bool IsImplicit = false);\n ExprResult BuildUnresolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,\n UnresolvedLookupExpr* Lookup);\n ExprResult BuildCoyieldExpr(SourceLocation KwLoc, Expr *E);\n StmtResult BuildCoreturnStmt(SourceLocation KwLoc, Expr *E,\n bool IsImplicit = false);\n StmtResult BuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs);\n bool buildCoroutineParameterMoves(SourceLocation Loc);\n VarDecl *buildCoroutinePromise(SourceLocation Loc);\n void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body);\n ClassTemplateDecl *lookupCoroutineTraits(SourceLocation KwLoc,\n SourceLocation FuncLoc);\n /// Check that the expression co_await promise.final_suspend() shall not be\n /// potentially-throwing.\n bool checkFinalSuspendNoThrow(const Stmt *FinalSuspend);\n\n //===--------------------------------------------------------------------===//\n // OpenCL extensions.\n //\nprivate:\n std::string CurrOpenCLExtension;\n /// Extensions required by an OpenCL type.\n llvm::DenseMap<const Type*, std::set<std::string>> OpenCLTypeExtMap;\n /// Extensions required by an OpenCL declaration.\n llvm::DenseMap<const Decl*, std::set<std::string>> OpenCLDeclExtMap;\npublic:\n llvm::StringRef getCurrentOpenCLExtension() const {\n return CurrOpenCLExtension;\n }\n\n /// Check if a function declaration \\p FD associates with any\n /// extensions present in OpenCLDeclExtMap and if so return the\n /// extension(s) name(s).\n std::string getOpenCLExtensionsFromDeclExtMap(FunctionDecl *FD);\n\n /// Check if a function type \\p FT associates with any\n /// extensions present in OpenCLTypeExtMap and if so return the\n /// extension(s) name(s).\n std::string getOpenCLExtensionsFromTypeExtMap(FunctionType *FT);\n\n /// Find an extension in an appropriate extension map and return its name\n template<typename T, typename MapT>\n std::string getOpenCLExtensionsFromExtMap(T* FT, MapT &Map);\n\n void setCurrentOpenCLExtension(llvm::StringRef Ext) {\n CurrOpenCLExtension = std::string(Ext);\n }\n\n /// Set OpenCL extensions for a type which can only be used when these\n /// OpenCL extensions are enabled. If \\p Exts is empty, do nothing.\n /// \\param Exts A space separated list of OpenCL extensions.\n void setOpenCLExtensionForType(QualType T, llvm::StringRef Exts);\n\n /// Set OpenCL extensions for a declaration which can only be\n /// used when these OpenCL extensions are enabled. If \\p Exts is empty, do\n /// nothing.\n /// \\param Exts A space separated list of OpenCL extensions.\n void setOpenCLExtensionForDecl(Decl *FD, llvm::StringRef Exts);\n\n /// Set current OpenCL extensions for a type which can only be used\n /// when these OpenCL extensions are enabled. If current OpenCL extension is\n /// empty, do nothing.\n void setCurrentOpenCLExtensionForType(QualType T);\n\n /// Set current OpenCL extensions for a declaration which\n /// can only be used when these OpenCL extensions are enabled. If current\n /// OpenCL extension is empty, do nothing.\n void setCurrentOpenCLExtensionForDecl(Decl *FD);\n\n bool isOpenCLDisabledDecl(Decl *FD);\n\n /// Check if type \\p T corresponding to declaration specifier \\p DS\n /// is disabled due to required OpenCL extensions being disabled. If so,\n /// emit diagnostics.\n /// \\return true if type is disabled.\n bool checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType T);\n\n /// Check if declaration \\p D used by expression \\p E\n /// is disabled due to required OpenCL extensions being disabled. If so,\n /// emit diagnostics.\n /// \\return true if type is disabled.\n bool checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E);\n\n //===--------------------------------------------------------------------===//\n // OpenMP directives and clauses.\n //\nprivate:\n void *VarDataSharingAttributesStack;\n /// Number of nested '#pragma omp declare target' directives.\n SmallVector<SourceLocation, 4> DeclareTargetNesting;\n /// Initialization of data-sharing attributes stack.\n void InitDataSharingAttributesStack();\n void DestroyDataSharingAttributesStack();\n ExprResult\n VerifyPositiveIntegerConstantInClause(Expr *Op, OpenMPClauseKind CKind,\n bool StrictlyPositive = true);\n /// Returns OpenMP nesting level for current directive.\n unsigned getOpenMPNestingLevel() const;\n\n /// Adjusts the function scopes index for the target-based regions.\n void adjustOpenMPTargetScopeIndex(unsigned &FunctionScopesIndex,\n unsigned Level) const;\n\n /// Returns the number of scopes associated with the construct on the given\n /// OpenMP level.\n int getNumberOfConstructScopes(unsigned Level) const;\n\n /// Push new OpenMP function region for non-capturing function.\n void pushOpenMPFunctionRegion();\n\n /// Pop OpenMP function region for non-capturing function.\n void popOpenMPFunctionRegion(const sema::FunctionScopeInfo *OldFSI);\n\n /// Checks if a type or a declaration is disabled due to the owning extension\n /// being disabled, and emits diagnostic messages if it is disabled.\n /// \\param D type or declaration to be checked.\n /// \\param DiagLoc source location for the diagnostic message.\n /// \\param DiagInfo information to be emitted for the diagnostic message.\n /// \\param SrcRange source range of the declaration.\n /// \\param Map maps type or declaration to the extensions.\n /// \\param Selector selects diagnostic message: 0 for type and 1 for\n /// declaration.\n /// \\return true if the type or declaration is disabled.\n template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>\n bool checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc, DiagInfoT DiagInfo,\n MapT &Map, unsigned Selector = 0,\n SourceRange SrcRange = SourceRange());\n\n /// Helper to keep information about the current `omp begin/end declare\n /// variant` nesting.\n struct OMPDeclareVariantScope {\n /// The associated OpenMP context selector.\n OMPTraitInfo *TI;\n\n /// The associated OpenMP context selector mangling.\n std::string NameSuffix;\n\n OMPDeclareVariantScope(OMPTraitInfo &TI);\n };\n\n /// Return the OMPTraitInfo for the surrounding scope, if any.\n OMPTraitInfo *getOMPTraitInfoForSurroundingScope() {\n return OMPDeclareVariantScopes.empty() ? nullptr\n : OMPDeclareVariantScopes.back().TI;\n }\n\n /// The current `omp begin/end declare variant` scopes.\n SmallVector<OMPDeclareVariantScope, 4> OMPDeclareVariantScopes;\n\n /// The current `omp begin/end assumes` scopes.\n SmallVector<AssumptionAttr *, 4> OMPAssumeScoped;\n\n /// All `omp assumes` we encountered so far.\n SmallVector<AssumptionAttr *, 4> OMPAssumeGlobal;\n\npublic:\n /// The declarator \\p D defines a function in the scope \\p S which is nested\n /// in an `omp begin/end declare variant` scope. In this method we create a\n /// declaration for \\p D and rename \\p D according to the OpenMP context\n /// selector of the surrounding scope. Return all base functions in \\p Bases.\n void ActOnStartOfFunctionDefinitionInOpenMPDeclareVariantScope(\n Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists,\n SmallVectorImpl<FunctionDecl *> &Bases);\n\n /// Register \\p D as specialization of all base functions in \\p Bases in the\n /// current `omp begin/end declare variant` scope.\n void ActOnFinishedFunctionDefinitionInOpenMPDeclareVariantScope(\n Decl *D, SmallVectorImpl<FunctionDecl *> &Bases);\n\n /// Act on \\p D, a function definition inside of an `omp [begin/end] assumes`.\n void ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(Decl *D);\n\n /// Can we exit an OpenMP declare variant scope at the moment.\n bool isInOpenMPDeclareVariantScope() const {\n return !OMPDeclareVariantScopes.empty();\n }\n\n /// Given the potential call expression \\p Call, determine if there is a\n /// specialization via the OpenMP declare variant mechanism available. If\n /// there is, return the specialized call expression, otherwise return the\n /// original \\p Call.\n ExprResult ActOnOpenMPCall(ExprResult Call, Scope *Scope,\n SourceLocation LParenLoc, MultiExprArg ArgExprs,\n SourceLocation RParenLoc, Expr *ExecConfig);\n\n /// Handle a `omp begin declare variant`.\n void ActOnOpenMPBeginDeclareVariant(SourceLocation Loc, OMPTraitInfo &TI);\n\n /// Handle a `omp end declare variant`.\n void ActOnOpenMPEndDeclareVariant();\n\n /// Checks if the variant/multiversion functions are compatible.\n bool areMultiversionVariantFunctionsCompatible(\n const FunctionDecl *OldFD, const FunctionDecl *NewFD,\n const PartialDiagnostic &NoProtoDiagID,\n const PartialDiagnosticAt &NoteCausedDiagIDAt,\n const PartialDiagnosticAt &NoSupportDiagIDAt,\n const PartialDiagnosticAt &DiffDiagIDAt, bool TemplatesSupported,\n bool ConstexprSupported, bool CLinkageMayDiffer);\n\n /// Function tries to capture lambda's captured variables in the OpenMP region\n /// before the original lambda is captured.\n void tryCaptureOpenMPLambdas(ValueDecl *V);\n\n /// Return true if the provided declaration \\a VD should be captured by\n /// reference.\n /// \\param Level Relative level of nested OpenMP construct for that the check\n /// is performed.\n /// \\param OpenMPCaptureLevel Capture level within an OpenMP construct.\n bool isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level,\n unsigned OpenMPCaptureLevel) const;\n\n /// Check if the specified variable is used in one of the private\n /// clauses (private, firstprivate, lastprivate, reduction etc.) in OpenMP\n /// constructs.\n VarDecl *isOpenMPCapturedDecl(ValueDecl *D, bool CheckScopeInfo = false,\n unsigned StopAt = 0);\n ExprResult getOpenMPCapturedExpr(VarDecl *Capture, ExprValueKind VK,\n ExprObjectKind OK, SourceLocation Loc);\n\n /// If the current region is a loop-based region, mark the start of the loop\n /// construct.\n void startOpenMPLoop();\n\n /// If the current region is a range loop-based region, mark the start of the\n /// loop construct.\n void startOpenMPCXXRangeFor();\n\n /// Check if the specified variable is used in 'private' clause.\n /// \\param Level Relative level of nested OpenMP construct for that the check\n /// is performed.\n OpenMPClauseKind isOpenMPPrivateDecl(ValueDecl *D, unsigned Level,\n unsigned CapLevel) const;\n\n /// Sets OpenMP capture kind (OMPC_private, OMPC_firstprivate, OMPC_map etc.)\n /// for \\p FD based on DSA for the provided corresponding captured declaration\n /// \\p D.\n void setOpenMPCaptureKind(FieldDecl *FD, const ValueDecl *D, unsigned Level);\n\n /// Check if the specified variable is captured by 'target' directive.\n /// \\param Level Relative level of nested OpenMP construct for that the check\n /// is performed.\n bool isOpenMPTargetCapturedDecl(const ValueDecl *D, unsigned Level,\n unsigned CaptureLevel) const;\n\n /// Check if the specified global variable must be captured by outer capture\n /// regions.\n /// \\param Level Relative level of nested OpenMP construct for that\n /// the check is performed.\n bool isOpenMPGlobalCapturedDecl(ValueDecl *D, unsigned Level,\n unsigned CaptureLevel) const;\n\n ExprResult PerformOpenMPImplicitIntegerConversion(SourceLocation OpLoc,\n Expr *Op);\n /// Called on start of new data sharing attribute block.\n void StartOpenMPDSABlock(OpenMPDirectiveKind K,\n const DeclarationNameInfo &DirName, Scope *CurScope,\n SourceLocation Loc);\n /// Start analysis of clauses.\n void StartOpenMPClause(OpenMPClauseKind K);\n /// End analysis of clauses.\n void EndOpenMPClause();\n /// Called on end of data sharing attribute block.\n void EndOpenMPDSABlock(Stmt *CurDirective);\n\n /// Check if the current region is an OpenMP loop region and if it is,\n /// mark loop control variable, used in \\p Init for loop initialization, as\n /// private by default.\n /// \\param Init First part of the for loop.\n void ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init);\n\n // OpenMP directives and clauses.\n /// Called on correct id-expression from the '#pragma omp\n /// threadprivate'.\n ExprResult ActOnOpenMPIdExpression(Scope *CurScope, CXXScopeSpec &ScopeSpec,\n const DeclarationNameInfo &Id,\n OpenMPDirectiveKind Kind);\n /// Called on well-formed '#pragma omp threadprivate'.\n DeclGroupPtrTy ActOnOpenMPThreadprivateDirective(\n SourceLocation Loc,\n ArrayRef<Expr *> VarList);\n /// Builds a new OpenMPThreadPrivateDecl and checks its correctness.\n OMPThreadPrivateDecl *CheckOMPThreadPrivateDecl(SourceLocation Loc,\n ArrayRef<Expr *> VarList);\n /// Called on well-formed '#pragma omp allocate'.\n DeclGroupPtrTy ActOnOpenMPAllocateDirective(SourceLocation Loc,\n ArrayRef<Expr *> VarList,\n ArrayRef<OMPClause *> Clauses,\n DeclContext *Owner = nullptr);\n\n /// Called on well-formed '#pragma omp [begin] assume[s]'.\n void ActOnOpenMPAssumesDirective(SourceLocation Loc,\n OpenMPDirectiveKind DKind,\n ArrayRef<StringRef> Assumptions,\n bool SkippedClauses);\n\n /// Check if there is an active global `omp begin assumes` directive.\n bool isInOpenMPAssumeScope() const { return !OMPAssumeScoped.empty(); }\n\n /// Check if there is an active global `omp assumes` directive.\n bool hasGlobalOpenMPAssumes() const { return !OMPAssumeGlobal.empty(); }\n\n /// Called on well-formed '#pragma omp end assumes'.\n void ActOnOpenMPEndAssumesDirective();\n\n /// Called on well-formed '#pragma omp requires'.\n DeclGroupPtrTy ActOnOpenMPRequiresDirective(SourceLocation Loc,\n ArrayRef<OMPClause *> ClauseList);\n /// Check restrictions on Requires directive\n OMPRequiresDecl *CheckOMPRequiresDecl(SourceLocation Loc,\n ArrayRef<OMPClause *> Clauses);\n /// Check if the specified type is allowed to be used in 'omp declare\n /// reduction' construct.\n QualType ActOnOpenMPDeclareReductionType(SourceLocation TyLoc,\n TypeResult ParsedType);\n /// Called on start of '#pragma omp declare reduction'.\n DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveStart(\n Scope *S, DeclContext *DC, DeclarationName Name,\n ArrayRef<std::pair<QualType, SourceLocation>> ReductionTypes,\n AccessSpecifier AS, Decl *PrevDeclInScope = nullptr);\n /// Initialize declare reduction construct initializer.\n void ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D);\n /// Finish current declare reduction construct initializer.\n void ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner);\n /// Initialize declare reduction construct initializer.\n /// \\return omp_priv variable.\n VarDecl *ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D);\n /// Finish current declare reduction construct initializer.\n void ActOnOpenMPDeclareReductionInitializerEnd(Decl *D, Expr *Initializer,\n VarDecl *OmpPrivParm);\n /// Called at the end of '#pragma omp declare reduction'.\n DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveEnd(\n Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid);\n\n /// Check variable declaration in 'omp declare mapper' construct.\n TypeResult ActOnOpenMPDeclareMapperVarDecl(Scope *S, Declarator &D);\n /// Check if the specified type is allowed to be used in 'omp declare\n /// mapper' construct.\n QualType ActOnOpenMPDeclareMapperType(SourceLocation TyLoc,\n TypeResult ParsedType);\n /// Called on start of '#pragma omp declare mapper'.\n DeclGroupPtrTy ActOnOpenMPDeclareMapperDirective(\n Scope *S, DeclContext *DC, DeclarationName Name, QualType MapperType,\n SourceLocation StartLoc, DeclarationName VN, AccessSpecifier AS,\n Expr *MapperVarRef, ArrayRef<OMPClause *> Clauses,\n Decl *PrevDeclInScope = nullptr);\n /// Build the mapper variable of '#pragma omp declare mapper'.\n ExprResult ActOnOpenMPDeclareMapperDirectiveVarDecl(Scope *S,\n QualType MapperType,\n SourceLocation StartLoc,\n DeclarationName VN);\n bool isOpenMPDeclareMapperVarDeclAllowed(const VarDecl *VD) const;\n const ValueDecl *getOpenMPDeclareMapperVarName() const;\n\n /// Called on the start of target region i.e. '#pragma omp declare target'.\n bool ActOnStartOpenMPDeclareTargetDirective(SourceLocation Loc);\n /// Called at the end of target region i.e. '#pragme omp end declare target'.\n void ActOnFinishOpenMPDeclareTargetDirective();\n /// Searches for the provided declaration name for OpenMP declare target\n /// directive.\n NamedDecl *\n lookupOpenMPDeclareTargetName(Scope *CurScope, CXXScopeSpec &ScopeSpec,\n const DeclarationNameInfo &Id,\n NamedDeclSetType &SameDirectiveDecls);\n /// Called on correct id-expression from the '#pragma omp declare target'.\n void ActOnOpenMPDeclareTargetName(NamedDecl *ND, SourceLocation Loc,\n OMPDeclareTargetDeclAttr::MapTypeTy MT,\n OMPDeclareTargetDeclAttr::DevTypeTy DT);\n /// Check declaration inside target region.\n void\n checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D,\n SourceLocation IdLoc = SourceLocation());\n /// Finishes analysis of the deferred functions calls that may be declared as\n /// host/nohost during device/host compilation.\n void finalizeOpenMPDelayedAnalysis(const FunctionDecl *Caller,\n const FunctionDecl *Callee,\n SourceLocation Loc);\n /// Return true inside OpenMP declare target region.\n bool isInOpenMPDeclareTargetContext() const {\n return !DeclareTargetNesting.empty();\n }\n /// Return true inside OpenMP target region.\n bool isInOpenMPTargetExecutionDirective() const;\n\n /// Return the number of captured regions created for an OpenMP directive.\n static int getOpenMPCaptureLevels(OpenMPDirectiveKind Kind);\n\n /// Initialization of captured region for OpenMP region.\n void ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope);\n\n /// Called for syntactical loops (ForStmt or CXXForRangeStmt) associated to\n /// an OpenMP loop directive.\n StmtResult ActOnOpenMPCanonicalLoop(Stmt *AStmt);\n\n /// End of OpenMP region.\n ///\n /// \\param S Statement associated with the current OpenMP region.\n /// \\param Clauses List of clauses for the current OpenMP region.\n ///\n /// \\returns Statement for finished OpenMP region.\n StmtResult ActOnOpenMPRegionEnd(StmtResult S, ArrayRef<OMPClause *> Clauses);\n StmtResult ActOnOpenMPExecutableDirective(\n OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName,\n OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,\n Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp parallel' after parsing\n /// of the associated statement.\n StmtResult ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,\n Stmt *AStmt,\n SourceLocation StartLoc,\n SourceLocation EndLoc);\n using VarsWithInheritedDSAType =\n llvm::SmallDenseMap<const ValueDecl *, const Expr *, 4>;\n /// Called on well-formed '\\#pragma omp simd' after parsing\n /// of the associated statement.\n StmtResult\n ActOnOpenMPSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,\n SourceLocation StartLoc, SourceLocation EndLoc,\n VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '#pragma omp tile' after parsing of its clauses and\n /// the associated statement.\n StmtResult ActOnOpenMPTileDirective(ArrayRef<OMPClause *> Clauses,\n Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp for' after parsing\n /// of the associated statement.\n StmtResult\n ActOnOpenMPForDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,\n SourceLocation StartLoc, SourceLocation EndLoc,\n VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp for simd' after parsing\n /// of the associated statement.\n StmtResult\n ActOnOpenMPForSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,\n SourceLocation StartLoc, SourceLocation EndLoc,\n VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp sections' after parsing\n /// of the associated statement.\n StmtResult ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses,\n Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp section' after parsing of the\n /// associated statement.\n StmtResult ActOnOpenMPSectionDirective(Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp single' after parsing of the\n /// associated statement.\n StmtResult ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses,\n Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp master' after parsing of the\n /// associated statement.\n StmtResult ActOnOpenMPMasterDirective(Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp critical' after parsing of the\n /// associated statement.\n StmtResult ActOnOpenMPCriticalDirective(const DeclarationNameInfo &DirName,\n ArrayRef<OMPClause *> Clauses,\n Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp parallel for' after parsing\n /// of the associated statement.\n StmtResult ActOnOpenMPParallelForDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp parallel for simd' after\n /// parsing of the associated statement.\n StmtResult ActOnOpenMPParallelForSimdDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp parallel master' after\n /// parsing of the associated statement.\n StmtResult ActOnOpenMPParallelMasterDirective(ArrayRef<OMPClause *> Clauses,\n Stmt *AStmt,\n SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp parallel sections' after\n /// parsing of the associated statement.\n StmtResult ActOnOpenMPParallelSectionsDirective(ArrayRef<OMPClause *> Clauses,\n Stmt *AStmt,\n SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp task' after parsing of the\n /// associated statement.\n StmtResult ActOnOpenMPTaskDirective(ArrayRef<OMPClause *> Clauses,\n Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp taskyield'.\n StmtResult ActOnOpenMPTaskyieldDirective(SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp barrier'.\n StmtResult ActOnOpenMPBarrierDirective(SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp taskwait'.\n StmtResult ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp taskgroup'.\n StmtResult ActOnOpenMPTaskgroupDirective(ArrayRef<OMPClause *> Clauses,\n Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp flush'.\n StmtResult ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses,\n SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp depobj'.\n StmtResult ActOnOpenMPDepobjDirective(ArrayRef<OMPClause *> Clauses,\n SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp scan'.\n StmtResult ActOnOpenMPScanDirective(ArrayRef<OMPClause *> Clauses,\n SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp ordered' after parsing of the\n /// associated statement.\n StmtResult ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses,\n Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp atomic' after parsing of the\n /// associated statement.\n StmtResult ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,\n Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp target' after parsing of the\n /// associated statement.\n StmtResult ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses,\n Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp target data' after parsing of\n /// the associated statement.\n StmtResult ActOnOpenMPTargetDataDirective(ArrayRef<OMPClause *> Clauses,\n Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp target enter data' after\n /// parsing of the associated statement.\n StmtResult ActOnOpenMPTargetEnterDataDirective(ArrayRef<OMPClause *> Clauses,\n SourceLocation StartLoc,\n SourceLocation EndLoc,\n Stmt *AStmt);\n /// Called on well-formed '\\#pragma omp target exit data' after\n /// parsing of the associated statement.\n StmtResult ActOnOpenMPTargetExitDataDirective(ArrayRef<OMPClause *> Clauses,\n SourceLocation StartLoc,\n SourceLocation EndLoc,\n Stmt *AStmt);\n /// Called on well-formed '\\#pragma omp target parallel' after\n /// parsing of the associated statement.\n StmtResult ActOnOpenMPTargetParallelDirective(ArrayRef<OMPClause *> Clauses,\n Stmt *AStmt,\n SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp target parallel for' after\n /// parsing of the associated statement.\n StmtResult ActOnOpenMPTargetParallelForDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp teams' after parsing of the\n /// associated statement.\n StmtResult ActOnOpenMPTeamsDirective(ArrayRef<OMPClause *> Clauses,\n Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp cancellation point'.\n StmtResult\n ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc,\n SourceLocation EndLoc,\n OpenMPDirectiveKind CancelRegion);\n /// Called on well-formed '\\#pragma omp cancel'.\n StmtResult ActOnOpenMPCancelDirective(ArrayRef<OMPClause *> Clauses,\n SourceLocation StartLoc,\n SourceLocation EndLoc,\n OpenMPDirectiveKind CancelRegion);\n /// Called on well-formed '\\#pragma omp taskloop' after parsing of the\n /// associated statement.\n StmtResult\n ActOnOpenMPTaskLoopDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,\n SourceLocation StartLoc, SourceLocation EndLoc,\n VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp taskloop simd' after parsing of\n /// the associated statement.\n StmtResult ActOnOpenMPTaskLoopSimdDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp master taskloop' after parsing of the\n /// associated statement.\n StmtResult ActOnOpenMPMasterTaskLoopDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp master taskloop simd' after parsing of\n /// the associated statement.\n StmtResult ActOnOpenMPMasterTaskLoopSimdDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp parallel master taskloop' after\n /// parsing of the associated statement.\n StmtResult ActOnOpenMPParallelMasterTaskLoopDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp parallel master taskloop simd' after\n /// parsing of the associated statement.\n StmtResult ActOnOpenMPParallelMasterTaskLoopSimdDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp distribute' after parsing\n /// of the associated statement.\n StmtResult\n ActOnOpenMPDistributeDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,\n SourceLocation StartLoc, SourceLocation EndLoc,\n VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp target update'.\n StmtResult ActOnOpenMPTargetUpdateDirective(ArrayRef<OMPClause *> Clauses,\n SourceLocation StartLoc,\n SourceLocation EndLoc,\n Stmt *AStmt);\n /// Called on well-formed '\\#pragma omp distribute parallel for' after\n /// parsing of the associated statement.\n StmtResult ActOnOpenMPDistributeParallelForDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp distribute parallel for simd'\n /// after parsing of the associated statement.\n StmtResult ActOnOpenMPDistributeParallelForSimdDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp distribute simd' after\n /// parsing of the associated statement.\n StmtResult ActOnOpenMPDistributeSimdDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp target parallel for simd' after\n /// parsing of the associated statement.\n StmtResult ActOnOpenMPTargetParallelForSimdDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp target simd' after parsing of\n /// the associated statement.\n StmtResult\n ActOnOpenMPTargetSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,\n SourceLocation StartLoc, SourceLocation EndLoc,\n VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp teams distribute' after parsing of\n /// the associated statement.\n StmtResult ActOnOpenMPTeamsDistributeDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp teams distribute simd' after parsing\n /// of the associated statement.\n StmtResult ActOnOpenMPTeamsDistributeSimdDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp teams distribute parallel for simd'\n /// after parsing of the associated statement.\n StmtResult ActOnOpenMPTeamsDistributeParallelForSimdDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp teams distribute parallel for'\n /// after parsing of the associated statement.\n StmtResult ActOnOpenMPTeamsDistributeParallelForDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp target teams' after parsing of the\n /// associated statement.\n StmtResult ActOnOpenMPTargetTeamsDirective(ArrayRef<OMPClause *> Clauses,\n Stmt *AStmt,\n SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed '\\#pragma omp target teams distribute' after parsing\n /// of the associated statement.\n StmtResult ActOnOpenMPTargetTeamsDistributeDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp target teams distribute parallel for'\n /// after parsing of the associated statement.\n StmtResult ActOnOpenMPTargetTeamsDistributeParallelForDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp target teams distribute parallel for\n /// simd' after parsing of the associated statement.\n StmtResult ActOnOpenMPTargetTeamsDistributeParallelForSimdDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp target teams distribute simd' after\n /// parsing of the associated statement.\n StmtResult ActOnOpenMPTargetTeamsDistributeSimdDirective(\n ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,\n SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);\n /// Called on well-formed '\\#pragma omp interop'.\n StmtResult ActOnOpenMPInteropDirective(ArrayRef<OMPClause *> Clauses,\n SourceLocation StartLoc,\n SourceLocation EndLoc);\n\n /// Checks correctness of linear modifiers.\n bool CheckOpenMPLinearModifier(OpenMPLinearClauseKind LinKind,\n SourceLocation LinLoc);\n /// Checks that the specified declaration matches requirements for the linear\n /// decls.\n bool CheckOpenMPLinearDecl(const ValueDecl *D, SourceLocation ELoc,\n OpenMPLinearClauseKind LinKind, QualType Type,\n bool IsDeclareSimd = false);\n\n /// Called on well-formed '\\#pragma omp declare simd' after parsing of\n /// the associated method/function.\n DeclGroupPtrTy ActOnOpenMPDeclareSimdDirective(\n DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS,\n Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,\n ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,\n ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR);\n\n /// Checks '\\#pragma omp declare variant' variant function and original\n /// functions after parsing of the associated method/function.\n /// \\param DG Function declaration to which declare variant directive is\n /// applied to.\n /// \\param VariantRef Expression that references the variant function, which\n /// must be used instead of the original one, specified in \\p DG.\n /// \\param TI The trait info object representing the match clause.\n /// \\returns None, if the function/variant function are not compatible with\n /// the pragma, pair of original function/variant ref expression otherwise.\n Optional<std::pair<FunctionDecl *, Expr *>>\n checkOpenMPDeclareVariantFunction(DeclGroupPtrTy DG, Expr *VariantRef,\n OMPTraitInfo &TI, SourceRange SR);\n\n /// Called on well-formed '\\#pragma omp declare variant' after parsing of\n /// the associated method/function.\n /// \\param FD Function declaration to which declare variant directive is\n /// applied to.\n /// \\param VariantRef Expression that references the variant function, which\n /// must be used instead of the original one, specified in \\p DG.\n /// \\param TI The context traits associated with the function variant.\n void ActOnOpenMPDeclareVariantDirective(FunctionDecl *FD, Expr *VariantRef,\n OMPTraitInfo &TI, SourceRange SR);\n\n OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind,\n Expr *Expr,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'allocator' clause.\n OMPClause *ActOnOpenMPAllocatorClause(Expr *Allocator,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'if' clause.\n OMPClause *ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier,\n Expr *Condition, SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation NameModifierLoc,\n SourceLocation ColonLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'final' clause.\n OMPClause *ActOnOpenMPFinalClause(Expr *Condition, SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'num_threads' clause.\n OMPClause *ActOnOpenMPNumThreadsClause(Expr *NumThreads,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'safelen' clause.\n OMPClause *ActOnOpenMPSafelenClause(Expr *Length,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'simdlen' clause.\n OMPClause *ActOnOpenMPSimdlenClause(Expr *Length, SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-form 'sizes' clause.\n OMPClause *ActOnOpenMPSizesClause(ArrayRef<Expr *> SizeExprs,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'collapse' clause.\n OMPClause *ActOnOpenMPCollapseClause(Expr *NumForLoops,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'ordered' clause.\n OMPClause *\n ActOnOpenMPOrderedClause(SourceLocation StartLoc, SourceLocation EndLoc,\n SourceLocation LParenLoc = SourceLocation(),\n Expr *NumForLoops = nullptr);\n /// Called on well-formed 'grainsize' clause.\n OMPClause *ActOnOpenMPGrainsizeClause(Expr *Size, SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'num_tasks' clause.\n OMPClause *ActOnOpenMPNumTasksClause(Expr *NumTasks, SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'hint' clause.\n OMPClause *ActOnOpenMPHintClause(Expr *Hint, SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'detach' clause.\n OMPClause *ActOnOpenMPDetachClause(Expr *Evt, SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n\n OMPClause *ActOnOpenMPSimpleClause(OpenMPClauseKind Kind,\n unsigned Argument,\n SourceLocation ArgumentLoc,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'default' clause.\n OMPClause *ActOnOpenMPDefaultClause(llvm::omp::DefaultKind Kind,\n SourceLocation KindLoc,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'proc_bind' clause.\n OMPClause *ActOnOpenMPProcBindClause(llvm::omp::ProcBindKind Kind,\n SourceLocation KindLoc,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'order' clause.\n OMPClause *ActOnOpenMPOrderClause(OpenMPOrderClauseKind Kind,\n SourceLocation KindLoc,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'update' clause.\n OMPClause *ActOnOpenMPUpdateClause(OpenMPDependClauseKind Kind,\n SourceLocation KindLoc,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n\n OMPClause *ActOnOpenMPSingleExprWithArgClause(\n OpenMPClauseKind Kind, ArrayRef<unsigned> Arguments, Expr *Expr,\n SourceLocation StartLoc, SourceLocation LParenLoc,\n ArrayRef<SourceLocation> ArgumentsLoc, SourceLocation DelimLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'schedule' clause.\n OMPClause *ActOnOpenMPScheduleClause(\n OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,\n OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,\n SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,\n SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc);\n\n OMPClause *ActOnOpenMPClause(OpenMPClauseKind Kind, SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'nowait' clause.\n OMPClause *ActOnOpenMPNowaitClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'untied' clause.\n OMPClause *ActOnOpenMPUntiedClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'mergeable' clause.\n OMPClause *ActOnOpenMPMergeableClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'read' clause.\n OMPClause *ActOnOpenMPReadClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'write' clause.\n OMPClause *ActOnOpenMPWriteClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'update' clause.\n OMPClause *ActOnOpenMPUpdateClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'capture' clause.\n OMPClause *ActOnOpenMPCaptureClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'seq_cst' clause.\n OMPClause *ActOnOpenMPSeqCstClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'acq_rel' clause.\n OMPClause *ActOnOpenMPAcqRelClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'acquire' clause.\n OMPClause *ActOnOpenMPAcquireClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'release' clause.\n OMPClause *ActOnOpenMPReleaseClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'relaxed' clause.\n OMPClause *ActOnOpenMPRelaxedClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n\n /// Called on well-formed 'init' clause.\n OMPClause *ActOnOpenMPInitClause(Expr *InteropVar, ArrayRef<Expr *> PrefExprs,\n bool IsTarget, bool IsTargetSync,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation VarLoc,\n SourceLocation EndLoc);\n\n /// Called on well-formed 'use' clause.\n OMPClause *ActOnOpenMPUseClause(Expr *InteropVar, SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation VarLoc, SourceLocation EndLoc);\n\n /// Called on well-formed 'destroy' clause.\n OMPClause *ActOnOpenMPDestroyClause(Expr *InteropVar, SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation VarLoc,\n SourceLocation EndLoc);\n\n /// Called on well-formed 'threads' clause.\n OMPClause *ActOnOpenMPThreadsClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'simd' clause.\n OMPClause *ActOnOpenMPSIMDClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'nogroup' clause.\n OMPClause *ActOnOpenMPNogroupClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'unified_address' clause.\n OMPClause *ActOnOpenMPUnifiedAddressClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n\n /// Called on well-formed 'unified_address' clause.\n OMPClause *ActOnOpenMPUnifiedSharedMemoryClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n\n /// Called on well-formed 'reverse_offload' clause.\n OMPClause *ActOnOpenMPReverseOffloadClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n\n /// Called on well-formed 'dynamic_allocators' clause.\n OMPClause *ActOnOpenMPDynamicAllocatorsClause(SourceLocation StartLoc,\n SourceLocation EndLoc);\n\n /// Called on well-formed 'atomic_default_mem_order' clause.\n OMPClause *ActOnOpenMPAtomicDefaultMemOrderClause(\n OpenMPAtomicDefaultMemOrderClauseKind Kind, SourceLocation KindLoc,\n SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc);\n\n OMPClause *ActOnOpenMPVarListClause(\n OpenMPClauseKind Kind, ArrayRef<Expr *> Vars, Expr *DepModOrTailExpr,\n const OMPVarListLocTy &Locs, SourceLocation ColonLoc,\n CXXScopeSpec &ReductionOrMapperIdScopeSpec,\n DeclarationNameInfo &ReductionOrMapperId, int ExtraModifier,\n ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,\n ArrayRef<SourceLocation> MapTypeModifiersLoc, bool IsMapTypeImplicit,\n SourceLocation ExtraModifierLoc,\n ArrayRef<OpenMPMotionModifierKind> MotionModifiers,\n ArrayRef<SourceLocation> MotionModifiersLoc);\n /// Called on well-formed 'inclusive' clause.\n OMPClause *ActOnOpenMPInclusiveClause(ArrayRef<Expr *> VarList,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'exclusive' clause.\n OMPClause *ActOnOpenMPExclusiveClause(ArrayRef<Expr *> VarList,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'allocate' clause.\n OMPClause *\n ActOnOpenMPAllocateClause(Expr *Allocator, ArrayRef<Expr *> VarList,\n SourceLocation StartLoc, SourceLocation ColonLoc,\n SourceLocation LParenLoc, SourceLocation EndLoc);\n /// Called on well-formed 'private' clause.\n OMPClause *ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'firstprivate' clause.\n OMPClause *ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'lastprivate' clause.\n OMPClause *ActOnOpenMPLastprivateClause(\n ArrayRef<Expr *> VarList, OpenMPLastprivateModifier LPKind,\n SourceLocation LPKindLoc, SourceLocation ColonLoc,\n SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc);\n /// Called on well-formed 'shared' clause.\n OMPClause *ActOnOpenMPSharedClause(ArrayRef<Expr *> VarList,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'reduction' clause.\n OMPClause *ActOnOpenMPReductionClause(\n ArrayRef<Expr *> VarList, OpenMPReductionClauseModifier Modifier,\n SourceLocation StartLoc, SourceLocation LParenLoc,\n SourceLocation ModifierLoc, SourceLocation ColonLoc,\n SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec,\n const DeclarationNameInfo &ReductionId,\n ArrayRef<Expr *> UnresolvedReductions = llvm::None);\n /// Called on well-formed 'task_reduction' clause.\n OMPClause *ActOnOpenMPTaskReductionClause(\n ArrayRef<Expr *> VarList, SourceLocation StartLoc,\n SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,\n CXXScopeSpec &ReductionIdScopeSpec,\n const DeclarationNameInfo &ReductionId,\n ArrayRef<Expr *> UnresolvedReductions = llvm::None);\n /// Called on well-formed 'in_reduction' clause.\n OMPClause *ActOnOpenMPInReductionClause(\n ArrayRef<Expr *> VarList, SourceLocation StartLoc,\n SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,\n CXXScopeSpec &ReductionIdScopeSpec,\n const DeclarationNameInfo &ReductionId,\n ArrayRef<Expr *> UnresolvedReductions = llvm::None);\n /// Called on well-formed 'linear' clause.\n OMPClause *\n ActOnOpenMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,\n SourceLocation StartLoc, SourceLocation LParenLoc,\n OpenMPLinearClauseKind LinKind, SourceLocation LinLoc,\n SourceLocation ColonLoc, SourceLocation EndLoc);\n /// Called on well-formed 'aligned' clause.\n OMPClause *ActOnOpenMPAlignedClause(ArrayRef<Expr *> VarList,\n Expr *Alignment,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation ColonLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'copyin' clause.\n OMPClause *ActOnOpenMPCopyinClause(ArrayRef<Expr *> VarList,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'copyprivate' clause.\n OMPClause *ActOnOpenMPCopyprivateClause(ArrayRef<Expr *> VarList,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'flush' pseudo clause.\n OMPClause *ActOnOpenMPFlushClause(ArrayRef<Expr *> VarList,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'depobj' pseudo clause.\n OMPClause *ActOnOpenMPDepobjClause(Expr *Depobj, SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'depend' clause.\n OMPClause *\n ActOnOpenMPDependClause(Expr *DepModifier, OpenMPDependClauseKind DepKind,\n SourceLocation DepLoc, SourceLocation ColonLoc,\n ArrayRef<Expr *> VarList, SourceLocation StartLoc,\n SourceLocation LParenLoc, SourceLocation EndLoc);\n /// Called on well-formed 'device' clause.\n OMPClause *ActOnOpenMPDeviceClause(OpenMPDeviceClauseModifier Modifier,\n Expr *Device, SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation ModifierLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'map' clause.\n OMPClause *\n ActOnOpenMPMapClause(ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,\n ArrayRef<SourceLocation> MapTypeModifiersLoc,\n CXXScopeSpec &MapperIdScopeSpec,\n DeclarationNameInfo &MapperId,\n OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,\n SourceLocation MapLoc, SourceLocation ColonLoc,\n ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,\n ArrayRef<Expr *> UnresolvedMappers = llvm::None);\n /// Called on well-formed 'num_teams' clause.\n OMPClause *ActOnOpenMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'thread_limit' clause.\n OMPClause *ActOnOpenMPThreadLimitClause(Expr *ThreadLimit,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'priority' clause.\n OMPClause *ActOnOpenMPPriorityClause(Expr *Priority, SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n /// Called on well-formed 'dist_schedule' clause.\n OMPClause *ActOnOpenMPDistScheduleClause(\n OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize,\n SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation KindLoc,\n SourceLocation CommaLoc, SourceLocation EndLoc);\n /// Called on well-formed 'defaultmap' clause.\n OMPClause *ActOnOpenMPDefaultmapClause(\n OpenMPDefaultmapClauseModifier M, OpenMPDefaultmapClauseKind Kind,\n SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation MLoc,\n SourceLocation KindLoc, SourceLocation EndLoc);\n /// Called on well-formed 'to' clause.\n OMPClause *\n ActOnOpenMPToClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,\n ArrayRef<SourceLocation> MotionModifiersLoc,\n CXXScopeSpec &MapperIdScopeSpec,\n DeclarationNameInfo &MapperId, SourceLocation ColonLoc,\n ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,\n ArrayRef<Expr *> UnresolvedMappers = llvm::None);\n /// Called on well-formed 'from' clause.\n OMPClause *\n ActOnOpenMPFromClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,\n ArrayRef<SourceLocation> MotionModifiersLoc,\n CXXScopeSpec &MapperIdScopeSpec,\n DeclarationNameInfo &MapperId, SourceLocation ColonLoc,\n ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,\n ArrayRef<Expr *> UnresolvedMappers = llvm::None);\n /// Called on well-formed 'use_device_ptr' clause.\n OMPClause *ActOnOpenMPUseDevicePtrClause(ArrayRef<Expr *> VarList,\n const OMPVarListLocTy &Locs);\n /// Called on well-formed 'use_device_addr' clause.\n OMPClause *ActOnOpenMPUseDeviceAddrClause(ArrayRef<Expr *> VarList,\n const OMPVarListLocTy &Locs);\n /// Called on well-formed 'is_device_ptr' clause.\n OMPClause *ActOnOpenMPIsDevicePtrClause(ArrayRef<Expr *> VarList,\n const OMPVarListLocTy &Locs);\n /// Called on well-formed 'nontemporal' clause.\n OMPClause *ActOnOpenMPNontemporalClause(ArrayRef<Expr *> VarList,\n SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc);\n\n /// Data for list of allocators.\n struct UsesAllocatorsData {\n /// Allocator.\n Expr *Allocator = nullptr;\n /// Allocator traits.\n Expr *AllocatorTraits = nullptr;\n /// Locations of '(' and ')' symbols.\n SourceLocation LParenLoc, RParenLoc;\n };\n /// Called on well-formed 'uses_allocators' clause.\n OMPClause *ActOnOpenMPUsesAllocatorClause(SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation EndLoc,\n ArrayRef<UsesAllocatorsData> Data);\n /// Called on well-formed 'affinity' clause.\n OMPClause *ActOnOpenMPAffinityClause(SourceLocation StartLoc,\n SourceLocation LParenLoc,\n SourceLocation ColonLoc,\n SourceLocation EndLoc, Expr *Modifier,\n ArrayRef<Expr *> Locators);\n\n /// The kind of conversion being performed.\n enum CheckedConversionKind {\n /// An implicit conversion.\n CCK_ImplicitConversion,\n /// A C-style cast.\n CCK_CStyleCast,\n /// A functional-style cast.\n CCK_FunctionalCast,\n /// A cast other than a C-style cast.\n CCK_OtherCast,\n /// A conversion for an operand of a builtin overloaded operator.\n CCK_ForBuiltinOverloadedOp\n };\n\n static bool isCast(CheckedConversionKind CCK) {\n return CCK == CCK_CStyleCast || CCK == CCK_FunctionalCast ||\n CCK == CCK_OtherCast;\n }\n\n /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit\n /// cast. If there is already an implicit cast, merge into the existing one.\n /// If isLvalue, the result of the cast is an lvalue.\n ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK,\n ExprValueKind VK = VK_RValue,\n const CXXCastPath *BasePath = nullptr,\n CheckedConversionKind CCK\n = CCK_ImplicitConversion);\n\n /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding\n /// to the conversion from scalar type ScalarTy to the Boolean type.\n static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy);\n\n /// IgnoredValueConversions - Given that an expression's result is\n /// syntactically ignored, perform any conversions that are\n /// required.\n ExprResult IgnoredValueConversions(Expr *E);\n\n // UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts\n // functions and arrays to their respective pointers (C99 6.3.2.1).\n ExprResult UsualUnaryConversions(Expr *E);\n\n /// CallExprUnaryConversions - a special case of an unary conversion\n /// performed on a function designator of a call expression.\n ExprResult CallExprUnaryConversions(Expr *E);\n\n // DefaultFunctionArrayConversion - converts functions and arrays\n // to their respective pointers (C99 6.3.2.1).\n ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose = true);\n\n // DefaultFunctionArrayLvalueConversion - converts functions and\n // arrays to their respective pointers and performs the\n // lvalue-to-rvalue conversion.\n ExprResult DefaultFunctionArrayLvalueConversion(Expr *E,\n bool Diagnose = true);\n\n // DefaultLvalueConversion - performs lvalue-to-rvalue conversion on\n // the operand. This function is a no-op if the operand has a function type\n // or an array type.\n ExprResult DefaultLvalueConversion(Expr *E);\n\n // DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that\n // do not have a prototype. Integer promotions are performed on each\n // argument, and arguments that have type float are promoted to double.\n ExprResult DefaultArgumentPromotion(Expr *E);\n\n /// If \\p E is a prvalue denoting an unmaterialized temporary, materialize\n /// it as an xvalue. In C++98, the result will still be a prvalue, because\n /// we don't have xvalues there.\n ExprResult TemporaryMaterializationConversion(Expr *E);\n\n // Used for emitting the right warning by DefaultVariadicArgumentPromotion\n enum VariadicCallType {\n VariadicFunction,\n VariadicBlock,\n VariadicMethod,\n VariadicConstructor,\n VariadicDoesNotApply\n };\n\n VariadicCallType getVariadicCallType(FunctionDecl *FDecl,\n const FunctionProtoType *Proto,\n Expr *Fn);\n\n // Used for determining in which context a type is allowed to be passed to a\n // vararg function.\n enum VarArgKind {\n VAK_Valid,\n VAK_ValidInCXX11,\n VAK_Undefined,\n VAK_MSVCUndefined,\n VAK_Invalid\n };\n\n // Determines which VarArgKind fits an expression.\n VarArgKind isValidVarArgType(const QualType &Ty);\n\n /// Check to see if the given expression is a valid argument to a variadic\n /// function, issuing a diagnostic if not.\n void checkVariadicArgument(const Expr *E, VariadicCallType CT);\n\n /// Check to see if a given expression could have '.c_str()' called on it.\n bool hasCStrMethod(const Expr *E);\n\n /// GatherArgumentsForCall - Collector argument expressions for various\n /// form of call prototypes.\n bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl,\n const FunctionProtoType *Proto,\n unsigned FirstParam, ArrayRef<Expr *> Args,\n SmallVectorImpl<Expr *> &AllArgs,\n VariadicCallType CallType = VariadicDoesNotApply,\n bool AllowExplicit = false,\n bool IsListInitialization = false);\n\n // DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but\n // will create a runtime trap if the resulting type is not a POD type.\n ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT,\n FunctionDecl *FDecl);\n\n /// Context in which we're performing a usual arithmetic conversion.\n enum ArithConvKind {\n /// An arithmetic operation.\n ACK_Arithmetic,\n /// A bitwise operation.\n ACK_BitwiseOp,\n /// A comparison.\n ACK_Comparison,\n /// A conditional (?:) operator.\n ACK_Conditional,\n /// A compound assignment expression.\n ACK_CompAssign,\n };\n\n // UsualArithmeticConversions - performs the UsualUnaryConversions on it's\n // operands and then handles various conversions that are common to binary\n // operators (C99 6.3.1.8). If both operands aren't arithmetic, this\n // routine returns the first non-arithmetic type found. The client is\n // responsible for emitting appropriate error diagnostics.\n QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS,\n SourceLocation Loc, ArithConvKind ACK);\n\n /// AssignConvertType - All of the 'assignment' semantic checks return this\n /// enum to indicate whether the assignment was allowed. These checks are\n /// done for simple assignments, as well as initialization, return from\n /// function, argument passing, etc. The query is phrased in terms of a\n /// source and destination type.\n enum AssignConvertType {\n /// Compatible - the types are compatible according to the standard.\n Compatible,\n\n /// PointerToInt - The assignment converts a pointer to an int, which we\n /// accept as an extension.\n PointerToInt,\n\n /// IntToPointer - The assignment converts an int to a pointer, which we\n /// accept as an extension.\n IntToPointer,\n\n /// FunctionVoidPointer - The assignment is between a function pointer and\n /// void*, which the standard doesn't allow, but we accept as an extension.\n FunctionVoidPointer,\n\n /// IncompatiblePointer - The assignment is between two pointers types that\n /// are not compatible, but we accept them as an extension.\n IncompatiblePointer,\n\n /// IncompatibleFunctionPointer - The assignment is between two function\n /// pointers types that are not compatible, but we accept them as an\n /// extension.\n IncompatibleFunctionPointer,\n\n /// IncompatiblePointerSign - The assignment is between two pointers types\n /// which point to integers which have a different sign, but are otherwise\n /// identical. This is a subset of the above, but broken out because it's by\n /// far the most common case of incompatible pointers.\n IncompatiblePointerSign,\n\n /// CompatiblePointerDiscardsQualifiers - The assignment discards\n /// c/v/r qualifiers, which we accept as an extension.\n CompatiblePointerDiscardsQualifiers,\n\n /// IncompatiblePointerDiscardsQualifiers - The assignment\n /// discards qualifiers that we don't permit to be discarded,\n /// like address spaces.\n IncompatiblePointerDiscardsQualifiers,\n\n /// IncompatibleNestedPointerAddressSpaceMismatch - The assignment\n /// changes address spaces in nested pointer types which is not allowed.\n /// For instance, converting __private int ** to __generic int ** is\n /// illegal even though __private could be converted to __generic.\n IncompatibleNestedPointerAddressSpaceMismatch,\n\n /// IncompatibleNestedPointerQualifiers - The assignment is between two\n /// nested pointer types, and the qualifiers other than the first two\n /// levels differ e.g. char ** -> const char **, but we accept them as an\n /// extension.\n IncompatibleNestedPointerQualifiers,\n\n /// IncompatibleVectors - The assignment is between two vector types that\n /// have the same size, which we accept as an extension.\n IncompatibleVectors,\n\n /// IntToBlockPointer - The assignment converts an int to a block\n /// pointer. We disallow this.\n IntToBlockPointer,\n\n /// IncompatibleBlockPointer - The assignment is between two block\n /// pointers types that are not compatible.\n IncompatibleBlockPointer,\n\n /// IncompatibleObjCQualifiedId - The assignment is between a qualified\n /// id type and something else (that is incompatible with it). For example,\n /// \"id <XXX>\" = \"Foo *\", where \"Foo *\" doesn't implement the XXX protocol.\n IncompatibleObjCQualifiedId,\n\n /// IncompatibleObjCWeakRef - Assigning a weak-unavailable object to an\n /// object with __weak qualifier.\n IncompatibleObjCWeakRef,\n\n /// Incompatible - We reject this conversion outright, it is invalid to\n /// represent it in the AST.\n Incompatible\n };\n\n /// DiagnoseAssignmentResult - Emit a diagnostic, if required, for the\n /// assignment conversion type specified by ConvTy. This returns true if the\n /// conversion was invalid or false if the conversion was accepted.\n bool DiagnoseAssignmentResult(AssignConvertType ConvTy,\n SourceLocation Loc,\n QualType DstType, QualType SrcType,\n Expr *SrcExpr, AssignmentAction Action,\n bool *Complained = nullptr);\n\n /// IsValueInFlagEnum - Determine if a value is allowed as part of a flag\n /// enum. If AllowMask is true, then we also allow the complement of a valid\n /// value, to be used as a mask.\n bool IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val,\n bool AllowMask) const;\n\n /// DiagnoseAssignmentEnum - Warn if assignment to enum is a constant\n /// integer not in the range of enum values.\n void DiagnoseAssignmentEnum(QualType DstType, QualType SrcType,\n Expr *SrcExpr);\n\n /// CheckAssignmentConstraints - Perform type checking for assignment,\n /// argument passing, variable initialization, and function return values.\n /// C99 6.5.16.\n AssignConvertType CheckAssignmentConstraints(SourceLocation Loc,\n QualType LHSType,\n QualType RHSType);\n\n /// Check assignment constraints and optionally prepare for a conversion of\n /// the RHS to the LHS type. The conversion is prepared for if ConvertRHS\n /// is true.\n AssignConvertType CheckAssignmentConstraints(QualType LHSType,\n ExprResult &RHS,\n CastKind &Kind,\n bool ConvertRHS = true);\n\n /// Check assignment constraints for an assignment of RHS to LHSType.\n ///\n /// \\param LHSType The destination type for the assignment.\n /// \\param RHS The source expression for the assignment.\n /// \\param Diagnose If \\c true, diagnostics may be produced when checking\n /// for assignability. If a diagnostic is produced, \\p RHS will be\n /// set to ExprError(). Note that this function may still return\n /// without producing a diagnostic, even for an invalid assignment.\n /// \\param DiagnoseCFAudited If \\c true, the target is a function parameter\n /// in an audited Core Foundation API and does not need to be checked\n /// for ARC retain issues.\n /// \\param ConvertRHS If \\c true, \\p RHS will be updated to model the\n /// conversions necessary to perform the assignment. If \\c false,\n /// \\p Diagnose must also be \\c false.\n AssignConvertType CheckSingleAssignmentConstraints(\n QualType LHSType, ExprResult &RHS, bool Diagnose = true,\n bool DiagnoseCFAudited = false, bool ConvertRHS = true);\n\n // If the lhs type is a transparent union, check whether we\n // can initialize the transparent union with the given expression.\n AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType,\n ExprResult &RHS);\n\n bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType);\n\n bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType);\n\n ExprResult PerformImplicitConversion(Expr *From, QualType ToType,\n AssignmentAction Action,\n bool AllowExplicit = false);\n ExprResult PerformImplicitConversion(Expr *From, QualType ToType,\n const ImplicitConversionSequence& ICS,\n AssignmentAction Action,\n CheckedConversionKind CCK\n = CCK_ImplicitConversion);\n ExprResult PerformImplicitConversion(Expr *From, QualType ToType,\n const StandardConversionSequence& SCS,\n AssignmentAction Action,\n CheckedConversionKind CCK);\n\n ExprResult PerformQualificationConversion(\n Expr *E, QualType Ty, ExprValueKind VK = VK_RValue,\n CheckedConversionKind CCK = CCK_ImplicitConversion);\n\n /// the following \"Check\" methods will return a valid/converted QualType\n /// or a null QualType (indicating an error diagnostic was issued).\n\n /// type checking binary operators (subroutines of CreateBuiltinBinOp).\n QualType InvalidOperands(SourceLocation Loc, ExprResult &LHS,\n ExprResult &RHS);\n QualType InvalidLogicalVectorOperands(SourceLocation Loc, ExprResult &LHS,\n ExprResult &RHS);\n QualType CheckPointerToMemberOperands( // C++ 5.5\n ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK,\n SourceLocation OpLoc, bool isIndirect);\n QualType CheckMultiplyDivideOperands( // C99 6.5.5\n ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign,\n bool IsDivide);\n QualType CheckRemainderOperands( // C99 6.5.5\n ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,\n bool IsCompAssign = false);\n QualType CheckAdditionOperands( // C99 6.5.6\n ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,\n BinaryOperatorKind Opc, QualType* CompLHSTy = nullptr);\n QualType CheckSubtractionOperands( // C99 6.5.6\n ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,\n QualType* CompLHSTy = nullptr);\n QualType CheckShiftOperands( // C99 6.5.7\n ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,\n BinaryOperatorKind Opc, bool IsCompAssign = false);\n void CheckPtrComparisonWithNullChar(ExprResult &E, ExprResult &NullE);\n QualType CheckCompareOperands( // C99 6.5.8/9\n ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,\n BinaryOperatorKind Opc);\n QualType CheckBitwiseOperands( // C99 6.5.[10...12]\n ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,\n BinaryOperatorKind Opc);\n QualType CheckLogicalOperands( // C99 6.5.[13,14]\n ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,\n BinaryOperatorKind Opc);\n // CheckAssignmentOperands is used for both simple and compound assignment.\n // For simple assignment, pass both expressions and a null converted type.\n // For compound assignment, pass both expressions and the converted type.\n QualType CheckAssignmentOperands( // C99 6.5.16.[1,2]\n Expr *LHSExpr, ExprResult &RHS, SourceLocation Loc, QualType CompoundType);\n\n ExprResult checkPseudoObjectIncDec(Scope *S, SourceLocation OpLoc,\n UnaryOperatorKind Opcode, Expr *Op);\n ExprResult checkPseudoObjectAssignment(Scope *S, SourceLocation OpLoc,\n BinaryOperatorKind Opcode,\n Expr *LHS, Expr *RHS);\n ExprResult checkPseudoObjectRValue(Expr *E);\n Expr *recreateSyntacticForm(PseudoObjectExpr *E);\n\n QualType CheckConditionalOperands( // C99 6.5.15\n ExprResult &Cond, ExprResult &LHS, ExprResult &RHS,\n ExprValueKind &VK, ExprObjectKind &OK, SourceLocation QuestionLoc);\n QualType CXXCheckConditionalOperands( // C++ 5.16\n ExprResult &cond, ExprResult &lhs, ExprResult &rhs,\n ExprValueKind &VK, ExprObjectKind &OK, SourceLocation questionLoc);\n QualType CheckVectorConditionalTypes(ExprResult &Cond, ExprResult &LHS,\n ExprResult &RHS,\n SourceLocation QuestionLoc);\n QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2,\n bool ConvertArgs = true);\n QualType FindCompositePointerType(SourceLocation Loc,\n ExprResult &E1, ExprResult &E2,\n bool ConvertArgs = true) {\n Expr *E1Tmp = E1.get(), *E2Tmp = E2.get();\n QualType Composite =\n FindCompositePointerType(Loc, E1Tmp, E2Tmp, ConvertArgs);\n E1 = E1Tmp;\n E2 = E2Tmp;\n return Composite;\n }\n\n QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS,\n SourceLocation QuestionLoc);\n\n bool DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr,\n SourceLocation QuestionLoc);\n\n void DiagnoseAlwaysNonNullPointer(Expr *E,\n Expr::NullPointerConstantKind NullType,\n bool IsEqual, SourceRange Range);\n\n /// type checking for vector binary operators.\n QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,\n SourceLocation Loc, bool IsCompAssign,\n bool AllowBothBool, bool AllowBoolConversion);\n QualType GetSignedVectorType(QualType V);\n QualType CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS,\n SourceLocation Loc,\n BinaryOperatorKind Opc);\n QualType CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS,\n SourceLocation Loc);\n\n /// Type checking for matrix binary operators.\n QualType CheckMatrixElementwiseOperands(ExprResult &LHS, ExprResult &RHS,\n SourceLocation Loc,\n bool IsCompAssign);\n QualType CheckMatrixMultiplyOperands(ExprResult &LHS, ExprResult &RHS,\n SourceLocation Loc, bool IsCompAssign);\n\n bool isValidSveBitcast(QualType srcType, QualType destType);\n\n bool areLaxCompatibleVectorTypes(QualType srcType, QualType destType);\n bool isLaxVectorConversion(QualType srcType, QualType destType);\n\n /// type checking declaration initializers (C99 6.7.8)\n bool CheckForConstantInitializer(Expr *e, QualType t);\n\n // type checking C++ declaration initializers (C++ [dcl.init]).\n\n /// ReferenceCompareResult - Expresses the result of comparing two\n /// types (cv1 T1 and cv2 T2) to determine their compatibility for the\n /// purposes of initialization by reference (C++ [dcl.init.ref]p4).\n enum ReferenceCompareResult {\n /// Ref_Incompatible - The two types are incompatible, so direct\n /// reference binding is not possible.\n Ref_Incompatible = 0,\n /// Ref_Related - The two types are reference-related, which means\n /// that their unqualified forms (T1 and T2) are either the same\n /// or T1 is a base class of T2.\n Ref_Related,\n /// Ref_Compatible - The two types are reference-compatible.\n Ref_Compatible\n };\n\n // Fake up a scoped enumeration that still contextually converts to bool.\n struct ReferenceConversionsScope {\n /// The conversions that would be performed on an lvalue of type T2 when\n /// binding a reference of type T1 to it, as determined when evaluating\n /// whether T1 is reference-compatible with T2.\n enum ReferenceConversions {\n Qualification = 0x1,\n NestedQualification = 0x2,\n Function = 0x4,\n DerivedToBase = 0x8,\n ObjC = 0x10,\n ObjCLifetime = 0x20,\n\n LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/ObjCLifetime)\n };\n };\n using ReferenceConversions = ReferenceConversionsScope::ReferenceConversions;\n\n ReferenceCompareResult\n CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2,\n ReferenceConversions *Conv = nullptr);\n\n ExprResult checkUnknownAnyCast(SourceRange TypeRange, QualType CastType,\n Expr *CastExpr, CastKind &CastKind,\n ExprValueKind &VK, CXXCastPath &Path);\n\n /// Force an expression with unknown-type to an expression of the\n /// given type.\n ExprResult forceUnknownAnyToType(Expr *E, QualType ToType);\n\n /// Type-check an expression that's being passed to an\n /// __unknown_anytype parameter.\n ExprResult checkUnknownAnyArg(SourceLocation callLoc,\n Expr *result, QualType ¶mType);\n\n // CheckVectorCast - check type constraints for vectors.\n // Since vectors are an extension, there are no C standard reference for this.\n // We allow casting between vectors and integer datatypes of the same size.\n // returns true if the cast is invalid\n bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,\n CastKind &Kind);\n\n /// Prepare `SplattedExpr` for a vector splat operation, adding\n /// implicit casts if necessary.\n ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr);\n\n // CheckExtVectorCast - check type constraints for extended vectors.\n // Since vectors are an extension, there are no C standard reference for this.\n // We allow casting between vectors and integer datatypes of the same size,\n // or vectors and the element type of that vector.\n // returns the cast expr\n ExprResult CheckExtVectorCast(SourceRange R, QualType DestTy, Expr *CastExpr,\n CastKind &Kind);\n\n ExprResult BuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, QualType Type,\n SourceLocation LParenLoc,\n Expr *CastExpr,\n SourceLocation RParenLoc);\n\n enum ARCConversionResult { ACR_okay, ACR_unbridged, ACR_error };\n\n /// Checks for invalid conversions and casts between\n /// retainable pointers and other pointer kinds for ARC and Weak.\n ARCConversionResult CheckObjCConversion(SourceRange castRange,\n QualType castType, Expr *&op,\n CheckedConversionKind CCK,\n bool Diagnose = true,\n bool DiagnoseCFAudited = false,\n BinaryOperatorKind Opc = BO_PtrMemD\n );\n\n Expr *stripARCUnbridgedCast(Expr *e);\n void diagnoseARCUnbridgedCast(Expr *e);\n\n bool CheckObjCARCUnavailableWeakConversion(QualType castType,\n QualType ExprType);\n\n /// checkRetainCycles - Check whether an Objective-C message send\n /// might create an obvious retain cycle.\n void checkRetainCycles(ObjCMessageExpr *msg);\n void checkRetainCycles(Expr *receiver, Expr *argument);\n void checkRetainCycles(VarDecl *Var, Expr *Init);\n\n /// checkUnsafeAssigns - Check whether +1 expr is being assigned\n /// to weak/__unsafe_unretained type.\n bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS);\n\n /// checkUnsafeExprAssigns - Check whether +1 expr is being assigned\n /// to weak/__unsafe_unretained expression.\n void checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS);\n\n /// CheckMessageArgumentTypes - Check types in an Obj-C message send.\n /// \\param Method - May be null.\n /// \\param [out] ReturnType - The return type of the send.\n /// \\return true iff there were any incompatible types.\n bool CheckMessageArgumentTypes(const Expr *Receiver, QualType ReceiverType,\n MultiExprArg Args, Selector Sel,\n ArrayRef<SourceLocation> SelectorLocs,\n ObjCMethodDecl *Method, bool isClassMessage,\n bool isSuperMessage, SourceLocation lbrac,\n SourceLocation rbrac, SourceRange RecRange,\n QualType &ReturnType, ExprValueKind &VK);\n\n /// Determine the result of a message send expression based on\n /// the type of the receiver, the method expected to receive the message,\n /// and the form of the message send.\n QualType getMessageSendResultType(const Expr *Receiver, QualType ReceiverType,\n ObjCMethodDecl *Method, bool isClassMessage,\n bool isSuperMessage);\n\n /// If the given expression involves a message send to a method\n /// with a related result type, emit a note describing what happened.\n void EmitRelatedResultTypeNote(const Expr *E);\n\n /// Given that we had incompatible pointer types in a return\n /// statement, check whether we're in a method with a related result\n /// type, and if so, emit a note describing what happened.\n void EmitRelatedResultTypeNoteForReturn(QualType destType);\n\n class ConditionResult {\n Decl *ConditionVar;\n FullExprArg Condition;\n bool Invalid;\n bool HasKnownValue;\n bool KnownValue;\n\n friend class Sema;\n ConditionResult(Sema &S, Decl *ConditionVar, FullExprArg Condition,\n bool IsConstexpr)\n : ConditionVar(ConditionVar), Condition(Condition), Invalid(false),\n HasKnownValue(IsConstexpr && Condition.get() &&\n !Condition.get()->isValueDependent()),\n KnownValue(HasKnownValue &&\n !!Condition.get()->EvaluateKnownConstInt(S.Context)) {}\n explicit ConditionResult(bool Invalid)\n : ConditionVar(nullptr), Condition(nullptr), Invalid(Invalid),\n HasKnownValue(false), KnownValue(false) {}\n\n public:\n ConditionResult() : ConditionResult(false) {}\n bool isInvalid() const { return Invalid; }\n std::pair<VarDecl *, Expr *> get() const {\n return std::make_pair(cast_or_null<VarDecl>(ConditionVar),\n Condition.get());\n }\n llvm::Optional<bool> getKnownValue() const {\n if (!HasKnownValue)\n return None;\n return KnownValue;\n }\n };\n static ConditionResult ConditionError() { return ConditionResult(true); }\n\n enum class ConditionKind {\n Boolean, ///< A boolean condition, from 'if', 'while', 'for', or 'do'.\n ConstexprIf, ///< A constant boolean condition from 'if constexpr'.\n Switch ///< An integral condition for a 'switch' statement.\n };\n\n ConditionResult ActOnCondition(Scope *S, SourceLocation Loc,\n Expr *SubExpr, ConditionKind CK);\n\n ConditionResult ActOnConditionVariable(Decl *ConditionVar,\n SourceLocation StmtLoc,\n ConditionKind CK);\n\n DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D);\n\n ExprResult CheckConditionVariable(VarDecl *ConditionVar,\n SourceLocation StmtLoc,\n ConditionKind CK);\n ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond);\n\n /// CheckBooleanCondition - Diagnose problems involving the use of\n /// the given expression as a boolean condition (e.g. in an if\n /// statement). Also performs the standard function and array\n /// decays, possibly changing the input variable.\n ///\n /// \\param Loc - A location associated with the condition, e.g. the\n /// 'if' keyword.\n /// \\return true iff there were any errors\n ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E,\n bool IsConstexpr = false);\n\n /// ActOnExplicitBoolSpecifier - Build an ExplicitSpecifier from an expression\n /// found in an explicit(bool) specifier.\n ExplicitSpecifier ActOnExplicitBoolSpecifier(Expr *E);\n\n /// tryResolveExplicitSpecifier - Attempt to resolve the explict specifier.\n /// Returns true if the explicit specifier is now resolved.\n bool tryResolveExplicitSpecifier(ExplicitSpecifier &ExplicitSpec);\n\n /// DiagnoseAssignmentAsCondition - Given that an expression is\n /// being used as a boolean condition, warn if it's an assignment.\n void DiagnoseAssignmentAsCondition(Expr *E);\n\n /// Redundant parentheses over an equality comparison can indicate\n /// that the user intended an assignment used as condition.\n void DiagnoseEqualityWithExtraParens(ParenExpr *ParenE);\n\n /// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.\n ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr = false);\n\n /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have\n /// the specified width and sign. If an overflow occurs, detect it and emit\n /// the specified diagnostic.\n void ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &OldVal,\n unsigned NewWidth, bool NewSign,\n SourceLocation Loc, unsigned DiagID);\n\n /// Checks that the Objective-C declaration is declared in the global scope.\n /// Emits an error and marks the declaration as invalid if it's not declared\n /// in the global scope.\n bool CheckObjCDeclScope(Decl *D);\n\n /// Abstract base class used for diagnosing integer constant\n /// expression violations.\n class VerifyICEDiagnoser {\n public:\n bool Suppress;\n\n VerifyICEDiagnoser(bool Suppress = false) : Suppress(Suppress) { }\n\n virtual SemaDiagnosticBuilder\n diagnoseNotICEType(Sema &S, SourceLocation Loc, QualType T);\n virtual SemaDiagnosticBuilder diagnoseNotICE(Sema &S,\n SourceLocation Loc) = 0;\n virtual SemaDiagnosticBuilder diagnoseFold(Sema &S, SourceLocation Loc);\n virtual ~VerifyICEDiagnoser() {}\n };\n\n enum AllowFoldKind {\n NoFold,\n AllowFold,\n };\n\n /// VerifyIntegerConstantExpression - Verifies that an expression is an ICE,\n /// and reports the appropriate diagnostics. Returns false on success.\n /// Can optionally return the value of the expression.\n ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,\n VerifyICEDiagnoser &Diagnoser,\n AllowFoldKind CanFold = NoFold);\n ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,\n unsigned DiagID,\n AllowFoldKind CanFold = NoFold);\n ExprResult VerifyIntegerConstantExpression(Expr *E,\n llvm::APSInt *Result = nullptr,\n AllowFoldKind CanFold = NoFold);\n ExprResult VerifyIntegerConstantExpression(Expr *E,\n AllowFoldKind CanFold = NoFold) {\n return VerifyIntegerConstantExpression(E, nullptr, CanFold);\n }\n\n /// VerifyBitField - verifies that a bit field expression is an ICE and has\n /// the correct width, and that the field type is valid.\n /// Returns false on success.\n /// Can optionally return whether the bit-field is of width 0\n ExprResult VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,\n QualType FieldTy, bool IsMsStruct,\n Expr *BitWidth, bool *ZeroWidth = nullptr);\n\nprivate:\n unsigned ForceCUDAHostDeviceDepth = 0;\n\npublic:\n /// Increments our count of the number of times we've seen a pragma forcing\n /// functions to be __host__ __device__. So long as this count is greater\n /// than zero, all functions encountered will be __host__ __device__.\n void PushForceCUDAHostDevice();\n\n /// Decrements our count of the number of times we've seen a pragma forcing\n /// functions to be __host__ __device__. Returns false if the count is 0\n /// before incrementing, so you can emit an error.\n bool PopForceCUDAHostDevice();\n\n /// Diagnostics that are emitted only if we discover that the given function\n /// must be codegen'ed. Because handling these correctly adds overhead to\n /// compilation, this is currently only enabled for CUDA compilations.\n llvm::DenseMap<CanonicalDeclPtr<FunctionDecl>,\n std::vector<PartialDiagnosticAt>>\n DeviceDeferredDiags;\n\n /// A pair of a canonical FunctionDecl and a SourceLocation. When used as the\n /// key in a hashtable, both the FD and location are hashed.\n struct FunctionDeclAndLoc {\n CanonicalDeclPtr<FunctionDecl> FD;\n SourceLocation Loc;\n };\n\n /// FunctionDecls and SourceLocations for which CheckCUDACall has emitted a\n /// (maybe deferred) \"bad call\" diagnostic. We use this to avoid emitting the\n /// same deferred diag twice.\n llvm::DenseSet<FunctionDeclAndLoc> LocsWithCUDACallDiags;\n\n /// An inverse call graph, mapping known-emitted functions to one of their\n /// known-emitted callers (plus the location of the call).\n ///\n /// Functions that we can tell a priori must be emitted aren't added to this\n /// map.\n llvm::DenseMap</* Callee = */ CanonicalDeclPtr<FunctionDecl>,\n /* Caller = */ FunctionDeclAndLoc>\n DeviceKnownEmittedFns;\n\n /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current\n /// context is \"used as device code\".\n ///\n /// - If CurContext is a __host__ function, does not emit any diagnostics\n /// unless \\p EmitOnBothSides is true.\n /// - If CurContext is a __device__ or __global__ function, emits the\n /// diagnostics immediately.\n /// - If CurContext is a __host__ __device__ function and we are compiling for\n /// the device, creates a diagnostic which is emitted if and when we realize\n /// that the function will be codegen'ed.\n ///\n /// Example usage:\n ///\n /// // Variable-length arrays are not allowed in CUDA device code.\n /// if (CUDADiagIfDeviceCode(Loc, diag::err_cuda_vla) << CurrentCUDATarget())\n /// return ExprError();\n /// // Otherwise, continue parsing as normal.\n SemaDiagnosticBuilder CUDADiagIfDeviceCode(SourceLocation Loc,\n unsigned DiagID);\n\n /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current\n /// context is \"used as host code\".\n ///\n /// Same as CUDADiagIfDeviceCode, with \"host\" and \"device\" switched.\n SemaDiagnosticBuilder CUDADiagIfHostCode(SourceLocation Loc, unsigned DiagID);\n\n /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current\n /// context is \"used as device code\".\n ///\n /// - If CurContext is a `declare target` function or it is known that the\n /// function is emitted for the device, emits the diagnostics immediately.\n /// - If CurContext is a non-`declare target` function and we are compiling\n /// for the device, creates a diagnostic which is emitted if and when we\n /// realize that the function will be codegen'ed.\n ///\n /// Example usage:\n ///\n /// // Variable-length arrays are not allowed in NVPTX device code.\n /// if (diagIfOpenMPDeviceCode(Loc, diag::err_vla_unsupported))\n /// return ExprError();\n /// // Otherwise, continue parsing as normal.\n SemaDiagnosticBuilder\n diagIfOpenMPDeviceCode(SourceLocation Loc, unsigned DiagID, FunctionDecl *FD);\n\n /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current\n /// context is \"used as host code\".\n ///\n /// - If CurContext is a `declare target` function or it is known that the\n /// function is emitted for the host, emits the diagnostics immediately.\n /// - If CurContext is a non-host function, just ignore it.\n ///\n /// Example usage:\n ///\n /// // Variable-length arrays are not allowed in NVPTX device code.\n /// if (diagIfOpenMPHostode(Loc, diag::err_vla_unsupported))\n /// return ExprError();\n /// // Otherwise, continue parsing as normal.\n SemaDiagnosticBuilder diagIfOpenMPHostCode(SourceLocation Loc,\n unsigned DiagID, FunctionDecl *FD);\n\n SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID,\n FunctionDecl *FD = nullptr);\n SemaDiagnosticBuilder targetDiag(SourceLocation Loc,\n const PartialDiagnostic &PD,\n FunctionDecl *FD = nullptr) {\n return targetDiag(Loc, PD.getDiagID(), FD) << PD;\n }\n\n /// Check if the expression is allowed to be used in expressions for the\n /// offloading devices.\n void checkDeviceDecl(ValueDecl *D, SourceLocation Loc);\n\n enum CUDAFunctionTarget {\n CFT_Device,\n CFT_Global,\n CFT_Host,\n CFT_HostDevice,\n CFT_InvalidTarget\n };\n\n /// Determines whether the given function is a CUDA device/host/kernel/etc.\n /// function.\n ///\n /// Use this rather than examining the function's attributes yourself -- you\n /// will get it wrong. Returns CFT_Host if D is null.\n CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D,\n bool IgnoreImplicitHDAttr = false);\n CUDAFunctionTarget IdentifyCUDATarget(const ParsedAttributesView &Attrs);\n\n /// Gets the CUDA target for the current context.\n CUDAFunctionTarget CurrentCUDATarget() {\n return IdentifyCUDATarget(dyn_cast<FunctionDecl>(CurContext));\n }\n\n static bool isCUDAImplicitHostDeviceFunction(const FunctionDecl *D);\n\n // CUDA function call preference. Must be ordered numerically from\n // worst to best.\n enum CUDAFunctionPreference {\n CFP_Never, // Invalid caller/callee combination.\n CFP_WrongSide, // Calls from host-device to host or device\n // function that do not match current compilation\n // mode.\n CFP_HostDevice, // Any calls to host/device functions.\n CFP_SameSide, // Calls from host-device to host or device\n // function matching current compilation mode.\n CFP_Native, // host-to-host or device-to-device calls.\n };\n\n /// Identifies relative preference of a given Caller/Callee\n /// combination, based on their host/device attributes.\n /// \\param Caller function which needs address of \\p Callee.\n /// nullptr in case of global context.\n /// \\param Callee target function\n ///\n /// \\returns preference value for particular Caller/Callee combination.\n CUDAFunctionPreference IdentifyCUDAPreference(const FunctionDecl *Caller,\n const FunctionDecl *Callee);\n\n /// Determines whether Caller may invoke Callee, based on their CUDA\n /// host/device attributes. Returns false if the call is not allowed.\n ///\n /// Note: Will return true for CFP_WrongSide calls. These may appear in\n /// semantically correct CUDA programs, but only if they're never codegen'ed.\n bool IsAllowedCUDACall(const FunctionDecl *Caller,\n const FunctionDecl *Callee) {\n return IdentifyCUDAPreference(Caller, Callee) != CFP_Never;\n }\n\n /// May add implicit CUDAHostAttr and CUDADeviceAttr attributes to FD,\n /// depending on FD and the current compilation settings.\n void maybeAddCUDAHostDeviceAttrs(FunctionDecl *FD,\n const LookupResult &Previous);\n\n /// May add implicit CUDAConstantAttr attribute to VD, depending on VD\n /// and current compilation settings.\n void MaybeAddCUDAConstantAttr(VarDecl *VD);\n\npublic:\n /// Check whether we're allowed to call Callee from the current context.\n ///\n /// - If the call is never allowed in a semantically-correct program\n /// (CFP_Never), emits an error and returns false.\n ///\n /// - If the call is allowed in semantically-correct programs, but only if\n /// it's never codegen'ed (CFP_WrongSide), creates a deferred diagnostic to\n /// be emitted if and when the caller is codegen'ed, and returns true.\n ///\n /// Will only create deferred diagnostics for a given SourceLocation once,\n /// so you can safely call this multiple times without generating duplicate\n /// deferred errors.\n ///\n /// - Otherwise, returns true without emitting any diagnostics.\n bool CheckCUDACall(SourceLocation Loc, FunctionDecl *Callee);\n\n void CUDACheckLambdaCapture(CXXMethodDecl *D, const sema::Capture &Capture);\n\n /// Set __device__ or __host__ __device__ attributes on the given lambda\n /// operator() method.\n ///\n /// CUDA lambdas by default is host device function unless it has explicit\n /// host or device attribute.\n void CUDASetLambdaAttrs(CXXMethodDecl *Method);\n\n /// Finds a function in \\p Matches with highest calling priority\n /// from \\p Caller context and erases all functions with lower\n /// calling priority.\n void EraseUnwantedCUDAMatches(\n const FunctionDecl *Caller,\n SmallVectorImpl<std::pair<DeclAccessPair, FunctionDecl *>> &Matches);\n\n /// Given a implicit special member, infer its CUDA target from the\n /// calls it needs to make to underlying base/field special members.\n /// \\param ClassDecl the class for which the member is being created.\n /// \\param CSM the kind of special member.\n /// \\param MemberDecl the special member itself.\n /// \\param ConstRHS true if this is a copy operation with a const object on\n /// its RHS.\n /// \\param Diagnose true if this call should emit diagnostics.\n /// \\return true if there was an error inferring.\n /// The result of this call is implicit CUDA target attribute(s) attached to\n /// the member declaration.\n bool inferCUDATargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl,\n CXXSpecialMember CSM,\n CXXMethodDecl *MemberDecl,\n bool ConstRHS,\n bool Diagnose);\n\n /// \\return true if \\p CD can be considered empty according to CUDA\n /// (E.2.3.1 in CUDA 7.5 Programming guide).\n bool isEmptyCudaConstructor(SourceLocation Loc, CXXConstructorDecl *CD);\n bool isEmptyCudaDestructor(SourceLocation Loc, CXXDestructorDecl *CD);\n\n // \\brief Checks that initializers of \\p Var satisfy CUDA restrictions. In\n // case of error emits appropriate diagnostic and invalidates \\p Var.\n //\n // \\details CUDA allows only empty constructors as initializers for global\n // variables (see E.2.3.1, CUDA 7.5). The same restriction also applies to all\n // __shared__ variables whether they are local or not (they all are implicitly\n // static in CUDA). One exception is that CUDA allows constant initializers\n // for __constant__ and __device__ variables.\n void checkAllowedCUDAInitializer(VarDecl *VD);\n\n /// Check whether NewFD is a valid overload for CUDA. Emits\n /// diagnostics and invalidates NewFD if not.\n void checkCUDATargetOverload(FunctionDecl *NewFD,\n const LookupResult &Previous);\n /// Copies target attributes from the template TD to the function FD.\n void inheritCUDATargetAttrs(FunctionDecl *FD, const FunctionTemplateDecl &TD);\n\n /// Returns the name of the launch configuration function. This is the name\n /// of the function that will be called to configure kernel call, with the\n /// parameters specified via <<<>>>.\n std::string getCudaConfigureFuncName() const;\n\n /// \\name Code completion\n //@{\n /// Describes the context in which code completion occurs.\n enum ParserCompletionContext {\n /// Code completion occurs at top-level or namespace context.\n PCC_Namespace,\n /// Code completion occurs within a class, struct, or union.\n PCC_Class,\n /// Code completion occurs within an Objective-C interface, protocol,\n /// or category.\n PCC_ObjCInterface,\n /// Code completion occurs within an Objective-C implementation or\n /// category implementation\n PCC_ObjCImplementation,\n /// Code completion occurs within the list of instance variables\n /// in an Objective-C interface, protocol, category, or implementation.\n PCC_ObjCInstanceVariableList,\n /// Code completion occurs following one or more template\n /// headers.\n PCC_Template,\n /// Code completion occurs following one or more template\n /// headers within a class.\n PCC_MemberTemplate,\n /// Code completion occurs within an expression.\n PCC_Expression,\n /// Code completion occurs within a statement, which may\n /// also be an expression or a declaration.\n PCC_Statement,\n /// Code completion occurs at the beginning of the\n /// initialization statement (or expression) in a for loop.\n PCC_ForInit,\n /// Code completion occurs within the condition of an if,\n /// while, switch, or for statement.\n PCC_Condition,\n /// Code completion occurs within the body of a function on a\n /// recovery path, where we do not have a specific handle on our position\n /// in the grammar.\n PCC_RecoveryInFunction,\n /// Code completion occurs where only a type is permitted.\n PCC_Type,\n /// Code completion occurs in a parenthesized expression, which\n /// might also be a type cast.\n PCC_ParenthesizedExpression,\n /// Code completion occurs within a sequence of declaration\n /// specifiers within a function, method, or block.\n PCC_LocalDeclarationSpecifiers\n };\n\n void CodeCompleteModuleImport(SourceLocation ImportLoc, ModuleIdPath Path);\n void CodeCompleteOrdinaryName(Scope *S,\n ParserCompletionContext CompletionContext);\n void CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,\n bool AllowNonIdentifiers,\n bool AllowNestedNameSpecifiers);\n\n struct CodeCompleteExpressionData;\n void CodeCompleteExpression(Scope *S,\n const CodeCompleteExpressionData &Data);\n void CodeCompleteExpression(Scope *S, QualType PreferredType,\n bool IsParenthesized = false);\n void CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base, Expr *OtherOpBase,\n SourceLocation OpLoc, bool IsArrow,\n bool IsBaseExprStatement,\n QualType PreferredType);\n void CodeCompletePostfixExpression(Scope *S, ExprResult LHS,\n QualType PreferredType);\n void CodeCompleteTag(Scope *S, unsigned TagSpec);\n void CodeCompleteTypeQualifiers(DeclSpec &DS);\n void CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D,\n const VirtSpecifiers *VS = nullptr);\n void CodeCompleteBracketDeclarator(Scope *S);\n void CodeCompleteCase(Scope *S);\n /// Determines the preferred type of the current function argument, by\n /// examining the signatures of all possible overloads.\n /// Returns null if unknown or ambiguous, or if code completion is off.\n ///\n /// If the code completion point has been reached, also reports the function\n /// signatures that were considered.\n ///\n /// FIXME: rename to GuessCallArgumentType to reduce confusion.\n QualType ProduceCallSignatureHelp(Scope *S, Expr *Fn, ArrayRef<Expr *> Args,\n SourceLocation OpenParLoc);\n QualType ProduceConstructorSignatureHelp(Scope *S, QualType Type,\n SourceLocation Loc,\n ArrayRef<Expr *> Args,\n SourceLocation OpenParLoc);\n QualType ProduceCtorInitMemberSignatureHelp(Scope *S, Decl *ConstructorDecl,\n CXXScopeSpec SS,\n ParsedType TemplateTypeTy,\n ArrayRef<Expr *> ArgExprs,\n IdentifierInfo *II,\n SourceLocation OpenParLoc);\n void CodeCompleteInitializer(Scope *S, Decl *D);\n /// Trigger code completion for a record of \\p BaseType. \\p InitExprs are\n /// expressions in the initializer list seen so far and \\p D is the current\n /// Designation being parsed.\n void CodeCompleteDesignator(const QualType BaseType,\n llvm::ArrayRef<Expr *> InitExprs,\n const Designation &D);\n void CodeCompleteAfterIf(Scope *S, bool IsBracedThen);\n\n void CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, bool EnteringContext,\n bool IsUsingDeclaration, QualType BaseType,\n QualType PreferredType);\n void CodeCompleteUsing(Scope *S);\n void CodeCompleteUsingDirective(Scope *S);\n void CodeCompleteNamespaceDecl(Scope *S);\n void CodeCompleteNamespaceAliasDecl(Scope *S);\n void CodeCompleteOperatorName(Scope *S);\n void CodeCompleteConstructorInitializer(\n Decl *Constructor,\n ArrayRef<CXXCtorInitializer *> Initializers);\n\n void CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,\n bool AfterAmpersand);\n void CodeCompleteAfterFunctionEquals(Declarator &D);\n\n void CodeCompleteObjCAtDirective(Scope *S);\n void CodeCompleteObjCAtVisibility(Scope *S);\n void CodeCompleteObjCAtStatement(Scope *S);\n void CodeCompleteObjCAtExpression(Scope *S);\n void CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS);\n void CodeCompleteObjCPropertyGetter(Scope *S);\n void CodeCompleteObjCPropertySetter(Scope *S);\n void CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,\n bool IsParameter);\n void CodeCompleteObjCMessageReceiver(Scope *S);\n void CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,\n ArrayRef<IdentifierInfo *> SelIdents,\n bool AtArgumentExpression);\n void CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,\n ArrayRef<IdentifierInfo *> SelIdents,\n bool AtArgumentExpression,\n bool IsSuper = false);\n void CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,\n ArrayRef<IdentifierInfo *> SelIdents,\n bool AtArgumentExpression,\n ObjCInterfaceDecl *Super = nullptr);\n void CodeCompleteObjCForCollection(Scope *S,\n DeclGroupPtrTy IterationVar);\n void CodeCompleteObjCSelector(Scope *S,\n ArrayRef<IdentifierInfo *> SelIdents);\n void CodeCompleteObjCProtocolReferences(\n ArrayRef<IdentifierLocPair> Protocols);\n void CodeCompleteObjCProtocolDecl(Scope *S);\n void CodeCompleteObjCInterfaceDecl(Scope *S);\n void CodeCompleteObjCSuperclass(Scope *S,\n IdentifierInfo *ClassName,\n SourceLocation ClassNameLoc);\n void CodeCompleteObjCImplementationDecl(Scope *S);\n void CodeCompleteObjCInterfaceCategory(Scope *S,\n IdentifierInfo *ClassName,\n SourceLocation ClassNameLoc);\n void CodeCompleteObjCImplementationCategory(Scope *S,\n IdentifierInfo *ClassName,\n SourceLocation ClassNameLoc);\n void CodeCompleteObjCPropertyDefinition(Scope *S);\n void CodeCompleteObjCPropertySynthesizeIvar(Scope *S,\n IdentifierInfo *PropertyName);\n void CodeCompleteObjCMethodDecl(Scope *S, Optional<bool> IsInstanceMethod,\n ParsedType ReturnType);\n void CodeCompleteObjCMethodDeclSelector(Scope *S,\n bool IsInstanceMethod,\n bool AtParameterName,\n ParsedType ReturnType,\n ArrayRef<IdentifierInfo *> SelIdents);\n void CodeCompleteObjCClassPropertyRefExpr(Scope *S, IdentifierInfo &ClassName,\n SourceLocation ClassNameLoc,\n bool IsBaseExprStatement);\n void CodeCompletePreprocessorDirective(bool InConditional);\n void CodeCompleteInPreprocessorConditionalExclusion(Scope *S);\n void CodeCompletePreprocessorMacroName(bool IsDefinition);\n void CodeCompletePreprocessorExpression();\n void CodeCompletePreprocessorMacroArgument(Scope *S,\n IdentifierInfo *Macro,\n MacroInfo *MacroInfo,\n unsigned Argument);\n void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled);\n void CodeCompleteNaturalLanguage();\n void CodeCompleteAvailabilityPlatformName();\n void GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,\n CodeCompletionTUInfo &CCTUInfo,\n SmallVectorImpl<CodeCompletionResult> &Results);\n //@}\n\n //===--------------------------------------------------------------------===//\n // Extra semantic analysis beyond the C type system\n\npublic:\n SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL,\n unsigned ByteNo) const;\n\nprivate:\n void CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr,\n const ArraySubscriptExpr *ASE=nullptr,\n bool AllowOnePastEnd=true, bool IndexNegated=false);\n void CheckArrayAccess(const Expr *E);\n // Used to grab the relevant information from a FormatAttr and a\n // FunctionDeclaration.\n struct FormatStringInfo {\n unsigned FormatIdx;\n unsigned FirstDataArg;\n bool HasVAListArg;\n };\n\n static bool getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember,\n FormatStringInfo *FSI);\n bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,\n const FunctionProtoType *Proto);\n bool CheckObjCMethodCall(ObjCMethodDecl *Method, SourceLocation loc,\n ArrayRef<const Expr *> Args);\n bool CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall,\n const FunctionProtoType *Proto);\n bool CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto);\n void CheckConstructorCall(FunctionDecl *FDecl, QualType ThisType,\n ArrayRef<const Expr *> Args,\n const FunctionProtoType *Proto, SourceLocation Loc);\n\n void CheckArgAlignment(SourceLocation Loc, NamedDecl *FDecl,\n StringRef ParamName, QualType ArgTy, QualType ParamTy);\n\n void checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto,\n const Expr *ThisArg, ArrayRef<const Expr *> Args,\n bool IsMemberFunction, SourceLocation Loc, SourceRange Range,\n VariadicCallType CallType);\n\n bool CheckObjCString(Expr *Arg);\n ExprResult CheckOSLogFormatStringArg(Expr *Arg);\n\n ExprResult CheckBuiltinFunctionCall(FunctionDecl *FDecl,\n unsigned BuiltinID, CallExpr *TheCall);\n\n bool CheckTSBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,\n CallExpr *TheCall);\n\n void checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD, CallExpr *TheCall);\n\n bool CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall,\n unsigned MaxWidth);\n bool CheckNeonBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,\n CallExpr *TheCall);\n bool CheckMVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);\n bool CheckSVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);\n bool CheckCDEBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,\n CallExpr *TheCall);\n bool CheckARMCoprocessorImmediate(const TargetInfo &TI, const Expr *CoprocArg,\n bool WantCDE);\n bool CheckARMBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,\n CallExpr *TheCall);\n\n bool CheckAArch64BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,\n CallExpr *TheCall);\n bool CheckBPFBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);\n bool CheckHexagonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);\n bool CheckHexagonBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall);\n bool CheckMipsBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,\n CallExpr *TheCall);\n bool CheckMipsBuiltinCpu(const TargetInfo &TI, unsigned BuiltinID,\n CallExpr *TheCall);\n bool CheckMipsBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall);\n bool CheckSystemZBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);\n bool CheckX86BuiltinRoundingOrSAE(unsigned BuiltinID, CallExpr *TheCall);\n bool CheckX86BuiltinGatherScatterScale(unsigned BuiltinID, CallExpr *TheCall);\n bool CheckX86BuiltinTileArguments(unsigned BuiltinID, CallExpr *TheCall);\n bool CheckX86BuiltinTileArgumentsRange(CallExpr *TheCall,\n ArrayRef<int> ArgNums);\n bool CheckX86BuiltinTileDuplicate(CallExpr *TheCall, ArrayRef<int> ArgNums);\n bool CheckX86BuiltinTileRangeAndDuplicate(CallExpr *TheCall,\n ArrayRef<int> ArgNums);\n bool CheckX86BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,\n CallExpr *TheCall);\n bool CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,\n CallExpr *TheCall);\n bool CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);\n bool CheckRISCVBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,\n CallExpr *TheCall);\n\n bool SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall);\n bool SemaBuiltinVAStartARMMicrosoft(CallExpr *Call);\n bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);\n bool SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs);\n bool SemaBuiltinComplex(CallExpr *TheCall);\n bool SemaBuiltinVSX(CallExpr *TheCall);\n bool SemaBuiltinOSLogFormat(CallExpr *TheCall);\n\npublic:\n // Used by C++ template instantiation.\n ExprResult SemaBuiltinShuffleVector(CallExpr *TheCall);\n ExprResult SemaConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo,\n SourceLocation BuiltinLoc,\n SourceLocation RParenLoc);\n\nprivate:\n bool SemaBuiltinPrefetch(CallExpr *TheCall);\n bool SemaBuiltinAllocaWithAlign(CallExpr *TheCall);\n bool SemaBuiltinAssume(CallExpr *TheCall);\n bool SemaBuiltinAssumeAligned(CallExpr *TheCall);\n bool SemaBuiltinLongjmp(CallExpr *TheCall);\n bool SemaBuiltinSetjmp(CallExpr *TheCall);\n ExprResult SemaBuiltinAtomicOverloaded(ExprResult TheCallResult);\n ExprResult SemaBuiltinNontemporalOverloaded(ExprResult TheCallResult);\n ExprResult SemaAtomicOpsOverloaded(ExprResult TheCallResult,\n AtomicExpr::AtomicOp Op);\n ExprResult SemaBuiltinOperatorNewDeleteOverloaded(ExprResult TheCallResult,\n bool IsDelete);\n bool SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum,\n llvm::APSInt &Result);\n bool SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum, int Low,\n int High, bool RangeIsError = true);\n bool SemaBuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum,\n unsigned Multiple);\n bool SemaBuiltinConstantArgPower2(CallExpr *TheCall, int ArgNum);\n bool SemaBuiltinConstantArgShiftedByte(CallExpr *TheCall, int ArgNum,\n unsigned ArgBits);\n bool SemaBuiltinConstantArgShiftedByteOrXXFF(CallExpr *TheCall, int ArgNum,\n unsigned ArgBits);\n bool SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall,\n int ArgNum, unsigned ExpectedFieldNum,\n bool AllowName);\n bool SemaBuiltinARMMemoryTaggingCall(unsigned BuiltinID, CallExpr *TheCall);\n bool SemaBuiltinPPCMMACall(CallExpr *TheCall, const char *TypeDesc);\n\n bool CheckPPCMMAType(QualType Type, SourceLocation TypeLoc);\n\n // Matrix builtin handling.\n ExprResult SemaBuiltinMatrixTranspose(CallExpr *TheCall,\n ExprResult CallResult);\n ExprResult SemaBuiltinMatrixColumnMajorLoad(CallExpr *TheCall,\n ExprResult CallResult);\n ExprResult SemaBuiltinMatrixColumnMajorStore(CallExpr *TheCall,\n ExprResult CallResult);\n\npublic:\n enum FormatStringType {\n FST_Scanf,\n FST_Printf,\n FST_NSString,\n FST_Strftime,\n FST_Strfmon,\n FST_Kprintf,\n FST_FreeBSDKPrintf,\n FST_OSTrace,\n FST_OSLog,\n FST_Unknown\n };\n static FormatStringType GetFormatStringType(const FormatAttr *Format);\n\n bool FormatStringHasSArg(const StringLiteral *FExpr);\n\n static bool GetFormatNSStringIdx(const FormatAttr *Format, unsigned &Idx);\n\nprivate:\n bool CheckFormatArguments(const FormatAttr *Format,\n ArrayRef<const Expr *> Args,\n bool IsCXXMember,\n VariadicCallType CallType,\n SourceLocation Loc, SourceRange Range,\n llvm::SmallBitVector &CheckedVarArgs);\n bool CheckFormatArguments(ArrayRef<const Expr *> Args,\n bool HasVAListArg, unsigned format_idx,\n unsigned firstDataArg, FormatStringType Type,\n VariadicCallType CallType,\n SourceLocation Loc, SourceRange range,\n llvm::SmallBitVector &CheckedVarArgs);\n\n void CheckAbsoluteValueFunction(const CallExpr *Call,\n const FunctionDecl *FDecl);\n\n void CheckMaxUnsignedZero(const CallExpr *Call, const FunctionDecl *FDecl);\n\n void CheckMemaccessArguments(const CallExpr *Call,\n unsigned BId,\n IdentifierInfo *FnName);\n\n void CheckStrlcpycatArguments(const CallExpr *Call,\n IdentifierInfo *FnName);\n\n void CheckStrncatArguments(const CallExpr *Call,\n IdentifierInfo *FnName);\n\n void CheckFreeArguments(const CallExpr *E);\n\n void CheckReturnValExpr(Expr *RetValExp, QualType lhsType,\n SourceLocation ReturnLoc,\n bool isObjCMethod = false,\n const AttrVec *Attrs = nullptr,\n const FunctionDecl *FD = nullptr);\n\npublic:\n void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS);\n\nprivate:\n void CheckImplicitConversions(Expr *E, SourceLocation CC = SourceLocation());\n void CheckBoolLikeConversion(Expr *E, SourceLocation CC);\n void CheckForIntOverflow(Expr *E);\n void CheckUnsequencedOperations(const Expr *E);\n\n /// Perform semantic checks on a completed expression. This will either\n /// be a full-expression or a default argument expression.\n void CheckCompletedExpr(Expr *E, SourceLocation CheckLoc = SourceLocation(),\n bool IsConstexpr = false);\n\n void CheckBitFieldInitialization(SourceLocation InitLoc, FieldDecl *Field,\n Expr *Init);\n\n /// Check if there is a field shadowing.\n void CheckShadowInheritedFields(const SourceLocation &Loc,\n DeclarationName FieldName,\n const CXXRecordDecl *RD,\n bool DeclIsField = true);\n\n /// Check if the given expression contains 'break' or 'continue'\n /// statement that produces control flow different from GCC.\n void CheckBreakContinueBinding(Expr *E);\n\n /// Check whether receiver is mutable ObjC container which\n /// attempts to add itself into the container\n void CheckObjCCircularContainer(ObjCMessageExpr *Message);\n\n void CheckTCBEnforcement(const CallExpr *TheCall, const FunctionDecl *Callee);\n\n void AnalyzeDeleteExprMismatch(const CXXDeleteExpr *DE);\n void AnalyzeDeleteExprMismatch(FieldDecl *Field, SourceLocation DeleteLoc,\n bool DeleteWasArrayForm);\npublic:\n /// Register a magic integral constant to be used as a type tag.\n void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind,\n uint64_t MagicValue, QualType Type,\n bool LayoutCompatible, bool MustBeNull);\n\n struct TypeTagData {\n TypeTagData() {}\n\n TypeTagData(QualType Type, bool LayoutCompatible, bool MustBeNull) :\n Type(Type), LayoutCompatible(LayoutCompatible),\n MustBeNull(MustBeNull)\n {}\n\n QualType Type;\n\n /// If true, \\c Type should be compared with other expression's types for\n /// layout-compatibility.\n unsigned LayoutCompatible : 1;\n unsigned MustBeNull : 1;\n };\n\n /// A pair of ArgumentKind identifier and magic value. This uniquely\n /// identifies the magic value.\n typedef std::pair<const IdentifierInfo *, uint64_t> TypeTagMagicValue;\n\nprivate:\n /// A map from magic value to type information.\n std::unique_ptr<llvm::DenseMap<TypeTagMagicValue, TypeTagData>>\n TypeTagForDatatypeMagicValues;\n\n /// Peform checks on a call of a function with argument_with_type_tag\n /// or pointer_with_type_tag attributes.\n void CheckArgumentWithTypeTag(const ArgumentWithTypeTagAttr *Attr,\n const ArrayRef<const Expr *> ExprArgs,\n SourceLocation CallSiteLoc);\n\n /// Check if we are taking the address of a packed field\n /// as this may be a problem if the pointer value is dereferenced.\n void CheckAddressOfPackedMember(Expr *rhs);\n\n /// The parser's current scope.\n ///\n /// The parser maintains this state here.\n Scope *CurScope;\n\n mutable IdentifierInfo *Ident_super;\n mutable IdentifierInfo *Ident___float128;\n\n /// Nullability type specifiers.\n IdentifierInfo *Ident__Nonnull = nullptr;\n IdentifierInfo *Ident__Nullable = nullptr;\n IdentifierInfo *Ident__Nullable_result = nullptr;\n IdentifierInfo *Ident__Null_unspecified = nullptr;\n\n IdentifierInfo *Ident_NSError = nullptr;\n\n /// The handler for the FileChanged preprocessor events.\n ///\n /// Used for diagnostics that implement custom semantic analysis for #include\n /// directives, like -Wpragma-pack.\n sema::SemaPPCallbacks *SemaPPCallbackHandler;\n\nprotected:\n friend class Parser;\n friend class InitializationSequence;\n friend class ASTReader;\n friend class ASTDeclReader;\n friend class ASTWriter;\n\npublic:\n /// Retrieve the keyword associated\n IdentifierInfo *getNullabilityKeyword(NullabilityKind nullability);\n\n /// The struct behind the CFErrorRef pointer.\n RecordDecl *CFError = nullptr;\n bool isCFError(RecordDecl *D);\n\n /// Retrieve the identifier \"NSError\".\n IdentifierInfo *getNSErrorIdent();\n\n /// Retrieve the parser's current scope.\n ///\n /// This routine must only be used when it is certain that semantic analysis\n /// and the parser are in precisely the same context, which is not the case\n /// when, e.g., we are performing any kind of template instantiation.\n /// Therefore, the only safe places to use this scope are in the parser\n /// itself and in routines directly invoked from the parser and *never* from\n /// template substitution or instantiation.\n Scope *getCurScope() const { return CurScope; }\n\n void incrementMSManglingNumber() const {\n return CurScope->incrementMSManglingNumber();\n }\n\n IdentifierInfo *getSuperIdentifier() const;\n IdentifierInfo *getFloat128Identifier() const;\n\n Decl *getObjCDeclContext() const;\n\n DeclContext *getCurLexicalContext() const {\n return OriginalLexicalContext ? OriginalLexicalContext : CurContext;\n }\n\n const DeclContext *getCurObjCLexicalContext() const {\n const DeclContext *DC = getCurLexicalContext();\n // A category implicitly has the attribute of the interface.\n if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(DC))\n DC = CatD->getClassInterface();\n return DC;\n }\n\n /// Determine the number of levels of enclosing template parameters. This is\n /// only usable while parsing. Note that this does not include dependent\n /// contexts in which no template parameters have yet been declared, such as\n /// in a terse function template or generic lambda before the first 'auto' is\n /// encountered.\n unsigned getTemplateDepth(Scope *S) const;\n\n /// To be used for checking whether the arguments being passed to\n /// function exceeds the number of parameters expected for it.\n static bool TooManyArguments(size_t NumParams, size_t NumArgs,\n bool PartialOverloading = false) {\n // We check whether we're just after a comma in code-completion.\n if (NumArgs > 0 && PartialOverloading)\n return NumArgs + 1 > NumParams; // If so, we view as an extra argument.\n return NumArgs > NumParams;\n }\n\n // Emitting members of dllexported classes is delayed until the class\n // (including field initializers) is fully parsed.\n SmallVector<CXXRecordDecl*, 4> DelayedDllExportClasses;\n SmallVector<CXXMethodDecl*, 4> DelayedDllExportMemberFunctions;\n\nprivate:\n int ParsingClassDepth = 0;\n\n class SavePendingParsedClassStateRAII {\n public:\n SavePendingParsedClassStateRAII(Sema &S) : S(S) { swapSavedState(); }\n\n ~SavePendingParsedClassStateRAII() {\n assert(S.DelayedOverridingExceptionSpecChecks.empty() &&\n \"there shouldn't be any pending delayed exception spec checks\");\n assert(S.DelayedEquivalentExceptionSpecChecks.empty() &&\n \"there shouldn't be any pending delayed exception spec checks\");\n swapSavedState();\n }\n\n private:\n Sema &S;\n decltype(DelayedOverridingExceptionSpecChecks)\n SavedOverridingExceptionSpecChecks;\n decltype(DelayedEquivalentExceptionSpecChecks)\n SavedEquivalentExceptionSpecChecks;\n\n void swapSavedState() {\n SavedOverridingExceptionSpecChecks.swap(\n S.DelayedOverridingExceptionSpecChecks);\n SavedEquivalentExceptionSpecChecks.swap(\n S.DelayedEquivalentExceptionSpecChecks);\n }\n };\n\n /// Helper class that collects misaligned member designations and\n /// their location info for delayed diagnostics.\n struct MisalignedMember {\n Expr *E;\n RecordDecl *RD;\n ValueDecl *MD;\n CharUnits Alignment;\n\n MisalignedMember() : E(), RD(), MD(), Alignment() {}\n MisalignedMember(Expr *E, RecordDecl *RD, ValueDecl *MD,\n CharUnits Alignment)\n : E(E), RD(RD), MD(MD), Alignment(Alignment) {}\n explicit MisalignedMember(Expr *E)\n : MisalignedMember(E, nullptr, nullptr, CharUnits()) {}\n\n bool operator==(const MisalignedMember &m) { return this->E == m.E; }\n };\n /// Small set of gathered accesses to potentially misaligned members\n /// due to the packed attribute.\n SmallVector<MisalignedMember, 4> MisalignedMembers;\n\n /// Adds an expression to the set of gathered misaligned members.\n void AddPotentialMisalignedMembers(Expr *E, RecordDecl *RD, ValueDecl *MD,\n CharUnits Alignment);\n\npublic:\n /// Diagnoses the current set of gathered accesses. This typically\n /// happens at full expression level. The set is cleared after emitting the\n /// diagnostics.\n void DiagnoseMisalignedMembers();\n\n /// This function checks if the expression is in the sef of potentially\n /// misaligned members and it is converted to some pointer type T with lower\n /// or equal alignment requirements. If so it removes it. This is used when\n /// we do not want to diagnose such misaligned access (e.g. in conversions to\n /// void*).\n void DiscardMisalignedMemberAddress(const Type *T, Expr *E);\n\n /// This function calls Action when it determines that E designates a\n /// misaligned member due to the packed attribute. This is used to emit\n /// local diagnostics like in reference binding.\n void RefersToMemberWithReducedAlignment(\n Expr *E,\n llvm::function_ref<void(Expr *, RecordDecl *, FieldDecl *, CharUnits)>\n Action);\n\n /// Describes the reason a calling convention specification was ignored, used\n /// for diagnostics.\n enum class CallingConventionIgnoredReason {\n ForThisTarget = 0,\n VariadicFunction,\n ConstructorDestructor,\n BuiltinFunction\n };\n /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current\n /// context is \"used as device code\".\n ///\n /// - If CurLexicalContext is a kernel function or it is known that the\n /// function will be emitted for the device, emits the diagnostics\n /// immediately.\n /// - If CurLexicalContext is a function and we are compiling\n /// for the device, but we don't know that this function will be codegen'ed\n /// for devive yet, creates a diagnostic which is emitted if and when we\n /// realize that the function will be codegen'ed.\n ///\n /// Example usage:\n ///\n /// Diagnose __float128 type usage only from SYCL device code if the current\n /// target doesn't support it\n /// if (!S.Context.getTargetInfo().hasFloat128Type() &&\n /// S.getLangOpts().SYCLIsDevice)\n /// SYCLDiagIfDeviceCode(Loc, diag::err_type_unsupported) << \"__float128\";\n SemaDiagnosticBuilder SYCLDiagIfDeviceCode(SourceLocation Loc,\n unsigned DiagID);\n\n /// Check whether we're allowed to call Callee from the current context.\n ///\n /// - If the call is never allowed in a semantically-correct program\n /// emits an error and returns false.\n ///\n /// - If the call is allowed in semantically-correct programs, but only if\n /// it's never codegen'ed, creates a deferred diagnostic to be emitted if\n /// and when the caller is codegen'ed, and returns true.\n ///\n /// - Otherwise, returns true without emitting any diagnostics.\n ///\n /// Adds Callee to DeviceCallGraph if we don't know if its caller will be\n /// codegen'ed yet.\n bool checkSYCLDeviceFunction(SourceLocation Loc, FunctionDecl *Callee);\n};\n\n/// RAII object that enters a new expression evaluation context.\nclass EnterExpressionEvaluationContext {\n Sema &Actions;\n bool Entered = true;\n\npublic:\n EnterExpressionEvaluationContext(\n Sema &Actions, Sema::ExpressionEvaluationContext NewContext,\n Decl *LambdaContextDecl = nullptr,\n Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext =\n Sema::ExpressionEvaluationContextRecord::EK_Other,\n bool ShouldEnter = true)\n : Actions(Actions), Entered(ShouldEnter) {\n if (Entered)\n Actions.PushExpressionEvaluationContext(NewContext, LambdaContextDecl,\n ExprContext);\n }\n EnterExpressionEvaluationContext(\n Sema &Actions, Sema::ExpressionEvaluationContext NewContext,\n Sema::ReuseLambdaContextDecl_t,\n Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext =\n Sema::ExpressionEvaluationContextRecord::EK_Other)\n : Actions(Actions) {\n Actions.PushExpressionEvaluationContext(\n NewContext, Sema::ReuseLambdaContextDecl, ExprContext);\n }\n\n enum InitListTag { InitList };\n EnterExpressionEvaluationContext(Sema &Actions, InitListTag,\n bool ShouldEnter = true)\n : Actions(Actions), Entered(false) {\n // In C++11 onwards, narrowing checks are performed on the contents of\n // braced-init-lists, even when they occur within unevaluated operands.\n // Therefore we still need to instantiate constexpr functions used in such\n // a context.\n if (ShouldEnter && Actions.isUnevaluatedContext() &&\n Actions.getLangOpts().CPlusPlus11) {\n Actions.PushExpressionEvaluationContext(\n Sema::ExpressionEvaluationContext::UnevaluatedList);\n Entered = true;\n }\n }\n\n ~EnterExpressionEvaluationContext() {\n if (Entered)\n Actions.PopExpressionEvaluationContext();\n }\n};\n\nDeductionFailureInfo\nMakeDeductionFailureInfo(ASTContext &Context, Sema::TemplateDeductionResult TDK,\n sema::TemplateDeductionInfo &Info);\n\n/// Contains a late templated function.\n/// Will be parsed at the end of the translation unit, used by Sema & Parser.\nstruct LateParsedTemplate {\n CachedTokens Toks;\n /// The template function declaration to be late parsed.\n Decl *D;\n};\n\ntemplate <>\nvoid Sema::PragmaStack<Sema::AlignPackInfo>::Act(SourceLocation PragmaLocation,\n PragmaMsStackAction Action,\n llvm::StringRef StackSlotLabel,\n AlignPackInfo Value);\n\n} // end namespace clang\n\nnamespace llvm {\n// Hash a FunctionDeclAndLoc by looking at both its FunctionDecl and its\n// SourceLocation.\ntemplate <> struct DenseMapInfo<clang::Sema::FunctionDeclAndLoc> {\n using FunctionDeclAndLoc = clang::Sema::FunctionDeclAndLoc;\n using FDBaseInfo = DenseMapInfo<clang::CanonicalDeclPtr<clang::FunctionDecl>>;\n\n static FunctionDeclAndLoc getEmptyKey() {\n return {FDBaseInfo::getEmptyKey(), clang::SourceLocation()};\n }\n\n static FunctionDeclAndLoc getTombstoneKey() {\n return {FDBaseInfo::getTombstoneKey(), clang::SourceLocation()};\n }\n\n static unsigned getHashValue(const FunctionDeclAndLoc &FDL) {\n return hash_combine(FDBaseInfo::getHashValue(FDL.FD),\n FDL.Loc.getHashValue());\n }\n\n static bool isEqual(const FunctionDeclAndLoc &LHS,\n const FunctionDeclAndLoc &RHS) {\n return LHS.FD == RHS.FD && LHS.Loc == RHS.Loc;\n }\n};\n} // namespace llvm\n\n#endif\n"}}},{"rowIdx":86,"cells":{"source":{"kind":"string","value":"GB_unop__ainv_uint64_uint64.c"},"original_c":{"kind":"string","value":"//------------------------------------------------------------------------------\n// GB_unop: hard-coded functions for each built-in unary operator\n//------------------------------------------------------------------------------\n\n// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n\n//------------------------------------------------------------------------------\n\n// If this file is in the Generated2/ folder, do not edit it\n// (it is auto-generated from Generator/*).\n\n#include \"GB.h\"\n#ifndef GBCOMPACT\n#include \"GB_control.h\"\n#include \"GB_atomics.h\"\n#include \"GB_unop__include.h\"\n\n// C=unop(A) is defined by the following types and operators:\n\n// op(A) function: GB (_unop_apply__ainv_uint64_uint64)\n// op(A') function: GB (_unop_tran__ainv_uint64_uint64)\n\n// C type: uint64_t\n// A type: uint64_t\n// cast: uint64_t cij = aij\n// unaryop: cij = -aij\n\n#define GB_ATYPE \\\n uint64_t\n\n#define GB_CTYPE \\\n uint64_t\n\n// aij = Ax [pA]\n#define GB_GETA(aij,Ax,pA) \\\n uint64_t aij = Ax [pA]\n\n#define GB_CX(p) Cx [p]\n\n// unary operator\n#define GB_OP(z, x) \\\n z = -x ;\n\n// casting\n#define GB_CAST(z, aij) \\\n uint64_t z = aij ;\n\n// cij = op (aij)\n#define GB_CAST_OP(pC,pA) \\\n{ \\\n /* aij = Ax [pA] */ \\\n uint64_t aij = Ax [pA] ; \\\n /* Cx [pC] = op (cast (aij)) */ \\\n uint64_t z = aij ; \\\n Cx [pC] = -z ; \\\n}\n\n// disable this operator and use the generic case if these conditions hold\n#define GB_DISABLE \\\n (GxB_NO_AINV || GxB_NO_UINT64)\n\n//------------------------------------------------------------------------------\n// Cx = op (cast (Ax)): apply a unary operator\n//------------------------------------------------------------------------------\n\n\nGrB_Info GB (_unop_apply__ainv_uint64_uint64)\n(\n uint64_t *Cx, // Cx and Ax may be aliased\n const uint64_t *Ax,\n const int8_t *restrict Ab, // A->b if A is bitmap\n int64_t anz,\n int nthreads\n)\n{\n #if GB_DISABLE\n return (GrB_NO_VALUE) ;\n #else\n int64_t p ;\n if (Ab == NULL)\n { \n #pragma omp parallel for num_threads(nthreads) schedule(static)\n for (p = 0 ; p < anz ; p++)\n {\n uint64_t aij = Ax [p] ;\n uint64_t z = aij ;\n Cx [p] = -z ;\n }\n }\n else\n { \n // bitmap case, no transpose; A->b already memcpy'd into C->b\n #pragma omp parallel for num_threads(nthreads) schedule(static)\n for (p = 0 ; p < anz ; p++)\n {\n if (!Ab [p]) continue ;\n uint64_t aij = Ax [p] ;\n uint64_t z = aij ;\n Cx [p] = -z ;\n }\n }\n return (GrB_SUCCESS) ;\n #endif\n}\n\n\n//------------------------------------------------------------------------------\n// C = op (cast (A')): transpose, typecast, and apply a unary operator\n//------------------------------------------------------------------------------\n\nGrB_Info GB (_unop_tran__ainv_uint64_uint64)\n(\n GrB_Matrix C,\n const GrB_Matrix A,\n int64_t *restrict *Workspaces,\n const int64_t *restrict A_slice,\n int nworkspaces,\n int nthreads\n)\n{ \n #if GB_DISABLE\n return (GrB_NO_VALUE) ;\n #else\n #include \"GB_unop_transpose.c\"\n return (GrB_SUCCESS) ;\n #endif\n}\n\n#endif\n\n"},"no_omp_formatted":{"kind":"string","value":"//------------------------------------------------------------------------------\n// GB_unop: hard-coded functions for each built-in unary operator\n//------------------------------------------------------------------------------\n\n// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n\n//------------------------------------------------------------------------------\n\n// If this file is in the Generated2/ folder, do not edit it\n// (it is auto-generated from Generator/*).\n\n#include \"GB.h\"\n#ifndef GBCOMPACT\n#include \"GB_control.h\"\n#include \"GB_atomics.h\"\n#include \"GB_unop__include.h\"\n\n// C=unop(A) is defined by the following types and operators:\n\n// op(A) function: GB (_unop_apply__ainv_uint64_uint64)\n// op(A') function: GB (_unop_tran__ainv_uint64_uint64)\n\n// C type: uint64_t\n// A type: uint64_t\n// cast: uint64_t cij = aij\n// unaryop: cij = -aij\n\n#define GB_ATYPE \\\n uint64_t\n\n#define GB_CTYPE \\\n uint64_t\n\n// aij = Ax [pA]\n#define GB_GETA(aij,Ax,pA) \\\n uint64_t aij = Ax [pA]\n\n#define GB_CX(p) Cx [p]\n\n// unary operator\n#define GB_OP(z, x) \\\n z = -x ;\n\n// casting\n#define GB_CAST(z, aij) \\\n uint64_t z = aij ;\n\n// cij = op (aij)\n#define GB_CAST_OP(pC,pA) \\\n{ \\\n /* aij = Ax [pA] */ \\\n uint64_t aij = Ax [pA] ; \\\n /* Cx [pC] = op (cast (aij)) */ \\\n uint64_t z = aij ; \\\n Cx [pC] = -z ; \\\n}\n\n// disable this operator and use the generic case if these conditions hold\n#define GB_DISABLE \\\n (GxB_NO_AINV || GxB_NO_UINT64)\n\n//------------------------------------------------------------------------------\n// Cx = op (cast (Ax)): apply a unary operator\n//------------------------------------------------------------------------------\n\n\nGrB_Info GB (_unop_apply__ainv_uint64_uint64)\n(\n uint64_t *Cx, // Cx and Ax may be aliased\n const uint64_t *Ax,\n const int8_t *restrict Ab, // A->b if A is bitmap\n int64_t anz,\n int nthreads\n)\n{\n #if GB_DISABLE\n return (GrB_NO_VALUE) ;\n #else\n int64_t p ;\n if (Ab == NULL)\n {\n for (p = 0 ; p < anz ; p++)\n {\n uint64_t aij = Ax [p] ;\n uint64_t z = aij ;\n Cx [p] = -z ;\n }\n }\n else\n { \n // bitmap case, no transpose; A->b already memcpy'd into C->b\n for (p = 0 ; p < anz ; p++)\n {\n if (!Ab [p]) continue ;\n uint64_t aij = Ax [p] ;\n uint64_t z = aij ;\n Cx [p] = -z ;\n }\n }\n return (GrB_SUCCESS) ;\n #endif\n}\n\n\n//------------------------------------------------------------------------------\n// C = op (cast (A')): transpose, typecast, and apply a unary operator\n//------------------------------------------------------------------------------\n\nGrB_Info GB (_unop_tran__ainv_uint64_uint64)\n(\n GrB_Matrix C,\n const GrB_Matrix A,\n int64_t *restrict *Workspaces,\n const int64_t *restrict A_slice,\n int nworkspaces,\n int nthreads\n)\n{ \n #if GB_DISABLE\n return (GrB_NO_VALUE) ;\n #else\n #include \"GB_unop_transpose.c\"\n return (GrB_SUCCESS) ;\n #endif\n}\n\n#endif\n\n"},"omp_formatted":{"kind":"string","value":"//------------------------------------------------------------------------------\n// GB_unop: hard-coded functions for each built-in unary operator\n//------------------------------------------------------------------------------\n\n// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n\n//------------------------------------------------------------------------------\n\n// If this file is in the Generated2/ folder, do not edit it\n// (it is auto-generated from Generator/*).\n\n#include \"GB.h\"\n#ifndef GBCOMPACT\n#include \"GB_control.h\"\n#include \"GB_atomics.h\"\n#include \"GB_unop__include.h\"\n\n// C=unop(A) is defined by the following types and operators:\n\n// op(A) function: GB (_unop_apply__ainv_uint64_uint64)\n// op(A') function: GB (_unop_tran__ainv_uint64_uint64)\n\n// C type: uint64_t\n// A type: uint64_t\n// cast: uint64_t cij = aij\n// unaryop: cij = -aij\n\n#define GB_ATYPE \\\n uint64_t\n\n#define GB_CTYPE \\\n uint64_t\n\n// aij = Ax [pA]\n#define GB_GETA(aij,Ax,pA) \\\n uint64_t aij = Ax [pA]\n\n#define GB_CX(p) Cx [p]\n\n// unary operator\n#define GB_OP(z, x) \\\n z = -x ;\n\n// casting\n#define GB_CAST(z, aij) \\\n uint64_t z = aij ;\n\n// cij = op (aij)\n#define GB_CAST_OP(pC,pA) \\\n{ \\\n /* aij = Ax [pA] */ \\\n uint64_t aij = Ax [pA] ; \\\n /* Cx [pC] = op (cast (aij)) */ \\\n uint64_t z = aij ; \\\n Cx [pC] = -z ; \\\n}\n\n// disable this operator and use the generic case if these conditions hold\n#define GB_DISABLE \\\n (GxB_NO_AINV || GxB_NO_UINT64)\n\n//------------------------------------------------------------------------------\n// Cx = op (cast (Ax)): apply a unary operator\n//------------------------------------------------------------------------------\n\n\nGrB_Info GB (_unop_apply__ainv_uint64_uint64)\n(\n uint64_t *Cx, // Cx and Ax may be aliased\n const uint64_t *Ax,\n const int8_t *restrict Ab, // A->b if A is bitmap\n int64_t anz,\n int nthreads\n)\n{\n #if GB_DISABLE\n return (GrB_NO_VALUE) ;\n #else\n int64_t p ;\n if (Ab == NULL)\n { \n #pragma omp parallel for num_threads(nthreads) schedule(static)\n for (p = 0 ; p < anz ; p++)\n {\n uint64_t aij = Ax [p] ;\n uint64_t z = aij ;\n Cx [p] = -z ;\n }\n }\n else\n { \n // bitmap case, no transpose; A->b already memcpy'd into C->b\n #pragma omp parallel for num_threads(nthreads) schedule(static)\n for (p = 0 ; p < anz ; p++)\n {\n if (!Ab [p]) continue ;\n uint64_t aij = Ax [p] ;\n uint64_t z = aij ;\n Cx [p] = -z ;\n }\n }\n return (GrB_SUCCESS) ;\n #endif\n}\n\n\n//------------------------------------------------------------------------------\n// C = op (cast (A')): transpose, typecast, and apply a unary operator\n//------------------------------------------------------------------------------\n\nGrB_Info GB (_unop_tran__ainv_uint64_uint64)\n(\n GrB_Matrix C,\n const GrB_Matrix A,\n int64_t *restrict *Workspaces,\n const int64_t *restrict A_slice,\n int nworkspaces,\n int nthreads\n)\n{ \n #if GB_DISABLE\n return (GrB_NO_VALUE) ;\n #else\n #include \"GB_unop_transpose.c\"\n return (GrB_SUCCESS) ;\n #endif\n}\n\n#endif\n\n"}}},{"rowIdx":87,"cells":{"source":{"kind":"string","value":"macro-2.c"},"original_c":{"kind":"string","value":"// { dg-do compile }\n\n#define p\tparallel\n#define s(x)\tshared(x##1, x##2)\n#define d(x)\tdefault(x)\n\nvoid bar(int, int, int, int);\nvoid foo(void)\n{\n int a1, a2, b1, b2;\n\n #pragma omp p s(a) s(b) d(none)\n bar(a1, a2, b1, b2);\n}\n"},"no_omp_formatted":{"kind":"string","value":"// { dg-do compile }\n\n#define p\tparallel\n#define s(x)\tshared(x##1, x##2)\n#define d(x)\tdefault(x)\n\nvoid bar(int, int, int, int);\nvoid foo(void)\n{\n int a1, a2, b1, b2;\n bar(a1, a2, b1, b2);\n}\n"},"omp_formatted":{"kind":"string","value":"// { dg-do compile }\n\n#define p\tparallel\n#define s(x)\tshared(x##1, x##2)\n#define d(x)\tdefault(x)\n\nvoid bar(int, int, int, int);\nvoid foo(void)\n{\n int a1, a2, b1, b2;\n\n #pragma omp p s(a) s(b) d(none)\n bar(a1, a2, b1, b2);\n}\n"}}},{"rowIdx":88,"cells":{"source":{"kind":"string","value":"ccl_utils.c"},"original_c":{"kind":"string","value":"#include <stdio.h>\n#include <stdlib.h>\n#include <math.h>\n\n#include <gsl/gsl_errno.h>\n\n#include \"ccl.h\"\n\n/* ------- ROUTINE: ccl_linear spacing ------\nINPUTS: [xmin,xmax] of the interval to be divided in N bins\nOUTPUT: bin edges in range [xmin,xmax]\n*/\n\ndouble * ccl_linear_spacing(double xmin, double xmax, int N)\n{\n double dx = (xmax-xmin)/(N -1.);\n\n double * x = malloc(sizeof(double)*N);\n if (x==NULL) {\n ccl_raise_warning(\n CCL_ERROR_MEMORY,\n \"ERROR: Could not allocate memory for linear-spaced array (N=%d)\\n\", N);\n return x;\n }\n\n for (int i=0; i<N; i++) {\n x[i] = xmin + dx*i;\n }\n x[0]=xmin; //Make sure roundoff errors don't spoil edges\n x[N-1]=xmax; //Make sure roundoff errors don't spoil edges\n\n return x;\n}\n\n/* ------- ROUTINE: ccl_linlog spacing ------\n * INPUTS: [xminlog,xmax] of the interval to be divided in bins\n * xmin when linear spacing starts\n * Nlog number of logarithmically spaced bins\n * Nlin number of linearly spaced bins\n * OUTPUT: bin edges in range [xminlog,xmax]\n * */\n\ndouble * ccl_linlog_spacing(double xminlog, double xmin, double xmax, int Nlog, int Nlin)\n{\n if (Nlog<2) {\n ccl_raise_warning(\n CCL_ERROR_LINLOGSPACE,\n \"ERROR: Cannot make log-spaced array with %d points - need at least 2\\n\", Nlog);\n return NULL;\n }\n\n if (!(xminlog>0 && xmin>0)) {\n ccl_raise_warning(\n CCL_ERROR_LINLOGSPACE,\n \"ERROR: Cannot make log-spaced array xminlog or xmin non-positive (had %le, %le)\\n\", xminlog, xmin);\n return NULL;\n }\n\n if (xminlog>xmin){\n ccl_raise_warning(CCL_ERROR_LINLOGSPACE, \"ERROR: xminlog must be smaller as xmin\");\n return NULL;\n }\n\n if (xmin>xmax){\n ccl_raise_warning(CCL_ERROR_LINLOGSPACE, \"ERROR: xmin must be smaller as xmax\");\n return NULL;\n }\n\n double * x = malloc(sizeof(double)*(Nlin+Nlog-1));\n if (x==NULL) {\n ccl_raise_warning(\n CCL_ERROR_MEMORY,\n \"ERROR: Could not allocate memory for array of size (Nlin+Nlog-1)=%d)\\n\", (Nlin+Nlog-1));\n return x;\n }\n\n double dx = (xmax-xmin)/(Nlin -1.);\n double log_xchange = log(xmin);\n double log_xmin = log(xminlog);\n double dlog_x = (log_xchange - log_xmin) / (Nlog-1.);\n\n for (int i=0; i<Nlin+Nlog-1; i++) {\n if (i<Nlog)\n x[i] = exp(log_xmin + dlog_x*i);\n if (i>=Nlog)\n x[i] = xmin + dx*(i-Nlog+1);\n }\n\n x[0]=xminlog; //Make sure roundoff errors don't spoil edges\n x[Nlog-1]=xmin; //Make sure roundoff errors don't spoil edges\n x[Nlin+Nlog-2]=xmax; //Make sure roundoff errors don't spoil edges\n\n return x;\n}\n\n/* ------- ROUTINE: ccl_log spacing ------\nINPUTS: [xmin,xmax] of the interval to be divided logarithmically in N bins\nTASK: divide an interval in N logarithmic bins\nOUTPUT: bin edges in range [xmin,xmax]\n*/\n\ndouble * ccl_log_spacing(double xmin, double xmax, int N)\n{\n if (N<2) {\n ccl_raise_warning(\n CCL_ERROR_LOGSPACE,\n \"ERROR: Cannot make log-spaced array with %d points - need at least 2\\n\", N);\n return NULL;\n }\n\n if (!(xmin>0 && xmax>0)) {\n ccl_raise_warning(\n CCL_ERROR_LOGSPACE,\n \"ERROR: Cannot make log-spaced array xmax or xmax non-positive (had %le, %le)\\n\", xmin, xmax);\n return NULL;\n }\n\n double log_xmax = log(xmax);\n double log_xmin = log(xmin);\n double dlog_x = (log_xmax - log_xmin) / (N-1.);\n\n double * x = malloc(sizeof(double)*N);\n if (x==NULL) {\n ccl_raise_warning(\n CCL_ERROR_MEMORY,\n \"ERROR: Could not allocate memory for log-spaced array (N=%d)\\n\", N);\n return x;\n }\n\n double xratio = exp(dlog_x);\n x[0] = xmin; //Make sure roundoff errors don't spoil edges\n for (int i=1; i<N-1; i++) {\n x[i] = x[i-1] * xratio;\n }\n x[N-1]=xmax; //Make sure roundoff errors don't spoil edges\n\n return x;\n}\n\n#define CCL_GAMMA1 2.6789385347077476336556 //Gamma(1/3)\n#define CCL_GAMMA2 1.3541179394264004169452 //Gamma(2/3)\n#define CCL_ROOTPI12 21.269446210866192327578 //12*sqrt(pi)\ndouble ccl_j_bessel(int l,double x)\n{\n double jl;\n double ax=fabs(x);\n double ax2=x*x;\n if(l<0) {\n fprintf(stderr,\"CosmoMas: l>0 for Bessel function\");\n exit(1);\n }\n\n if(l<7) {\n if(l==0) {\n if(ax<0.1) jl=1-ax2*(1-ax2/20.)/6.;\n else jl=sin(x)/x;\n }\n else if(l==1) {\n if(ax<0.2) jl=ax*(1-ax2*(1-ax2/28)/10)/3;\n else jl=(sin(x)/ax-cos(x))/ax;\n }\n else if(l==2) {\n if(ax<0.3) jl=ax2*(1-ax2*(1-ax2/36)/14)/15;\n else jl=(-3*cos(x)/ax-sin(x)*(1-3/ax2))/ax;\n }\n else if(l==3) {\n if(ax<0.4)\n\tjl=ax*ax2*(1-ax2*(1-ax2/44)/18)/105;\n else\n\tjl=(cos(x)*(1-15/ax2)-sin(x)*(6-15/ax2)/ax)/ax;\n }\n else if(l==4) {\n if(ax<0.6)\n\tjl=ax2*ax2*(1-ax2*(1-ax2/52)/22)/945;\n else\n\tjl=(sin(x)*(1-(45-105/ax2)/ax2)+cos(x)*(10-105/ax2)/ax)/ax;\n }\n else if(l==5) {\n if(ax<1.0)\n\tjl=ax2*ax2*ax*(1-ax2*(1-ax2/60)/26)/10395;\n else {\n\tjl=(sin(x)*(15-(420-945/ax2)/ax2)/ax-\n\t cos(x)*(1-(105-945/ax2)/ax2))/ax;\n }\n }\n else {\n if(ax<1.0)\n\tjl=ax2*ax2*ax2*(1-ax2*(1-ax2/68)/30)/135135;\n else {\n\tjl=(sin(x)*(-1+(210-(4725-10395/ax2)/ax2)/ax2)+\n\t cos(x)*(-21+(1260-10395/ax2)/ax2)/ax)/ax;\n }\n }\n }\n else {\n double nu=l+0.5;\n double nu2=nu*nu;\n\n if(ax<1.0E-40) jl=0;\n else if((ax2/l)<0.5) {\n jl=(exp(l*log(ax/nu)-M_LN2+nu*(1-M_LN2)-(1-(1-3.5/nu2)/(30*nu2))/(12*nu))/nu)*\n\t(1-ax2/(4*nu+4)*(1-ax2/(8*nu+16)*(1-ax2/(12*nu+36))));\n }\n else if((l*l/ax)<0.5) {\n double beta=ax-0.5*M_PI*(l+1);\n jl=(cos(beta)*(1-(nu2-0.25)*(nu2-2.25)/(8*ax2)*(1-(nu2-6.25)*(nu2-12.25)/(48*ax2)))-\n\t sin(beta)*(nu2-0.25)/(2*ax)*(1-(nu2-2.25)*(nu2-6.25)/(24*ax2)*\n\t\t\t\t (1-(nu2-12.25)*(nu2-20.25)/(80*ax2))))/ax;\n }\n else {\n double l3=pow(nu,0.325);\n if(ax<nu-1.31*l3) {\n\tdouble cosb=nu/ax;\n\tdouble sx=sqrt(nu2-ax2);\n\tdouble cotb=nu/sx;\n\tdouble secb=ax/nu;\n\tdouble beta=log(cosb+sx/ax);\n\tdouble cot3b=cotb*cotb*cotb;\n\tdouble cot6b=cot3b*cot3b;\n\tdouble sec2b=secb*secb;\n\tdouble expterm=((2+3*sec2b)*cot3b/24\n\t\t\t-((4+sec2b)*sec2b*cot6b/16\n\t\t\t +((16-(1512+(3654+375*sec2b)*sec2b)*sec2b)*cot3b/5760\n\t\t\t +(32+(288+(232+13*sec2b)*sec2b)*sec2b)*sec2b*cot6b/(128*nu))*\n\t\t\t cot6b/nu)/nu)/nu;\n\tjl=sqrt(cotb*cosb)/(2*nu)*exp(-nu*beta+nu/cotb-expterm);\n }\n else if(ax>nu+1.48*l3) {\n\tdouble cosb=nu/ax;\n\tdouble sx=sqrt(ax2-nu2);\n\tdouble cotb=nu/sx;\n\tdouble secb=ax/nu;\n\tdouble beta=acos(cosb);\n\tdouble cot3b=cotb*cotb*cotb;\n\tdouble cot6b=cot3b*cot3b;\n\tdouble sec2b=secb*secb;\n\tdouble trigarg=nu/cotb-nu*beta-0.25*M_PI-\n\t ((2+3*sec2b)*cot3b/24+(16-(1512+(3654+375*sec2b)*sec2b)*sec2b)*\n\t cot3b*cot6b/(5760*nu2))/nu;\n\tdouble expterm=((4+sec2b)*sec2b*cot6b/16-\n\t\t\t(32+(288+(232+13*sec2b)*sec2b)*sec2b)*\n\t\t\tsec2b*cot6b*cot6b/(128*nu2))/nu2;\n\tjl=sqrt(cotb*cosb)/nu*exp(-expterm)*cos(trigarg);\n }\n else {\n\tdouble beta=ax-nu;\n\tdouble beta2=beta*beta;\n\tdouble sx=6/ax;\n\tdouble sx2=sx*sx;\n\tdouble secb=pow(sx,0.3333333333333333333333);\n\tdouble sec2b=secb*secb;\n\n\tjl=(CCL_GAMMA1*secb+beta*CCL_GAMMA2*sec2b\n\t -(beta2/18-1.0/45.0)*beta*sx*secb*CCL_GAMMA1\n\t -((beta2-1)*beta2/36+1.0/420.0)*sx*sec2b*CCL_GAMMA2\n\t +(((beta2/1620-7.0/3240.0)*beta2+1.0/648.0)*beta2-1.0/8100.0)*sx2*secb*CCL_GAMMA1\n\t +(((beta2/4536-1.0/810.0)*beta2+19.0/11340.0)*beta2-13.0/28350.0)*beta*sx2*sec2b*CCL_GAMMA2\n\t -((((beta2/349920-1.0/29160.0)*beta2+71.0/583200.0)*beta2-121.0/874800.0)*\n\t beta2+7939.0/224532000.0)*beta*sx2*sx*secb*CCL_GAMMA1)*sqrt(sx)/CCL_ROOTPI12;\n }\n }\n }\n if((x<0)&&(l%2!=0)) jl=-jl;\n\n return jl;\n}\n\nvoid ccl_integ_spline(int ny, int nx,double *x,double **y,\n double a, double b, double *result,\n const gsl_interp_type *T, int *status)\n{\n if(b==a) {\n int iyy;\n for(iyy=0; iyy<ny; iyy++)\n result[iyy]=0;\n return;\n }\n if(b<a) {\n b=x[nx-1];\n a=x[0];\n }\n\n if((b>x[nx-1]) || (a<x[0])) {\n ccl_raise_warning(CCL_ERROR_SPLINE,\n\t\t \"ERROR: integration limits beyond interpolated range\\n\");\n *status = CCL_ERROR_SPLINE;\n return;\n }\n\n if(*status==0) {\n #pragma omp parallel default(none) \\\n shared(nx, ny, x, y, a, b, result, T, status)\n {\n int iy;\n int local_status=0;\n gsl_interp_accel *ia = NULL;\n gsl_spline *s = NULL;\n\n s = gsl_spline_alloc(T, nx);\n if(s == NULL)\n local_status = CCL_ERROR_MEMORY;\n\n if(!local_status) {\n ia = gsl_interp_accel_alloc();\n if(ia == NULL)\n local_status = CCL_ERROR_MEMORY;\n }\n\n if(!local_status) {\n #pragma omp for\n for(iy=0; iy<ny; iy++) {\n if(!local_status) {\n if(gsl_spline_init(s, x, y[iy], nx)) {\n local_status = CCL_ERROR_SPLINE;\n result[iy] = NAN;\n\t }\n\t }\n\n\t if(!local_status) {\n\t int sstat = gsl_spline_eval_integ_e(s, a, b, ia, &(result[iy]));\n\t if(sstat) {\n local_status = CCL_ERROR_SPLINE_EV;\n result[iy] = NAN;\n\t }\n\t }\n\t}\n }\n\n gsl_spline_free(s);\n gsl_interp_accel_free(ia);\n\n if (local_status) {\n #pragma omp atomic write\n *status = local_status;\n }\n } //end omp parallel\n }\n}\n"},"no_omp_formatted":{"kind":"string","value":"#include <stdio.h>\n#include <stdlib.h>\n#include <math.h>\n\n#include <gsl/gsl_errno.h>\n\n#include \"ccl.h\"\n\n/* ------- ROUTINE: ccl_linear spacing ------\nINPUTS: [xmin,xmax] of the interval to be divided in N bins\nOUTPUT: bin edges in range [xmin,xmax]\n*/\n\ndouble * ccl_linear_spacing(double xmin, double xmax, int N)\n{\n double dx = (xmax-xmin)/(N -1.);\n\n double * x = malloc(sizeof(double)*N);\n if (x==NULL) {\n ccl_raise_warning(\n CCL_ERROR_MEMORY,\n \"ERROR: Could not allocate memory for linear-spaced array (N=%d)\\n\", N);\n return x;\n }\n\n for (int i=0; i<N; i++) {\n x[i] = xmin + dx*i;\n }\n x[0]=xmin; //Make sure roundoff errors don't spoil edges\n x[N-1]=xmax; //Make sure roundoff errors don't spoil edges\n\n return x;\n}\n\n/* ------- ROUTINE: ccl_linlog spacing ------\n * INPUTS: [xminlog,xmax] of the interval to be divided in bins\n * xmin when linear spacing starts\n * Nlog number of logarithmically spaced bins\n * Nlin number of linearly spaced bins\n * OUTPUT: bin edges in range [xminlog,xmax]\n * */\n\ndouble * ccl_linlog_spacing(double xminlog, double xmin, double xmax, int Nlog, int Nlin)\n{\n if (Nlog<2) {\n ccl_raise_warning(\n CCL_ERROR_LINLOGSPACE,\n \"ERROR: Cannot make log-spaced array with %d points - need at least 2\\n\", Nlog);\n return NULL;\n }\n\n if (!(xminlog>0 && xmin>0)) {\n ccl_raise_warning(\n CCL_ERROR_LINLOGSPACE,\n \"ERROR: Cannot make log-spaced array xminlog or xmin non-positive (had %le, %le)\\n\", xminlog, xmin);\n return NULL;\n }\n\n if (xminlog>xmin){\n ccl_raise_warning(CCL_ERROR_LINLOGSPACE, \"ERROR: xminlog must be smaller as xmin\");\n return NULL;\n }\n\n if (xmin>xmax){\n ccl_raise_warning(CCL_ERROR_LINLOGSPACE, \"ERROR: xmin must be smaller as xmax\");\n return NULL;\n }\n\n double * x = malloc(sizeof(double)*(Nlin+Nlog-1));\n if (x==NULL) {\n ccl_raise_warning(\n CCL_ERROR_MEMORY,\n \"ERROR: Could not allocate memory for array of size (Nlin+Nlog-1)=%d)\\n\", (Nlin+Nlog-1));\n return x;\n }\n\n double dx = (xmax-xmin)/(Nlin -1.);\n double log_xchange = log(xmin);\n double log_xmin = log(xminlog);\n double dlog_x = (log_xchange - log_xmin) / (Nlog-1.);\n\n for (int i=0; i<Nlin+Nlog-1; i++) {\n if (i<Nlog)\n x[i] = exp(log_xmin + dlog_x*i);\n if (i>=Nlog)\n x[i] = xmin + dx*(i-Nlog+1);\n }\n\n x[0]=xminlog; //Make sure roundoff errors don't spoil edges\n x[Nlog-1]=xmin; //Make sure roundoff errors don't spoil edges\n x[Nlin+Nlog-2]=xmax; //Make sure roundoff errors don't spoil edges\n\n return x;\n}\n\n/* ------- ROUTINE: ccl_log spacing ------\nINPUTS: [xmin,xmax] of the interval to be divided logarithmically in N bins\nTASK: divide an interval in N logarithmic bins\nOUTPUT: bin edges in range [xmin,xmax]\n*/\n\ndouble * ccl_log_spacing(double xmin, double xmax, int N)\n{\n if (N<2) {\n ccl_raise_warning(\n CCL_ERROR_LOGSPACE,\n \"ERROR: Cannot make log-spaced array with %d points - need at least 2\\n\", N);\n return NULL;\n }\n\n if (!(xmin>0 && xmax>0)) {\n ccl_raise_warning(\n CCL_ERROR_LOGSPACE,\n \"ERROR: Cannot make log-spaced array xmax or xmax non-positive (had %le, %le)\\n\", xmin, xmax);\n return NULL;\n }\n\n double log_xmax = log(xmax);\n double log_xmin = log(xmin);\n double dlog_x = (log_xmax - log_xmin) / (N-1.);\n\n double * x = malloc(sizeof(double)*N);\n if (x==NULL) {\n ccl_raise_warning(\n CCL_ERROR_MEMORY,\n \"ERROR: Could not allocate memory for log-spaced array (N=%d)\\n\", N);\n return x;\n }\n\n double xratio = exp(dlog_x);\n x[0] = xmin; //Make sure roundoff errors don't spoil edges\n for (int i=1; i<N-1; i++) {\n x[i] = x[i-1] * xratio;\n }\n x[N-1]=xmax; //Make sure roundoff errors don't spoil edges\n\n return x;\n}\n\n#define CCL_GAMMA1 2.6789385347077476336556 //Gamma(1/3)\n#define CCL_GAMMA2 1.3541179394264004169452 //Gamma(2/3)\n#define CCL_ROOTPI12 21.269446210866192327578 //12*sqrt(pi)\ndouble ccl_j_bessel(int l,double x)\n{\n double jl;\n double ax=fabs(x);\n double ax2=x*x;\n if(l<0) {\n fprintf(stderr,\"CosmoMas: l>0 for Bessel function\");\n exit(1);\n }\n\n if(l<7) {\n if(l==0) {\n if(ax<0.1) jl=1-ax2*(1-ax2/20.)/6.;\n else jl=sin(x)/x;\n }\n else if(l==1) {\n if(ax<0.2) jl=ax*(1-ax2*(1-ax2/28)/10)/3;\n else jl=(sin(x)/ax-cos(x))/ax;\n }\n else if(l==2) {\n if(ax<0.3) jl=ax2*(1-ax2*(1-ax2/36)/14)/15;\n else jl=(-3*cos(x)/ax-sin(x)*(1-3/ax2))/ax;\n }\n else if(l==3) {\n if(ax<0.4)\n\tjl=ax*ax2*(1-ax2*(1-ax2/44)/18)/105;\n else\n\tjl=(cos(x)*(1-15/ax2)-sin(x)*(6-15/ax2)/ax)/ax;\n }\n else if(l==4) {\n if(ax<0.6)\n\tjl=ax2*ax2*(1-ax2*(1-ax2/52)/22)/945;\n else\n\tjl=(sin(x)*(1-(45-105/ax2)/ax2)+cos(x)*(10-105/ax2)/ax)/ax;\n }\n else if(l==5) {\n if(ax<1.0)\n\tjl=ax2*ax2*ax*(1-ax2*(1-ax2/60)/26)/10395;\n else {\n\tjl=(sin(x)*(15-(420-945/ax2)/ax2)/ax-\n\t cos(x)*(1-(105-945/ax2)/ax2))/ax;\n }\n }\n else {\n if(ax<1.0)\n\tjl=ax2*ax2*ax2*(1-ax2*(1-ax2/68)/30)/135135;\n else {\n\tjl=(sin(x)*(-1+(210-(4725-10395/ax2)/ax2)/ax2)+\n\t cos(x)*(-21+(1260-10395/ax2)/ax2)/ax)/ax;\n }\n }\n }\n else {\n double nu=l+0.5;\n double nu2=nu*nu;\n\n if(ax<1.0E-40) jl=0;\n else if((ax2/l)<0.5) {\n jl=(exp(l*log(ax/nu)-M_LN2+nu*(1-M_LN2)-(1-(1-3.5/nu2)/(30*nu2))/(12*nu))/nu)*\n\t(1-ax2/(4*nu+4)*(1-ax2/(8*nu+16)*(1-ax2/(12*nu+36))));\n }\n else if((l*l/ax)<0.5) {\n double beta=ax-0.5*M_PI*(l+1);\n jl=(cos(beta)*(1-(nu2-0.25)*(nu2-2.25)/(8*ax2)*(1-(nu2-6.25)*(nu2-12.25)/(48*ax2)))-\n\t sin(beta)*(nu2-0.25)/(2*ax)*(1-(nu2-2.25)*(nu2-6.25)/(24*ax2)*\n\t\t\t\t (1-(nu2-12.25)*(nu2-20.25)/(80*ax2))))/ax;\n }\n else {\n double l3=pow(nu,0.325);\n if(ax<nu-1.31*l3) {\n\tdouble cosb=nu/ax;\n\tdouble sx=sqrt(nu2-ax2);\n\tdouble cotb=nu/sx;\n\tdouble secb=ax/nu;\n\tdouble beta=log(cosb+sx/ax);\n\tdouble cot3b=cotb*cotb*cotb;\n\tdouble cot6b=cot3b*cot3b;\n\tdouble sec2b=secb*secb;\n\tdouble expterm=((2+3*sec2b)*cot3b/24\n\t\t\t-((4+sec2b)*sec2b*cot6b/16\n\t\t\t +((16-(1512+(3654+375*sec2b)*sec2b)*sec2b)*cot3b/5760\n\t\t\t +(32+(288+(232+13*sec2b)*sec2b)*sec2b)*sec2b*cot6b/(128*nu))*\n\t\t\t cot6b/nu)/nu)/nu;\n\tjl=sqrt(cotb*cosb)/(2*nu)*exp(-nu*beta+nu/cotb-expterm);\n }\n else if(ax>nu+1.48*l3) {\n\tdouble cosb=nu/ax;\n\tdouble sx=sqrt(ax2-nu2);\n\tdouble cotb=nu/sx;\n\tdouble secb=ax/nu;\n\tdouble beta=acos(cosb);\n\tdouble cot3b=cotb*cotb*cotb;\n\tdouble cot6b=cot3b*cot3b;\n\tdouble sec2b=secb*secb;\n\tdouble trigarg=nu/cotb-nu*beta-0.25*M_PI-\n\t ((2+3*sec2b)*cot3b/24+(16-(1512+(3654+375*sec2b)*sec2b)*sec2b)*\n\t cot3b*cot6b/(5760*nu2))/nu;\n\tdouble expterm=((4+sec2b)*sec2b*cot6b/16-\n\t\t\t(32+(288+(232+13*sec2b)*sec2b)*sec2b)*\n\t\t\tsec2b*cot6b*cot6b/(128*nu2))/nu2;\n\tjl=sqrt(cotb*cosb)/nu*exp(-expterm)*cos(trigarg);\n }\n else {\n\tdouble beta=ax-nu;\n\tdouble beta2=beta*beta;\n\tdouble sx=6/ax;\n\tdouble sx2=sx*sx;\n\tdouble secb=pow(sx,0.3333333333333333333333);\n\tdouble sec2b=secb*secb;\n\n\tjl=(CCL_GAMMA1*secb+beta*CCL_GAMMA2*sec2b\n\t -(beta2/18-1.0/45.0)*beta*sx*secb*CCL_GAMMA1\n\t -((beta2-1)*beta2/36+1.0/420.0)*sx*sec2b*CCL_GAMMA2\n\t +(((beta2/1620-7.0/3240.0)*beta2+1.0/648.0)*beta2-1.0/8100.0)*sx2*secb*CCL_GAMMA1\n\t +(((beta2/4536-1.0/810.0)*beta2+19.0/11340.0)*beta2-13.0/28350.0)*beta*sx2*sec2b*CCL_GAMMA2\n\t -((((beta2/349920-1.0/29160.0)*beta2+71.0/583200.0)*beta2-121.0/874800.0)*\n\t beta2+7939.0/224532000.0)*beta*sx2*sx*secb*CCL_GAMMA1)*sqrt(sx)/CCL_ROOTPI12;\n }\n }\n }\n if((x<0)&&(l%2!=0)) jl=-jl;\n\n return jl;\n}\n\nvoid ccl_integ_spline(int ny, int nx,double *x,double **y,\n double a, double b, double *result,\n const gsl_interp_type *T, int *status)\n{\n if(b==a) {\n int iyy;\n for(iyy=0; iyy<ny; iyy++)\n result[iyy]=0;\n return;\n }\n if(b<a) {\n b=x[nx-1];\n a=x[0];\n }\n\n if((b>x[nx-1]) || (a<x[0])) {\n ccl_raise_warning(CCL_ERROR_SPLINE,\n\t\t \"ERROR: integration limits beyond interpolated range\\n\");\n *status = CCL_ERROR_SPLINE;\n return;\n }\n\n if(*status==0) {\n shared(nx, ny, x, y, a, b, result, T, status)\n {\n int iy;\n int local_status=0;\n gsl_interp_accel *ia = NULL;\n gsl_spline *s = NULL;\n\n s = gsl_spline_alloc(T, nx);\n if(s == NULL)\n local_status = CCL_ERROR_MEMORY;\n\n if(!local_status) {\n ia = gsl_interp_accel_alloc();\n if(ia == NULL)\n local_status = CCL_ERROR_MEMORY;\n }\n\n if(!local_status) {\n for(iy=0; iy<ny; iy++) {\n if(!local_status) {\n if(gsl_spline_init(s, x, y[iy], nx)) {\n local_status = CCL_ERROR_SPLINE;\n result[iy] = NAN;\n\t }\n\t }\n\n\t if(!local_status) {\n\t int sstat = gsl_spline_eval_integ_e(s, a, b, ia, &(result[iy]));\n\t if(sstat) {\n local_status = CCL_ERROR_SPLINE_EV;\n result[iy] = NAN;\n\t }\n\t }\n\t}\n }\n\n gsl_spline_free(s);\n gsl_interp_accel_free(ia);\n\n if (local_status) {\n *status = local_status;\n }\n } //end omp parallel\n }\n}\n"},"omp_formatted":{"kind":"string","value":"#include <stdio.h>\n#include <stdlib.h>\n#include <math.h>\n\n#include <gsl/gsl_errno.h>\n\n#include \"ccl.h\"\n\n/* ------- ROUTINE: ccl_linear spacing ------\nINPUTS: [xmin,xmax] of the interval to be divided in N bins\nOUTPUT: bin edges in range [xmin,xmax]\n*/\n\ndouble * ccl_linear_spacing(double xmin, double xmax, int N)\n{\n double dx = (xmax-xmin)/(N -1.);\n\n double * x = malloc(sizeof(double)*N);\n if (x==NULL) {\n ccl_raise_warning(\n CCL_ERROR_MEMORY,\n \"ERROR: Could not allocate memory for linear-spaced array (N=%d)\\n\", N);\n return x;\n }\n\n for (int i=0; i<N; i++) {\n x[i] = xmin + dx*i;\n }\n x[0]=xmin; //Make sure roundoff errors don't spoil edges\n x[N-1]=xmax; //Make sure roundoff errors don't spoil edges\n\n return x;\n}\n\n/* ------- ROUTINE: ccl_linlog spacing ------\n * INPUTS: [xminlog,xmax] of the interval to be divided in bins\n * xmin when linear spacing starts\n * Nlog number of logarithmically spaced bins\n * Nlin number of linearly spaced bins\n * OUTPUT: bin edges in range [xminlog,xmax]\n * */\n\ndouble * ccl_linlog_spacing(double xminlog, double xmin, double xmax, int Nlog, int Nlin)\n{\n if (Nlog<2) {\n ccl_raise_warning(\n CCL_ERROR_LINLOGSPACE,\n \"ERROR: Cannot make log-spaced array with %d points - need at least 2\\n\", Nlog);\n return NULL;\n }\n\n if (!(xminlog>0 && xmin>0)) {\n ccl_raise_warning(\n CCL_ERROR_LINLOGSPACE,\n \"ERROR: Cannot make log-spaced array xminlog or xmin non-positive (had %le, %le)\\n\", xminlog, xmin);\n return NULL;\n }\n\n if (xminlog>xmin){\n ccl_raise_warning(CCL_ERROR_LINLOGSPACE, \"ERROR: xminlog must be smaller as xmin\");\n return NULL;\n }\n\n if (xmin>xmax){\n ccl_raise_warning(CCL_ERROR_LINLOGSPACE, \"ERROR: xmin must be smaller as xmax\");\n return NULL;\n }\n\n double * x = malloc(sizeof(double)*(Nlin+Nlog-1));\n if (x==NULL) {\n ccl_raise_warning(\n CCL_ERROR_MEMORY,\n \"ERROR: Could not allocate memory for array of size (Nlin+Nlog-1)=%d)\\n\", (Nlin+Nlog-1));\n return x;\n }\n\n double dx = (xmax-xmin)/(Nlin -1.);\n double log_xchange = log(xmin);\n double log_xmin = log(xminlog);\n double dlog_x = (log_xchange - log_xmin) / (Nlog-1.);\n\n for (int i=0; i<Nlin+Nlog-1; i++) {\n if (i<Nlog)\n x[i] = exp(log_xmin + dlog_x*i);\n if (i>=Nlog)\n x[i] = xmin + dx*(i-Nlog+1);\n }\n\n x[0]=xminlog; //Make sure roundoff errors don't spoil edges\n x[Nlog-1]=xmin; //Make sure roundoff errors don't spoil edges\n x[Nlin+Nlog-2]=xmax; //Make sure roundoff errors don't spoil edges\n\n return x;\n}\n\n/* ------- ROUTINE: ccl_log spacing ------\nINPUTS: [xmin,xmax] of the interval to be divided logarithmically in N bins\nTASK: divide an interval in N logarithmic bins\nOUTPUT: bin edges in range [xmin,xmax]\n*/\n\ndouble * ccl_log_spacing(double xmin, double xmax, int N)\n{\n if (N<2) {\n ccl_raise_warning(\n CCL_ERROR_LOGSPACE,\n \"ERROR: Cannot make log-spaced array with %d points - need at least 2\\n\", N);\n return NULL;\n }\n\n if (!(xmin>0 && xmax>0)) {\n ccl_raise_warning(\n CCL_ERROR_LOGSPACE,\n \"ERROR: Cannot make log-spaced array xmax or xmax non-positive (had %le, %le)\\n\", xmin, xmax);\n return NULL;\n }\n\n double log_xmax = log(xmax);\n double log_xmin = log(xmin);\n double dlog_x = (log_xmax - log_xmin) / (N-1.);\n\n double * x = malloc(sizeof(double)*N);\n if (x==NULL) {\n ccl_raise_warning(\n CCL_ERROR_MEMORY,\n \"ERROR: Could not allocate memory for log-spaced array (N=%d)\\n\", N);\n return x;\n }\n\n double xratio = exp(dlog_x);\n x[0] = xmin; //Make sure roundoff errors don't spoil edges\n for (int i=1; i<N-1; i++) {\n x[i] = x[i-1] * xratio;\n }\n x[N-1]=xmax; //Make sure roundoff errors don't spoil edges\n\n return x;\n}\n\n#define CCL_GAMMA1 2.6789385347077476336556 //Gamma(1/3)\n#define CCL_GAMMA2 1.3541179394264004169452 //Gamma(2/3)\n#define CCL_ROOTPI12 21.269446210866192327578 //12*sqrt(pi)\ndouble ccl_j_bessel(int l,double x)\n{\n double jl;\n double ax=fabs(x);\n double ax2=x*x;\n if(l<0) {\n fprintf(stderr,\"CosmoMas: l>0 for Bessel function\");\n exit(1);\n }\n\n if(l<7) {\n if(l==0) {\n if(ax<0.1) jl=1-ax2*(1-ax2/20.)/6.;\n else jl=sin(x)/x;\n }\n else if(l==1) {\n if(ax<0.2) jl=ax*(1-ax2*(1-ax2/28)/10)/3;\n else jl=(sin(x)/ax-cos(x))/ax;\n }\n else if(l==2) {\n if(ax<0.3) jl=ax2*(1-ax2*(1-ax2/36)/14)/15;\n else jl=(-3*cos(x)/ax-sin(x)*(1-3/ax2))/ax;\n }\n else if(l==3) {\n if(ax<0.4)\n\tjl=ax*ax2*(1-ax2*(1-ax2/44)/18)/105;\n else\n\tjl=(cos(x)*(1-15/ax2)-sin(x)*(6-15/ax2)/ax)/ax;\n }\n else if(l==4) {\n if(ax<0.6)\n\tjl=ax2*ax2*(1-ax2*(1-ax2/52)/22)/945;\n else\n\tjl=(sin(x)*(1-(45-105/ax2)/ax2)+cos(x)*(10-105/ax2)/ax)/ax;\n }\n else if(l==5) {\n if(ax<1.0)\n\tjl=ax2*ax2*ax*(1-ax2*(1-ax2/60)/26)/10395;\n else {\n\tjl=(sin(x)*(15-(420-945/ax2)/ax2)/ax-\n\t cos(x)*(1-(105-945/ax2)/ax2))/ax;\n }\n }\n else {\n if(ax<1.0)\n\tjl=ax2*ax2*ax2*(1-ax2*(1-ax2/68)/30)/135135;\n else {\n\tjl=(sin(x)*(-1+(210-(4725-10395/ax2)/ax2)/ax2)+\n\t cos(x)*(-21+(1260-10395/ax2)/ax2)/ax)/ax;\n }\n }\n }\n else {\n double nu=l+0.5;\n double nu2=nu*nu;\n\n if(ax<1.0E-40) jl=0;\n else if((ax2/l)<0.5) {\n jl=(exp(l*log(ax/nu)-M_LN2+nu*(1-M_LN2)-(1-(1-3.5/nu2)/(30*nu2))/(12*nu))/nu)*\n\t(1-ax2/(4*nu+4)*(1-ax2/(8*nu+16)*(1-ax2/(12*nu+36))));\n }\n else if((l*l/ax)<0.5) {\n double beta=ax-0.5*M_PI*(l+1);\n jl=(cos(beta)*(1-(nu2-0.25)*(nu2-2.25)/(8*ax2)*(1-(nu2-6.25)*(nu2-12.25)/(48*ax2)))-\n\t sin(beta)*(nu2-0.25)/(2*ax)*(1-(nu2-2.25)*(nu2-6.25)/(24*ax2)*\n\t\t\t\t (1-(nu2-12.25)*(nu2-20.25)/(80*ax2))))/ax;\n }\n else {\n double l3=pow(nu,0.325);\n if(ax<nu-1.31*l3) {\n\tdouble cosb=nu/ax;\n\tdouble sx=sqrt(nu2-ax2);\n\tdouble cotb=nu/sx;\n\tdouble secb=ax/nu;\n\tdouble beta=log(cosb+sx/ax);\n\tdouble cot3b=cotb*cotb*cotb;\n\tdouble cot6b=cot3b*cot3b;\n\tdouble sec2b=secb*secb;\n\tdouble expterm=((2+3*sec2b)*cot3b/24\n\t\t\t-((4+sec2b)*sec2b*cot6b/16\n\t\t\t +((16-(1512+(3654+375*sec2b)*sec2b)*sec2b)*cot3b/5760\n\t\t\t +(32+(288+(232+13*sec2b)*sec2b)*sec2b)*sec2b*cot6b/(128*nu))*\n\t\t\t cot6b/nu)/nu)/nu;\n\tjl=sqrt(cotb*cosb)/(2*nu)*exp(-nu*beta+nu/cotb-expterm);\n }\n else if(ax>nu+1.48*l3) {\n\tdouble cosb=nu/ax;\n\tdouble sx=sqrt(ax2-nu2);\n\tdouble cotb=nu/sx;\n\tdouble secb=ax/nu;\n\tdouble beta=acos(cosb);\n\tdouble cot3b=cotb*cotb*cotb;\n\tdouble cot6b=cot3b*cot3b;\n\tdouble sec2b=secb*secb;\n\tdouble trigarg=nu/cotb-nu*beta-0.25*M_PI-\n\t ((2+3*sec2b)*cot3b/24+(16-(1512+(3654+375*sec2b)*sec2b)*sec2b)*\n\t cot3b*cot6b/(5760*nu2))/nu;\n\tdouble expterm=((4+sec2b)*sec2b*cot6b/16-\n\t\t\t(32+(288+(232+13*sec2b)*sec2b)*sec2b)*\n\t\t\tsec2b*cot6b*cot6b/(128*nu2))/nu2;\n\tjl=sqrt(cotb*cosb)/nu*exp(-expterm)*cos(trigarg);\n }\n else {\n\tdouble beta=ax-nu;\n\tdouble beta2=beta*beta;\n\tdouble sx=6/ax;\n\tdouble sx2=sx*sx;\n\tdouble secb=pow(sx,0.3333333333333333333333);\n\tdouble sec2b=secb*secb;\n\n\tjl=(CCL_GAMMA1*secb+beta*CCL_GAMMA2*sec2b\n\t -(beta2/18-1.0/45.0)*beta*sx*secb*CCL_GAMMA1\n\t -((beta2-1)*beta2/36+1.0/420.0)*sx*sec2b*CCL_GAMMA2\n\t +(((beta2/1620-7.0/3240.0)*beta2+1.0/648.0)*beta2-1.0/8100.0)*sx2*secb*CCL_GAMMA1\n\t +(((beta2/4536-1.0/810.0)*beta2+19.0/11340.0)*beta2-13.0/28350.0)*beta*sx2*sec2b*CCL_GAMMA2\n\t -((((beta2/349920-1.0/29160.0)*beta2+71.0/583200.0)*beta2-121.0/874800.0)*\n\t beta2+7939.0/224532000.0)*beta*sx2*sx*secb*CCL_GAMMA1)*sqrt(sx)/CCL_ROOTPI12;\n }\n }\n }\n if((x<0)&&(l%2!=0)) jl=-jl;\n\n return jl;\n}\n\nvoid ccl_integ_spline(int ny, int nx,double *x,double **y,\n double a, double b, double *result,\n const gsl_interp_type *T, int *status)\n{\n if(b==a) {\n int iyy;\n for(iyy=0; iyy<ny; iyy++)\n result[iyy]=0;\n return;\n }\n if(b<a) {\n b=x[nx-1];\n a=x[0];\n }\n\n if((b>x[nx-1]) || (a<x[0])) {\n ccl_raise_warning(CCL_ERROR_SPLINE,\n\t\t \"ERROR: integration limits beyond interpolated range\\n\");\n *status = CCL_ERROR_SPLINE;\n return;\n }\n\n if(*status==0) {\n #pragma omp parallel default(none) \\\n shared(nx, ny, x, y, a, b, result, T, status)\n {\n int iy;\n int local_status=0;\n gsl_interp_accel *ia = NULL;\n gsl_spline *s = NULL;\n\n s = gsl_spline_alloc(T, nx);\n if(s == NULL)\n local_status = CCL_ERROR_MEMORY;\n\n if(!local_status) {\n ia = gsl_interp_accel_alloc();\n if(ia == NULL)\n local_status = CCL_ERROR_MEMORY;\n }\n\n if(!local_status) {\n #pragma omp for\n for(iy=0; iy<ny; iy++) {\n if(!local_status) {\n if(gsl_spline_init(s, x, y[iy], nx)) {\n local_status = CCL_ERROR_SPLINE;\n result[iy] = NAN;\n\t }\n\t }\n\n\t if(!local_status) {\n\t int sstat = gsl_spline_eval_integ_e(s, a, b, ia, &(result[iy]));\n\t if(sstat) {\n local_status = CCL_ERROR_SPLINE_EV;\n result[iy] = NAN;\n\t }\n\t }\n\t}\n }\n\n gsl_spline_free(s);\n gsl_interp_accel_free(ia);\n\n if (local_status) {\n #pragma omp atomic write\n *status = local_status;\n }\n } //end omp parallel\n }\n}\n"}}},{"rowIdx":89,"cells":{"source":{"kind":"string","value":"generator.h"},"original_c":{"kind":"string","value":"// Copyright (c) 2015, The Regents of the University of California (Regents)\n// See LICENSE.txt for license details\n\n#ifndef GENERATOR_H_\n#define GENERATOR_H_\n\n#include <algorithm>\n#include <cinttypes>\n#include <random>\n\n#include \"graph.h\"\n#include \"pvector.h\"\n#include \"util.h\"\n\n\n/*\nGAP Benchmark Suite\nClass: Generator\nAuthor: Scott Beamer\n\nGiven scale and degree, generates edgelist for synthetic graph\n - Intended to be called from Builder\n - GenerateEL(uniform) generates and returns the edgelist\n - Can generate uniform random (uniform=true) or R-MAT graph according\n to Graph500 parameters (uniform=false)\n - Can also randomize weights within a weighted edgelist (InsertWeights)\n - Blocking/reseeding is for parallelism with deterministic output edgelist\n*/\n\n\ntemplate <typename NodeID_, typename DestID_ = NodeID_,\n typename WeightT_ = NodeID_>\nclass Generator {\n typedef EdgePair<NodeID_, DestID_> Edge;\n typedef EdgePair<NodeID_, NodeWeight<NodeID_, WeightT_>> WEdge;\n typedef pvector<Edge> EdgeList;\n\n public:\n Generator(int scale, int degree) {\n scale_ = scale;\n num_nodes_ = 1l << scale;\n num_edges_ = num_nodes_ * degree;\n if (num_nodes_ > std::numeric_limits<NodeID_>::max()) {\n std::cout << \"NodeID type (max: \" << std::numeric_limits<NodeID_>::max();\n std::cout << \") too small to hold \" << num_nodes_ << std::endl;\n std::cout << \"Recommend changing NodeID (typedef'd in src/benchmark.h)\";\n std::cout << \" to a wider type and recompiling\" << std::endl;\n std::exit(-31);\n }\n }\n\n void PermuteIDs(EdgeList &el) {\n pvector<NodeID_> permutation(num_nodes_);\n std::mt19937 rng(kRandSeed);\n #pragma omp parallel for\n for (NodeID_ n=0; n < num_nodes_; n++)\n permutation[n] = n;\n shuffle(permutation.begin(), permutation.end(), rng);\n #pragma omp parallel for\n for (int64_t e=0; e < num_edges_; e++)\n el[e] = Edge(permutation[el[e].u], permutation[el[e].v]);\n }\n\n EdgeList MakeUniformEL() {\n EdgeList el(num_edges_);\n #pragma omp parallel\n {\n std::mt19937 rng;\n std::uniform_int_distribution<NodeID_> udist(0, num_nodes_-1);\n #pragma omp for\n for (int64_t block=0; block < num_edges_; block+=block_size) {\n rng.seed(kRandSeed + block/block_size);\n for (int64_t e=block; e < std::min(block+block_size, num_edges_); e++) {\n el[e] = Edge(udist(rng), udist(rng));\n }\n }\n }\n return el;\n }\n\n EdgeList MakeRMatEL() {\n const float A = 0.57f, B = 0.19f, C = 0.19f;\n EdgeList el(num_edges_);\n #pragma omp parallel\n {\n std::mt19937 rng;\n std::uniform_real_distribution<float> udist(0, 1.0f);\n #pragma omp for\n for (int64_t block=0; block < num_edges_; block+=block_size) {\n rng.seed(kRandSeed + block/block_size);\n for (int64_t e=block; e < std::min(block+block_size, num_edges_); e++) {\n NodeID_ src = 0, dst = 0;\n for (int depth=0; depth < scale_; depth++) {\n float rand_point = udist(rng);\n src = src << 1;\n dst = dst << 1;\n if (rand_point < A+B) {\n if (rand_point > A)\n dst++;\n } else {\n src++;\n if (rand_point > A+B+C)\n dst++;\n }\n }\n el[e] = Edge(src, dst);\n }\n }\n }\n PermuteIDs(el);\n // TIME_PRINT(\"Shuffle\", std::shuffle(el.begin(), el.end(),\n // std::mt19937()));\n return el;\n }\n\n EdgeList GenerateEL(bool uniform) {\n EdgeList el;\n Timer t;\n t.Start();\n if (uniform)\n el = MakeUniformEL();\n else\n el = MakeRMatEL();\n t.Stop();\n PrintTime(\"Generate Time\", t.Seconds());\n return el;\n }\n\n static void InsertWeights(pvector<EdgePair<NodeID_, NodeID_>> &el) {}\n\n // Overwrites existing weights with random from [1,255]\n static void InsertWeights(pvector<WEdge> &el) {\n #pragma omp parallel\n {\n std::mt19937 rng;\n std::uniform_int_distribution<int> udist(1, 255);\n int64_t el_size = el.size();\n #pragma omp for\n for (int64_t block=0; block < el_size; block+=block_size) {\n rng.seed(kRandSeed + block/block_size);\n for (int64_t e=block; e < std::min(block+block_size, el_size); e++) {\n el[e].v.w = static_cast<WeightT_>(udist(rng));\n }\n }\n }\n }\n\n private:\n int scale_;\n int64_t num_nodes_;\n int64_t num_edges_;\n static const int64_t block_size = 1<<18;\n};\n\n#endif // GENERATOR_H_\n"},"no_omp_formatted":{"kind":"string","value":"// Copyright(c) 2015, The Regents of the University of California(Regents)\n// See LICENSE.txt for license\n details\n\n#ifndef GENERATOR_H_\n#define GENERATOR_H_\n\n#include <algorithm>\n#include <cinttypes>\n#include <random>\n\n#include \"graph.h\"\n#include \"pvector.h\"\n#include \"util.h\"\n\n\n /*\n * GAP Benchmark Suite Class: Generator Author: Scott Beamer\n * \n * Given scale and degree, generates edgelist for synthetic graph - Intended\n * to be called from Builder - GenerateEL(uniform) generates and returns\n * the edgelist - Can generate uniform random (uniform=true) or R-MAT\n * graph according to Graph500 parameters (uniform=false) - Can also\n * randomize weights within a weighted edgelist (InsertWeights) -\n * Blocking/reseeding is for parallelism with deterministic output\n * edgelist\n */\n\n\n template < typename NodeID_, typename DestID_ = NodeID_,\n typename WeightT_ = NodeID_ >\n class Generator\n{\n typedef EdgePair < NodeID_, DestID_ > Edge;\n typedef EdgePair < NodeID_, NodeWeight < NodeID_, WeightT_ >> WEdge;\n typedef pvector < Edge > EdgeList;\n\npublic:\n Generator(int scale, int degree)\n {\n scale_ = scale;\n num_nodes_ = 1l << scale;\n num_edges_ = num_nodes_ * degree;\nif (num_nodes_ > std: : numeric_limits < NodeID_ >: :max())\n {\n std: : cout << \"NodeID type (max: \" << std: : numeric_limits < NodeID_ >: :max();\n std: : cout << \") too small to hold \" << num_nodes_ << std: :endl;\n std: : cout << \"Recommend changing NodeID (typedef'd in src/benchmark.h)\";\n std: : cout << \" to a wider type and recompiling\" << std: :endl;\n std: : exit(-31);\n }\n }\n\n void PermuteIDs(EdgeList & el)\n {\n pvector < NodeID_ > permutation(num_nodes_);\nstd: : mt19937 rng(kRandSeed);\n for (NodeID_ n = 0; n < num_nodes_; n++)\n permutation[n] = n;\n shuffle(permutation.begin(), permutation.end(), rng);\n for (int64_t e = 0; e < num_edges_; e++)\n el[e] = Edge(permutation[el[e].u], permutation[el[e].v]);\n }\n\n EdgeList MakeUniformEL()\n {\n EdgeList el(num_edges_);\n std: : mt19937 rng;\n std: : uniform_int_distribution < NodeID_ > udist(0, num_nodes_ - 1);\n for (int64_t block = 0; block < num_edges_; block += block_size)\n {\n rng.seed(kRandSeed + block / block_size);\n for (int64_t e = block; e < std: :min(block + block_size, num_edges_); e++)\n {\n el[e] = Edge(udist(rng), udist(rng));\n }\n }\n\n return el;\n }\n\n EdgeList MakeRMatEL()\n {\n const float A = 0.57 f, B = 0.19 f, C = 0.19 f;\n EdgeList el(num_edges_);\n std: : mt19937 rng;\n std: : uniform_real_distribution < float >udist(0, 1.0 f);\n for (int64_t block = 0; block < num_edges_; block += block_size)\n {\n rng.seed(kRandSeed + block / block_size);\n for (int64_t e = block; e < std: :min(block + block_size, num_edges_); e++)\n {\n NodeID_ src = 0, dst = 0;\n for (int depth = 0; depth < scale_; depth++)\n {\n float rand_point = udist(rng);\n src = src << 1;\n dst = dst << 1;\n if (rand_point < A + B)\n {\n if (rand_point > A)\n dst++;\n } else\n {\n src++;\n if (rand_point > A + B + C)\n dst++;\n }\n }\n el[e] = Edge(src, dst);\n }\n }\n\n PermuteIDs(el);\n//TIME_PRINT(\"Shuffle\", std: :shuffle(el.begin(), el.end(),\n//std: : mt19937()));\n return el;\n }\n\n EdgeList GenerateEL(bool uniform)\n {\n EdgeList el;\n Timer t;\n t.Start();\n if (uniform)\n el = MakeUniformEL();\n else\n el = MakeRMatEL();\n t.Stop();\n PrintTime(\"Generate Time\", t.Seconds());\n return el;\n }\n\n static void InsertWeights(pvector < EdgePair < NodeID_, NodeID_ >> &el)\n {\n }\n\n //Overwrites existing weights with random from[1, 255]\n static void InsertWeights(pvector < WEdge > &el)\n {\n std::mt19937 rng;\nstd: : uniform_int_distribution < int >udist(1, 255);\n int64_t el_size = el.size();\n for (int64_t block = 0; block < el_size; block += block_size)\n {\n rng.seed(kRandSeed + block / block_size);\n for (int64_t e = block; e < std: :min(block + block_size, el_size); e++)\n {\n el[e].v.w = static_cast < WeightT_ > (udist(rng));\n }\n }\n\n }\n\n private:\n int scale_;\n int64_t num_nodes_;\n int64_t num_edges_;\n static const int64_t block_size = 1 << 18;\n};\n\n#endif\t/* // GENERATOR_H_ */\n"},"omp_formatted":{"kind":"string","value":"// Copyright(c) 2015, The Regents of the University of California(Regents)\n// See LICENSE.txt for license\n details\n\n#ifndef GENERATOR_H_\n#define GENERATOR_H_\n\n#include <algorithm>\n#include <cinttypes>\n#include <random>\n\n#include \"graph.h\"\n#include \"pvector.h\"\n#include \"util.h\"\n\n\n /*\n * GAP Benchmark Suite Class: Generator Author: Scott Beamer\n * \n * Given scale and degree, generates edgelist for synthetic graph - Intended\n * to be called from Builder - GenerateEL(uniform) generates and returns\n * the edgelist - Can generate uniform random (uniform=true) or R-MAT\n * graph according to Graph500 parameters (uniform=false) - Can also\n * randomize weights within a weighted edgelist (InsertWeights) -\n * Blocking/reseeding is for parallelism with deterministic output\n * edgelist\n */\n\n\n template < typename NodeID_, typename DestID_ = NodeID_,\n typename WeightT_ = NodeID_ >\n class Generator\n{\n typedef EdgePair < NodeID_, DestID_ > Edge;\n typedef EdgePair < NodeID_, NodeWeight < NodeID_, WeightT_ >> WEdge;\n typedef pvector < Edge > EdgeList;\n\npublic:\n Generator(int scale, int degree)\n {\n scale_ = scale;\n num_nodes_ = 1l << scale;\n num_edges_ = num_nodes_ * degree;\nif (num_nodes_ > std: : numeric_limits < NodeID_ >: :max())\n {\n std: : cout << \"NodeID type (max: \" << std: : numeric_limits < NodeID_ >: :max();\n std: : cout << \") too small to hold \" << num_nodes_ << std: :endl;\n std: : cout << \"Recommend changing NodeID (typedef'd in src/benchmark.h)\";\n std: : cout << \" to a wider type and recompiling\" << std: :endl;\n std: : exit(-31);\n }\n }\n\n void PermuteIDs(EdgeList & el)\n {\n pvector < NodeID_ > permutation(num_nodes_);\nstd: : mt19937 rng(kRandSeed);\n#pragma omp parallel for\n for (NodeID_ n = 0; n < num_nodes_; n++)\n permutation[n] = n;\n shuffle(permutation.begin(), permutation.end(), rng);\n#pragma omp parallel for\n for (int64_t e = 0; e < num_edges_; e++)\n el[e] = Edge(permutation[el[e].u], permutation[el[e].v]);\n }\n\n EdgeList MakeUniformEL()\n {\n EdgeList el(num_edges_);\n#pragma omp parallel\n {\n std: : mt19937 rng;\n std: : uniform_int_distribution < NodeID_ > udist(0, num_nodes_ - 1);\n#pragma omp for\n for (int64_t block = 0; block < num_edges_; block += block_size)\n {\n rng.seed(kRandSeed + block / block_size);\n for (int64_t e = block; e < std: :min(block + block_size, num_edges_); e++)\n {\n el[e] = Edge(udist(rng), udist(rng));\n }\n }\n }\n return el;\n }\n\n EdgeList MakeRMatEL()\n {\n const float A = 0.57 f, B = 0.19 f, C = 0.19 f;\n EdgeList el(num_edges_);\n#pragma omp parallel\n {\n std: : mt19937 rng;\n std: : uniform_real_distribution < float >udist(0, 1.0 f);\n#pragma omp for\n for (int64_t block = 0; block < num_edges_; block += block_size)\n {\n rng.seed(kRandSeed + block / block_size);\n for (int64_t e = block; e < std: :min(block + block_size, num_edges_); e++)\n {\n NodeID_ src = 0, dst = 0;\n for (int depth = 0; depth < scale_; depth++)\n {\n float rand_point = udist(rng);\n src = src << 1;\n dst = dst << 1;\n if (rand_point < A + B)\n {\n if (rand_point > A)\n dst++;\n } else\n {\n src++;\n if (rand_point > A + B + C)\n dst++;\n }\n }\n el[e] = Edge(src, dst);\n }\n }\n }\n PermuteIDs(el);\n//TIME_PRINT(\"Shuffle\", std: :shuffle(el.begin(), el.end(),\n//std: : mt19937()));\n return el;\n }\n\n EdgeList GenerateEL(bool uniform)\n {\n EdgeList el;\n Timer t;\n t.Start();\n if (uniform)\n el = MakeUniformEL();\n else\n el = MakeRMatEL();\n t.Stop();\n PrintTime(\"Generate Time\", t.Seconds());\n return el;\n }\n\n static void InsertWeights(pvector < EdgePair < NodeID_, NodeID_ >> &el)\n {\n }\n\n //Overwrites existing weights with random from[1, 255]\n static void InsertWeights(pvector < WEdge > &el)\n {\n#pragma omp parallel\n {\n std::mt19937 rng;\n std: : uniform_int_distribution < int >udist(1, 255);\n int64_t el_size = el.size();\n#pragma omp for\n for (int64_t block = 0; block < el_size; block += block_size)\n {\n rng.seed(kRandSeed + block / block_size);\n for (int64_t e = block; e < std: :min(block + block_size, el_size); e++)\n {\n el[e].v.w = static_cast < WeightT_ > (udist(rng));\n }\n }\n }\n }\n\n private:\n int scale_;\n int64_t num_nodes_;\n int64_t num_edges_;\n static const int64_t block_size = 1 << 18;\n};\n\n#endif\t/* // GENERATOR_H_ */\n"}}},{"rowIdx":90,"cells":{"source":{"kind":"string","value":"thread_scale.c"},"original_c":{"kind":"string","value":"/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */\n/*\n * See COPYRIGHT in top-level directory.\n */\n#define _GNU_SOURCE\n#include <stdio.h>\n#include <omp.h>\n#include <sched.h>\n#include <unistd.h>\n#include <pthread.h>\n#include \"zmtest_abslock.h\"\n\n#define TEST_NITER (1<<22)\n#define WARMUP_ITER 128\n\n#define CACHELINE_SZ 64\n#define ARRAY_LEN 10\n\nchar cache_lines[CACHELINE_SZ*ARRAY_LEN] = {0};\n\n#if ARRAY_LEN == 10\nint indices [] = {3,6,1,7,0,2,9,4,8,5};\n#elif ARRAY_LEN == 4\nint indices [] = {2,1,3,0};\n#endif\n\nzm_abslock_t lock;\n\n#if defined (ZM_BIND_MANUAL)\nvoid bind_compact(){\n int tid = omp_get_thread_num();\n /* Compute the target core */\n int tgt_core = tid;\n\n cpu_set_t set;\n CPU_ZERO(&set);\n CPU_SET(tgt_core, &set);\n\n if (pthread_setaffinity_np(pthread_self(), sizeof(set), &set) < 0) {\n perror(\"pthread_setaffinity_np\");\n }\n}\n#else\n#define bind_compact()\n#endif\n\nstatic void test_thruput()\n{\n unsigned nthreads = omp_get_max_threads();\n\n zm_abslock_init(&lock);\n int cur_nthreads;\n /* Throughput = lock acquisitions per second */\n printf(\"nthreads,thruput,lat\\n\");\n for(cur_nthreads=1; cur_nthreads <= nthreads; cur_nthreads+= ((cur_nthreads==1) ? 1 : 2)) {\n double start_time, stop_time;\n #pragma omp parallel num_threads(cur_nthreads)\n {\n\n bind_compact();\n\n int tid = omp_get_thread_num();\n\n /* Warmup */\n for(int iter=0; iter < WARMUP_ITER; iter++) {\n zm_abslock_acquire(&lock);\n /* Computation */\n for(int i = 0; i < ARRAY_LEN; i++)\n cache_lines[indices[i]] += cache_lines[indices[ARRAY_LEN-1-i]];\n zm_abslock_release(&lock);\n }\n #pragma omp barrier\n #pragma omp single\n {\n start_time = omp_get_wtime();\n }\n #pragma omp for schedule(static)\n for(int iter = 0; iter < TEST_NITER; iter++) {\n zm_abslock_acquire(&lock);\n /* Computation */\n for(int i = 0; i < ARRAY_LEN; i++)\n cache_lines[indices[i]] += cache_lines[indices[ARRAY_LEN-1-i]];\n zm_abslock_release(&lock);\n }\n }\n stop_time = omp_get_wtime();\n double elapsed_time = stop_time - start_time;\n double thruput = (double)TEST_NITER/elapsed_time;\n double latency = elapsed_time*1e9/TEST_NITER; // latency in nanoseconds\n printf(\"%d,%.2lf,%.2lf\\n\", cur_nthreads, thruput, latency);\n }\n\n}\n\nint main(int argc, char **argv)\n{\n test_thruput();\n return 0;\n}\n\n"},"no_omp_formatted":{"kind":"string","value":"\n#define _GNU_SOURCE\n#include <stdio.h>\n#include <omp.h>\n#include <sched.h>\n#include <unistd.h>\n#include <pthread.h>\n#include \"zmtest_abslock.h\"\n\n#define TEST_NITER (1<<22)\n#define WARMUP_ITER 128\n\n#define CACHELINE_SZ 64\n#define ARRAY_LEN 10\n\nchar cache_lines[CACHELINE_SZ * ARRAY_LEN] = {0};\n\n#if ARRAY_LEN == 10\nint indices[] = {3, 6, 1, 7, 0, 2, 9, 4, 8, 5};\n\n#elif ARRAY_LEN == 4\nint indices[] = {2, 1, 3, 0};\n\n#endif\n\nzm_abslock_t lock;\n\n#if defined (ZM_BIND_MANUAL)\nvoid \nbind_compact()\n{\n int tid = omp_get_thread_num();\n /* Compute the target core */\n int tgt_core = tid;\n\n cpu_set_t set;\n CPU_ZERO(&set);\n CPU_SET(tgt_core, &set);\n\n if (pthread_setaffinity_np(pthread_self(), sizeof(set), &set) < 0)\n {\n perror(\"pthread_setaffinity_np\");\n }\n}\n\n#else\n#define bind_compact()\n#endif\n\nstatic void \ntest_thruput()\n{\n unsigned nthreads = omp_get_max_threads();\n\n zm_abslock_init(&lock);\n int cur_nthreads;\n /* Throughput = lock acquisitions per second */\n printf(\"nthreads,thruput,lat\\n\");\n for (cur_nthreads = 1; cur_nthreads <= nthreads; cur_nthreads += ((cur_nthreads == 1) ? 1 : 2))\n {\n double start_time, stop_time;\n\n bind_compact();\n\n int tid = omp_get_thread_num();\n\n /* Warmup */\n for (int iter = 0; iter < WARMUP_ITER; iter++)\n {\n zm_abslock_acquire(&lock);\n /* Computation */\n for (int i = 0; i < ARRAY_LEN; i++)\n cache_lines[indices[i]] += cache_lines[indices[ARRAY_LEN - 1 - i]];\n zm_abslock_release(&lock);\n }\n start_time = omp_get_wtime();\n\n for (int iter = 0; iter < TEST_NITER; iter++)\n {\n zm_abslock_acquire(&lock);\n /* Computation */\n for (int i = 0; i < ARRAY_LEN; i++)\n cache_lines[indices[i]] += cache_lines[indices[ARRAY_LEN - 1 - i]];\n zm_abslock_release(&lock);\n }\n\n stop_time = omp_get_wtime();\n double elapsed_time = stop_time - start_time;\n double thruput = (double)TEST_NITER / elapsed_time;\n double latency = elapsed_time * 1e9 / TEST_NITER;\n //latency in nanoseconds\n printf(\"%d,%.2lf,%.2lf\\n\", cur_nthreads, thruput, latency);\n }\n\n}\n\nint \nmain(int argc, char **argv)\n{\n test_thruput();\n return 0;\n}\n"},"omp_formatted":{"kind":"string","value":"\n#define _GNU_SOURCE\n#include <stdio.h>\n#include <omp.h>\n#include <sched.h>\n#include <unistd.h>\n#include <pthread.h>\n#include \"zmtest_abslock.h\"\n\n#define TEST_NITER (1<<22)\n#define WARMUP_ITER 128\n\n#define CACHELINE_SZ 64\n#define ARRAY_LEN 10\n\nchar cache_lines[CACHELINE_SZ * ARRAY_LEN] = {0};\n\n#if ARRAY_LEN == 10\nint indices[] = {3, 6, 1, 7, 0, 2, 9, 4, 8, 5};\n\n#elif ARRAY_LEN == 4\nint indices[] = {2, 1, 3, 0};\n\n#endif\n\nzm_abslock_t lock;\n\n#if defined (ZM_BIND_MANUAL)\nvoid \nbind_compact()\n{\n int tid = omp_get_thread_num();\n /* Compute the target core */\n int tgt_core = tid;\n\n cpu_set_t set;\n CPU_ZERO(&set);\n CPU_SET(tgt_core, &set);\n\n if (pthread_setaffinity_np(pthread_self(), sizeof(set), &set) < 0)\n {\n perror(\"pthread_setaffinity_np\");\n }\n}\n\n#else\n#define bind_compact()\n#endif\n\nstatic void \ntest_thruput()\n{\n unsigned nthreads = omp_get_max_threads();\n\n zm_abslock_init(&lock);\n int cur_nthreads;\n /* Throughput = lock acquisitions per second */\n printf(\"nthreads,thruput,lat\\n\");\n for (cur_nthreads = 1; cur_nthreads <= nthreads; cur_nthreads += ((cur_nthreads == 1) ? 1 : 2))\n {\n double start_time, stop_time;\n#pragma omp parallel num_threads(cur_nthreads)\n {\n\n bind_compact();\n\n int tid = omp_get_thread_num();\n\n /* Warmup */\n for (int iter = 0; iter < WARMUP_ITER; iter++)\n {\n zm_abslock_acquire(&lock);\n /* Computation */\n for (int i = 0; i < ARRAY_LEN; i++)\n cache_lines[indices[i]] += cache_lines[indices[ARRAY_LEN - 1 - i]];\n zm_abslock_release(&lock);\n }\n#pragma omp barrier\n#pragma omp single\n {\n start_time = omp_get_wtime();\n }\n#pragma omp for schedule(static)\n for (int iter = 0; iter < TEST_NITER; iter++)\n {\n zm_abslock_acquire(&lock);\n /* Computation */\n for (int i = 0; i < ARRAY_LEN; i++)\n cache_lines[indices[i]] += cache_lines[indices[ARRAY_LEN - 1 - i]];\n zm_abslock_release(&lock);\n }\n }\n stop_time = omp_get_wtime();\n double elapsed_time = stop_time - start_time;\n double thruput = (double)TEST_NITER / elapsed_time;\n double latency = elapsed_time * 1e9 / TEST_NITER;\n //latency in nanoseconds\n printf(\"%d,%.2lf,%.2lf\\n\", cur_nthreads, thruput, latency);\n }\n\n}\n\nint \nmain(int argc, char **argv)\n{\n test_thruput();\n return 0;\n}\n"}}},{"rowIdx":91,"cells":{"source":{"kind":"string","value":"wgs64.c"},"original_c":{"kind":"string","value":"#include <stdio.h>\n#include <omp.h>\n\nint n =64;\n\nint main(void) {\n\n int fail = 0;\n int a = -1;\n //\n#if 1\n#pragma omp target\n { //nothing\n }\n#endif\n #pragma omp target teams distribute thread_limit(64)\n for (int k =0; k < n; k++)\n {\n // nothing\n }\n printf(\"Succeeded\\n\");\n\n return fail;\n}\n\n"},"no_omp_formatted":{"kind":"string","value":"#include <stdio.h>\n#include <omp.h>\n\nint n = 64;\n\nint \nmain(void)\n{\n\n int fail = 0;\n int a = -1;\n //\n#if 1 //nothing\n\n#endif\n for (int k = 0; k < n; k++)\n {\n //nothing\n }\n printf(\"Succeeded\\n\");\n\n return fail;\n}\n"},"omp_formatted":{"kind":"string","value":"#include <stdio.h>\n#include <omp.h>\n\nint n = 64;\n\nint \nmain(void)\n{\n\n int fail = 0;\n int a = -1;\n //\n#if 1\n#pragma omp target\n {\n //nothing\n }\n#endif\n#pragma omp target teams distribute thread_limit(64)\n for (int k = 0; k < n; k++)\n {\n //nothing\n }\n printf(\"Succeeded\\n\");\n\n return fail;\n}\n"}}},{"rowIdx":92,"cells":{"source":{"kind":"string","value":"ellipticBuildJacobi.c"},"original_c":{"kind":"string","value":"/*\n\nThe MIT License (MIT)\n\nCopyright (c) 2017 Tim Warburton, Noel Chalmers, Jesse Chan, Ali Karakus\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n\n*/\n\n#include \"elliptic.h\"\n\nvoid BuildLocalIpdgBBDiagTri2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A);\nvoid BuildLocalIpdgDiagTri2D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A);\nvoid BuildLocalIpdgDiagQuad2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dfloat *B, dfloat *Br, dfloat *Bs, dlong eM, dfloat *A);\nvoid BuildLocalIpdgDiagTet3D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A);\nvoid BuildLocalIpdgDiagHex3D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dfloat *B, dfloat *Br, dfloat *Bs, dfloat *Bt, dlong eM, dfloat *A);\n\nvoid BuildLocalContinuousDiagTri2D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *A);\nvoid BuildLocalContinuousDiagQuad2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *B, dfloat *Br, dfloat *Bs, dfloat *A);\nvoid BuildLocalContinuousDiagTet3D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *A);\nvoid BuildLocalContinuousDiagHex3D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *B, dfloat *Br, dfloat *Bs, dfloat *Bt, dfloat *A);\n\nvoid ellipticBuildJacobi(elliptic_t* elliptic, dfloat lambda, dfloat **invDiagA){\n\n mesh_t *mesh = elliptic->mesh;\n setupAide options = elliptic->options;\n\n // surface mass matrices MS = MM*LIFT\n dfloat *MS = (dfloat *) calloc(mesh->Nfaces*mesh->Nfp*mesh->Nfp,sizeof(dfloat));\n for (int f=0;f<mesh->Nfaces;f++) {\n for (int n=0;n<mesh->Nfp;n++) {\n int fn = mesh->faceNodes[f*mesh->Nfp+n];\n\n for (int m=0;m<mesh->Nfp;m++) {\n dfloat MSnm = 0;\n\n for (int i=0;i<mesh->Np;i++){\n MSnm += mesh->MM[fn+i*mesh->Np]*mesh->LIFT[i*mesh->Nfp*mesh->Nfaces+f*mesh->Nfp+m];\n }\n\n MS[m+n*mesh->Nfp + f*mesh->Nfp*mesh->Nfp] = MSnm;\n }\n }\n }\n\n // build some monolithic basis arrays (for quads and hexes)\n dfloat *B = (dfloat*) calloc(mesh->Np*mesh->Np, sizeof(dfloat));\n dfloat *Br = (dfloat*) calloc(mesh->Np*mesh->Np, sizeof(dfloat));\n dfloat *Bs = (dfloat*) calloc(mesh->Np*mesh->Np, sizeof(dfloat));\n dfloat *Bt = (dfloat*) calloc(mesh->Np*mesh->Np, sizeof(dfloat));\n\n if (elliptic->elementType==QUADRILATERALS) {\n int mode = 0;\n for(int nj=0;nj<mesh->N+1;++nj){\n for(int ni=0;ni<mesh->N+1;++ni){\n\n int node = 0;\n\n for(int j=0;j<mesh->N+1;++j){\n for(int i=0;i<mesh->N+1;++i){\n\n if(nj==j && ni==i)\n B[mode*mesh->Np+node] = 1;\n if(nj==j)\n Br[mode*mesh->Np+node] = mesh->D[ni+mesh->Nq*i]; \n if(ni==i)\n Bs[mode*mesh->Np+node] = mesh->D[nj+mesh->Nq*j]; \n \n ++node;\n }\n }\n ++mode;\n }\n }\n }\n\n if (elliptic->elementType==HEXAHEDRA) {\n int mode = 0;\n for(int nk=0;nk<mesh->N+1;++nk){\n for(int nj=0;nj<mesh->N+1;++nj){\n for(int ni=0;ni<mesh->N+1;++ni){\n\n int node = 0;\n\n for(int k=0;k<mesh->N+1;++k){\n for(int j=0;j<mesh->N+1;++j){\n for(int i=0;i<mesh->N+1;++i){\n\n if(nk==k && nj==j && ni==i)\n B[mode*mesh->Np+node] = 1;\n if(nj==j && nk==k)\n Br[mode*mesh->Np+node] = mesh->D[ni+mesh->Nq*i]; \n if(ni==i && nk==k)\n Bs[mode*mesh->Np+node] = mesh->D[nj+mesh->Nq*j]; \n if(ni==i && nj==j)\n Bt[mode*mesh->Np+node] = mesh->D[nk+mesh->Nq*k]; \n \n ++node;\n }\n }\n }\n \n ++mode;\n }\n }\n }\n }\n\n\n\n dlong diagNnum = mesh->Np*mesh->Nelements;\n\n dfloat *diagA = (dfloat*) calloc(diagNnum, sizeof(dfloat));\n\n if(mesh->rank==0) printf(\"Building diagonal...\");fflush(stdout);\n\n if (options.compareArgs(\"DISCRETIZATION\",\"IPDG\")) {\n switch(elliptic->elementType){\n case TRIANGLES: \n if (options.compareArgs(\"BASIS\",\"BERN\")) {\n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalIpdgBBDiagTri2D(elliptic, mesh, lambda, MS, eM, diagA + eM*mesh->Np); \n } else {\n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalIpdgDiagTri2D(elliptic, mesh, lambda, MS, eM, diagA + eM*mesh->Np); \n } \n break;\n case QUADRILATERALS:\n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalIpdgDiagQuad2D(elliptic, mesh, lambda, MS, B, Br, Bs, eM, diagA + eM*mesh->Np);\n break;\n case TETRAHEDRA:\n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalIpdgDiagTet3D(elliptic, mesh, lambda, MS, eM, diagA + eM*mesh->Np); \n break;\n case HEXAHEDRA:\n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalIpdgDiagHex3D(elliptic, mesh, lambda, MS, B, Br, Bs, Bt, eM, diagA + eM*mesh->Np); \n break;\n }\n } else if (options.compareArgs(\"DISCRETIZATION\",\"CONTINUOUS\")) {\n switch(elliptic->elementType){\n case TRIANGLES: \n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalContinuousDiagTri2D(elliptic, mesh, lambda, eM, diagA + eM*mesh->Np);\n break;\n case QUADRILATERALS:\n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalContinuousDiagQuad2D(elliptic, mesh, lambda, eM, B, Br, Bs, diagA + eM*mesh->Np);\n break;\n case TETRAHEDRA:\n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalContinuousDiagTet3D(elliptic, mesh, lambda, eM, diagA + eM*mesh->Np);\n break;\n case HEXAHEDRA:\n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalContinuousDiagHex3D(elliptic, mesh, lambda, eM, B, Br, Bs, Bt, diagA + eM*mesh->Np);\n break;\n }\n }\n\n if (options.compareArgs(\"DISCRETIZATION\",\"CONTINUOUS\")) \n gsParallelGatherScatter(mesh->hostGsh, diagA, dfloatString, \"add\"); \n \n *invDiagA = (dfloat*) calloc(diagNnum, sizeof(dfloat));\n for (dlong n=0;n<mesh->Nelements*mesh->Np;n++) {\n (*invDiagA)[n] = 1/diagA[n];\n }\n\n if(mesh->rank==0) printf(\"done.\\n\");\n\n free(diagA);\n free(MS);\n free(B); free(Br); free(Bs); free(Bt);\n}\n\nvoid BuildLocalIpdgDiagTri2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A) {\n\n dlong vbase = eM*mesh->Nvgeo;\n dfloat drdx = mesh->vgeo[vbase+RXID];\n dfloat drdy = mesh->vgeo[vbase+RYID];\n dfloat dsdx = mesh->vgeo[vbase+SXID];\n dfloat dsdy = mesh->vgeo[vbase+SYID];\n dfloat J = mesh->vgeo[vbase+JID];\n\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n A[n] = J*lambda*mesh->MM[n*mesh->Np+n];\n A[n] += J*drdx*drdx*mesh->Srr[n*mesh->Np+n];\n A[n] += J*drdx*dsdx*mesh->Srs[n*mesh->Np+n];\n A[n] += J*dsdx*drdx*mesh->Ssr[n*mesh->Np+n];\n A[n] += J*dsdx*dsdx*mesh->Sss[n*mesh->Np+n];\n A[n] += J*drdy*drdy*mesh->Srr[n*mesh->Np+n];\n A[n] += J*drdy*dsdy*mesh->Srs[n*mesh->Np+n];\n A[n] += J*dsdy*drdy*mesh->Ssr[n*mesh->Np+n];\n A[n] += J*dsdy*dsdy*mesh->Sss[n*mesh->Np+n];\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n }\n }\n\n for (int fM=0;fM<mesh->Nfaces;fM++) {\n // load surface geofactors for this face\n dlong sid = mesh->Nsgeo*(eM*mesh->Nfaces+fM);\n dfloat nx = mesh->sgeo[sid+NXID];\n dfloat ny = mesh->sgeo[sid+NYID];\n dfloat sJ = mesh->sgeo[sid+SJID];\n dfloat hinv = mesh->sgeo[sid+IHID];\n\n int bc = mesh->EToB[fM+mesh->Nfaces*eM]; //raw boundary flag\n\n dfloat penalty = elliptic->tau*hinv;\n\n int bcD = 0, bcN =0;\n int bcType = 0;\n\n if(bc>0) bcType = elliptic->BCType[bc]; //find its type (Dirichlet/Neumann)\n\n // this needs to be double checked (and the code where these are used)\n if(bcType==1){ // Dirichlet\n bcD = 1;\n bcN = 0;\n } else if(bcType==2){ // Neumann\n bcD = 0;\n bcN = 1;\n }\n\n // mass matrix for this face\n dfloat *MSf = MS+fM*mesh->Nfp*mesh->Nfp;\n\n // penalty term just involves face nodes\n for(int n=0;n<mesh->Nfp;++n){\n int nM = mesh->faceNodes[fM*mesh->Nfp+n];\n \n for(int m=0;m<mesh->Nfp;++m){\n int mM = mesh->faceNodes[fM*mesh->Nfp+m];\n if (mM == nM) {\n // OP11 = OP11 + 0.5*( gtau*mmE )\n dfloat MSfnm = sJ*MSf[n*mesh->Nfp+m];\n A[nM] += 0.5*(1.-bcN)*(1.+bcD)*penalty*MSfnm;\n }\n }\n }\n\n // now add differential surface terms\n for(int n=0;n<mesh->Nfp;++n){\n int nM = mesh->faceNodes[fM*mesh->Nfp+n];\n\n for(int i=0;i<mesh->Nfp;++i){\n int iM = mesh->faceNodes[fM*mesh->Nfp+i];\n\n dfloat MSfni = sJ*MSf[n*mesh->Nfp+i]; // surface Jacobian built in\n\n dfloat DxMim = drdx*mesh->Dr[iM*mesh->Np+nM] + dsdx*mesh->Ds[iM*mesh->Np+nM];\n dfloat DyMim = drdy*mesh->Dr[iM*mesh->Np+nM] + dsdy*mesh->Ds[iM*mesh->Np+nM];\n\n // OP11 = OP11 + 0.5*( - mmE*Dn1)\n A[nM] += -0.5*nx*(1+bcD)*(1-bcN)*MSfni*DxMim;\n A[nM] += -0.5*ny*(1+bcD)*(1-bcN)*MSfni*DyMim;\n }\n }\n\n for(int n=0;n<mesh->Np;++n){\n for(int m=0;m<mesh->Nfp;++m){\n int mM = mesh->faceNodes[fM*mesh->Nfp+m];\n\n if (mM==n) {\n for(int i=0;i<mesh->Nfp;++i){\n int iM = mesh->faceNodes[fM*mesh->Nfp+i];\n\n dfloat MSfim = sJ*MSf[i*mesh->Nfp+m];\n\n dfloat DxMin = drdx*mesh->Dr[iM*mesh->Np+n] + dsdx*mesh->Ds[iM*mesh->Np+n];\n dfloat DyMin = drdy*mesh->Dr[iM*mesh->Np+n] + dsdy*mesh->Ds[iM*mesh->Np+n];\n\n // OP11 = OP11 + (- Dn1'*mmE );\n A[n] += -0.5*nx*(1+bcD)*(1-bcN)*DxMin*MSfim;\n A[n] += -0.5*ny*(1+bcD)*(1-bcN)*DyMin*MSfim;\n }\n }\n }\n }\n }\n}\n\nvoid BuildLocalIpdgPatchAxTri2D(elliptic_t* elliptic, mesh_t* mesh, int basisNp, dfloat *basis, dfloat lambda,\n dfloat *MS, dlong eM, dfloat *A);\n\n//generate the BB diagonal by extracting it from the transformed patch\nvoid BuildLocalIpdgBBDiagTri2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A) {\n\n dfloat *patchA = (dfloat *) calloc(mesh->Np*mesh->Np,sizeof(dfloat));\n\n int basisNp = mesh->Np;\n dfloat *basis = mesh->VB;\n\n BuildLocalIpdgPatchAxTri2D(elliptic, mesh, basisNp, basis, lambda, MS, eM, patchA);\n\n for(int n=0;n<mesh->Np;++n) {\n A[n] = patchA[n*mesh->Np+n]; //store the diagonal entry\n }\n free(patchA);\n}\n\n//returns the continuous C0 patch A matrix for element eM\nvoid BuildLocalContinuousDiagTri2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *A) {\n\n dlong gbase = eM*mesh->Nggeo;\n dfloat Grr = mesh->ggeo[gbase + G00ID];\n dfloat Grs = mesh->ggeo[gbase + G01ID];\n dfloat Gss = mesh->ggeo[gbase + G11ID];\n dfloat J = mesh->ggeo[gbase + GWJID];\n\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] = J*lambda*mesh->MM[n+n*mesh->Np];\n A[n] += Grr*mesh->Srr[n+n*mesh->Np];\n A[n] += Grs*mesh->Srs[n+n*mesh->Np];\n A[n] += Grs*mesh->Ssr[n+n*mesh->Np];\n A[n] += Gss*mesh->Sss[n+n*mesh->Np];\n } else {\n A[n] = 1; //just put a 1 so A is invertable\n }\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n } \n }\n }\n}\n\nvoid BuildLocalIpdgDiagQuad2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dfloat *B, dfloat *Br, dfloat *Bs, dlong eM, dfloat *A) {\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n A[n] = 0;\n\n // (grad phi_n, grad phi_m)_{D^e}\n for(int i=0;i<mesh->Np;++i){\n dlong base = eM*mesh->Np*mesh->Nvgeo + i;\n dfloat drdx = mesh->vgeo[base+mesh->Np*RXID];\n dfloat drdy = mesh->vgeo[base+mesh->Np*RYID];\n dfloat dsdx = mesh->vgeo[base+mesh->Np*SXID];\n dfloat dsdy = mesh->vgeo[base+mesh->Np*SYID];\n dfloat JW = mesh->vgeo[base+mesh->Np*JWID];\n \n int idn = n*mesh->Np+i;\n dfloat dlndx = drdx*Br[idn] + dsdx*Bs[idn];\n dfloat dlndy = drdy*Br[idn] + dsdy*Bs[idn];\n A[n] += JW*(dlndx*dlndx+dlndy*dlndy);\n A[n] += lambda*JW*B[idn]*B[idn];\n }\n\n for (int fM=0;fM<mesh->Nfaces;fM++) {\n // accumulate flux terms for negative and positive traces\n for(int i=0;i<mesh->Nfp;++i){\n int vidM = mesh->faceNodes[i+fM*mesh->Nfp];\n\n // grab vol geofacs at surface nodes\n dlong baseM = eM*mesh->Np*mesh->Nvgeo + vidM;\n dfloat drdxM = mesh->vgeo[baseM+mesh->Np*RXID];\n dfloat drdyM = mesh->vgeo[baseM+mesh->Np*RYID];\n dfloat dsdxM = mesh->vgeo[baseM+mesh->Np*SXID];\n dfloat dsdyM = mesh->vgeo[baseM+mesh->Np*SYID];\n\n // grab surface geometric factors\n dlong base = mesh->Nsgeo*(eM*mesh->Nfp*mesh->Nfaces + fM*mesh->Nfp + i);\n dfloat nx = mesh->sgeo[base+NXID];\n dfloat ny = mesh->sgeo[base+NYID];\n dfloat wsJ = mesh->sgeo[base+WSJID];\n dfloat hinv = mesh->sgeo[base+IHID];\n \n // form negative trace terms in IPDG\n int idnM = n*mesh->Np+vidM; \n\n dfloat dlndxM = drdxM*Br[idnM] + dsdxM*Bs[idnM];\n dfloat dlndyM = drdyM*Br[idnM] + dsdyM*Bs[idnM];\n dfloat ndotgradlnM = nx*dlndxM+ny*dlndyM;\n dfloat lnM = B[idnM];\n \n dfloat penalty = elliptic->tau*hinv; \n int bc = mesh->EToB[fM+mesh->Nfaces*eM]; //raw boundary flag\n\n int bcD = 0, bcN =0;\n int bcType = 0;\n\n if(bc>0) bcType = elliptic->BCType[bc]; //find its type (Dirichlet/Neumann)\n\n // this needs to be double checked (and the code where these are used)\n if(bcType==1){ // Dirichlet\n bcD = 1;\n bcN = 0;\n } else if(bcType==2){ // Neumann\n bcD = 0;\n bcN = 1;\n } \n\n A[n] += -0.5*(1+bcD)*(1-bcN)*wsJ*lnM*ndotgradlnM; // -(ln^-, N.grad lm^-)\n A[n] += -0.5*(1+bcD)*(1-bcN)*wsJ*ndotgradlnM*lnM; // -(N.grad ln^-, lm^-)\n A[n] += +0.5*(1+bcD)*(1-bcN)*wsJ*penalty*lnM*lnM; // +((tau/h)*ln^-,lm^-)\n }\n }\n }\n}\n\nvoid BuildLocalContinuousDiagQuad2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, \n dfloat *B, dfloat *Br, dfloat* Bs, dfloat *A) {\n\n for (int ny=0;ny<mesh->Nq;ny++) {\n for (int nx=0;nx<mesh->Nq;nx++) {\n int iid = nx+ny*mesh->Nq;\n if (elliptic->mapB[nx+ny*mesh->Nq+eM*mesh->Np]!=1) { \n A[iid] = 0;\n\n for (int k=0;k<mesh->Nq;k++) {\n int id = k+ny*mesh->Nq;\n dfloat Grr = mesh->ggeo[eM*mesh->Np*mesh->Nggeo + id + G00ID*mesh->Np];\n A[iid] += Grr*mesh->D[nx+k*mesh->Nq]*mesh->D[nx+k*mesh->Nq];\n }\n\n for (int k=0;k<mesh->Nq;k++) {\n int id = nx+k*mesh->Nq;\n dfloat Gss = mesh->ggeo[eM*mesh->Np*mesh->Nggeo + id + G11ID*mesh->Np];\n A[iid] += Gss*mesh->D[ny+k*mesh->Nq]*mesh->D[ny+k*mesh->Nq];\n }\n\n int id = nx+ny*mesh->Nq;\n dfloat Grs = mesh->ggeo[eM*mesh->Np*mesh->Nggeo + id + G01ID*mesh->Np];\n A[iid] += 2*Grs*mesh->D[nx+nx*mesh->Nq]*mesh->D[ny+ny*mesh->Nq];\n\n dfloat JW = mesh->ggeo[eM*mesh->Np*mesh->Nggeo + id + GWJID*mesh->Np];\n A[iid] += JW*lambda;\n\n } else {\n A[iid] = 1; //just put a 1 so A is invertable\n }\n }\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n } \n }\n }\n}\n\nvoid BuildLocalIpdgDiagTet3D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A) {\n dlong vbase = eM*mesh->Nvgeo;\n dfloat drdx = mesh->vgeo[vbase+RXID];\n dfloat drdy = mesh->vgeo[vbase+RYID];\n dfloat drdz = mesh->vgeo[vbase+RZID];\n dfloat dsdx = mesh->vgeo[vbase+SXID];\n dfloat dsdy = mesh->vgeo[vbase+SYID];\n dfloat dsdz = mesh->vgeo[vbase+SZID];\n dfloat dtdx = mesh->vgeo[vbase+TXID];\n dfloat dtdy = mesh->vgeo[vbase+TYID];\n dfloat dtdz = mesh->vgeo[vbase+TZID];\n dfloat J = mesh->vgeo[vbase+JID];\n\n dfloat G00 = drdx*drdx + drdy*drdy + drdz*drdz;\n dfloat G01 = drdx*dsdx + drdy*dsdy + drdz*dsdz;\n dfloat G02 = drdx*dtdx + drdy*dtdy + drdz*dtdz;\n\n dfloat G10 = dsdx*drdx + dsdy*drdy + dsdz*drdz;\n dfloat G11 = dsdx*dsdx + dsdy*dsdy + dsdz*dsdz;\n dfloat G12 = dsdx*dtdx + dsdy*dtdy + dsdz*dtdz;\n\n dfloat G20 = dtdx*drdx + dtdy*drdy + dtdz*drdz;\n dfloat G21 = dtdx*dsdx + dtdy*dsdy + dtdz*dsdz;\n dfloat G22 = dtdx*dtdx + dtdy*dtdy + dtdz*dtdz;\n\n\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n A[n] = J*lambda*mesh->MM[n*mesh->Np+n];\n A[n] += J*G00*mesh->Srr[n*mesh->Np+n];\n A[n] += J*G01*mesh->Srs[n*mesh->Np+n];\n A[n] += J*G02*mesh->Srt[n*mesh->Np+n];\n A[n] += J*G10*mesh->Ssr[n*mesh->Np+n];\n A[n] += J*G11*mesh->Sss[n*mesh->Np+n];\n A[n] += J*G12*mesh->Sst[n*mesh->Np+n];\n A[n] += J*G20*mesh->Str[n*mesh->Np+n];\n A[n] += J*G21*mesh->Sts[n*mesh->Np+n];\n A[n] += J*G22*mesh->Stt[n*mesh->Np+n];\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n }\n }\n\n for (int fM=0;fM<mesh->Nfaces;fM++) {\n // load surface geofactors for this face\n dlong sid = mesh->Nsgeo*(eM*mesh->Nfaces+fM);\n dfloat nx = mesh->sgeo[sid+NXID];\n dfloat ny = mesh->sgeo[sid+NYID];\n dfloat nz = mesh->sgeo[sid+NZID];\n dfloat sJ = mesh->sgeo[sid+SJID];\n dfloat hinv = mesh->sgeo[sid+IHID];\n\n int bc = mesh->EToB[fM+mesh->Nfaces*eM]; //raw boundary flag\n\n dfloat penalty = elliptic->tau*hinv;\n\n int bcD = 0, bcN =0;\n int bcType = 0;\n\n if(bc>0) bcType = elliptic->BCType[bc]; //find its type (Dirichlet/Neumann)\n\n // this needs to be double checked (and the code where these are used)\n if(bcType==1){ // Dirichlet\n bcD = 1;\n bcN = 0;\n } else if(bcType==2){ // Neumann\n bcD = 0;\n bcN = 1;\n }\n\n // mass matrix for this face\n dfloat *MSf = MS+fM*mesh->Nfp*mesh->Nfp;\n\n // penalty term just involves face nodes\n for(int n=0;n<mesh->Nfp;++n){\n for(int m=0;m<mesh->Nfp;++m){\n int nM = mesh->faceNodes[fM*mesh->Nfp+n];\n int mM = mesh->faceNodes[fM*mesh->Nfp+m];\n\n if (mM==nM) {\n // OP11 = OP11 + 0.5*( gtau*mmE )\n dfloat MSfnm = sJ*MSf[n*mesh->Nfp+m];\n A[nM] += 0.5*(1.-bcN)*(1.+bcD)*penalty*MSfnm;\n }\n }\n }\n\n // now add differential surface terms\n for(int n=0;n<mesh->Nfp;++n){\n int nM = mesh->faceNodes[fM*mesh->Nfp+n];\n\n for(int i=0;i<mesh->Nfp;++i){\n int iM = mesh->faceNodes[fM*mesh->Nfp+i];\n\n dfloat MSfni = sJ*MSf[n*mesh->Nfp+i]; // surface Jacobian built in\n\n dfloat DxMim = drdx*mesh->Dr[iM*mesh->Np+nM] + dsdx*mesh->Ds[iM*mesh->Np+nM] + dtdx*mesh->Dt[iM*mesh->Np+nM];\n dfloat DyMim = drdy*mesh->Dr[iM*mesh->Np+nM] + dsdy*mesh->Ds[iM*mesh->Np+nM] + dtdy*mesh->Dt[iM*mesh->Np+nM];\n dfloat DzMim = drdz*mesh->Dr[iM*mesh->Np+nM] + dsdz*mesh->Ds[iM*mesh->Np+nM] + dtdz*mesh->Dt[iM*mesh->Np+nM];\n\n // OP11 = OP11 + 0.5*( - mmE*Dn1)\n A[nM] += -0.5*nx*(1+bcD)*(1-bcN)*MSfni*DxMim;\n A[nM] += -0.5*ny*(1+bcD)*(1-bcN)*MSfni*DyMim;\n A[nM] += -0.5*nz*(1+bcD)*(1-bcN)*MSfni*DzMim;\n }\n }\n\n for(int n=0;n<mesh->Np;++n){\n for(int m=0;m<mesh->Nfp;++m){\n int mM = mesh->faceNodes[fM*mesh->Nfp+m];\n\n if (mM==n) {\n for(int i=0;i<mesh->Nfp;++i){\n int iM = mesh->faceNodes[fM*mesh->Nfp+i];\n\n dfloat MSfim = sJ*MSf[i*mesh->Nfp+m];\n\n dfloat DxMin = drdx*mesh->Dr[iM*mesh->Np+n] + dsdx*mesh->Ds[iM*mesh->Np+n] + dtdx*mesh->Dt[iM*mesh->Np+n];\n dfloat DyMin = drdy*mesh->Dr[iM*mesh->Np+n] + dsdy*mesh->Ds[iM*mesh->Np+n] + dtdy*mesh->Dt[iM*mesh->Np+n];\n dfloat DzMin = drdz*mesh->Dr[iM*mesh->Np+n] + dsdz*mesh->Ds[iM*mesh->Np+n] + dtdz*mesh->Dt[iM*mesh->Np+n];\n\n // OP11 = OP11 + (- Dn1'*mmE );\n A[n] += -0.5*nx*(1+bcD)*(1-bcN)*DxMin*MSfim;\n A[n] += -0.5*ny*(1+bcD)*(1-bcN)*DyMin*MSfim;\n A[n] += -0.5*nz*(1+bcD)*(1-bcN)*DzMin*MSfim;\n }\n }\n }\n }\n }\n}\n\nvoid BuildLocalContinuousDiagTet3D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *A) {\n dlong gbase = eM*mesh->Nggeo;\n dfloat Grr = mesh->ggeo[gbase + G00ID];\n dfloat Grs = mesh->ggeo[gbase + G01ID];\n dfloat Grt = mesh->ggeo[gbase + G02ID];\n dfloat Gss = mesh->ggeo[gbase + G11ID];\n dfloat Gst = mesh->ggeo[gbase + G12ID];\n dfloat Gtt = mesh->ggeo[gbase + G22ID];\n dfloat J = mesh->ggeo[gbase + GWJID];\n\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] = J*lambda*mesh->MM[n+n*mesh->Np];\n A[n] += Grr*mesh->Srr[n+n*mesh->Np];\n A[n] += Grs*mesh->Srs[n+n*mesh->Np];\n A[n] += Grt*mesh->Srt[n+n*mesh->Np];\n A[n] += Grs*mesh->Ssr[n+n*mesh->Np];\n A[n] += Gss*mesh->Sss[n+n*mesh->Np];\n A[n] += Gst*mesh->Sst[n+n*mesh->Np];\n A[n] += Grt*mesh->Str[n+n*mesh->Np];\n A[n] += Gst*mesh->Sts[n+n*mesh->Np];\n A[n] += Gtt*mesh->Stt[n+n*mesh->Np];\n } else {\n A[n] = 1; //just put a 1 so A is invertable\n }\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n } \n }\n }\n}\n\nvoid BuildLocalIpdgDiagHex3D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dfloat *B, dfloat *Br, dfloat *Bs, dfloat *Bt, dlong eM, dfloat *A) {\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n A[n] = 0;\n\n // (grad phi_n, grad phi_m)_{D^e}\n for(int i=0;i<mesh->Np;++i){\n dlong base = eM*mesh->Np*mesh->Nvgeo + i;\n dfloat drdx = mesh->vgeo[base+mesh->Np*RXID];\n dfloat drdy = mesh->vgeo[base+mesh->Np*RYID];\n dfloat drdz = mesh->vgeo[base+mesh->Np*RZID];\n dfloat dsdx = mesh->vgeo[base+mesh->Np*SXID];\n dfloat dsdy = mesh->vgeo[base+mesh->Np*SYID];\n dfloat dsdz = mesh->vgeo[base+mesh->Np*SZID];\n dfloat dtdx = mesh->vgeo[base+mesh->Np*TXID];\n dfloat dtdy = mesh->vgeo[base+mesh->Np*TYID];\n dfloat dtdz = mesh->vgeo[base+mesh->Np*TZID];\n dfloat JW = mesh->vgeo[base+mesh->Np*JWID];\n \n int idn = n*mesh->Np+i;\n dfloat dlndx = drdx*Br[idn] + dsdx*Bs[idn] + dtdx*Bt[idn];\n dfloat dlndy = drdy*Br[idn] + dsdy*Bs[idn] + dtdy*Bt[idn];\n dfloat dlndz = drdz*Br[idn] + dsdz*Bs[idn] + dtdz*Bt[idn]; \n A[n] += JW*(dlndx*dlndx+dlndy*dlndy+dlndz*dlndz);\n A[n] += lambda*JW*B[idn]*B[idn];\n }\n\n for (int fM=0;fM<mesh->Nfaces;fM++) {\n // accumulate flux terms for negative and positive traces\n for(int i=0;i<mesh->Nfp;++i){\n int vidM = mesh->faceNodes[i+fM*mesh->Nfp];\n\n // grab vol geofacs at surface nodes\n dlong baseM = eM*mesh->Np*mesh->Nvgeo + vidM;\n dfloat drdxM = mesh->vgeo[baseM+mesh->Np*RXID];\n dfloat drdyM = mesh->vgeo[baseM+mesh->Np*RYID];\n dfloat drdzM = mesh->vgeo[baseM+mesh->Np*RZID];\n dfloat dsdxM = mesh->vgeo[baseM+mesh->Np*SXID];\n dfloat dsdyM = mesh->vgeo[baseM+mesh->Np*SYID];\n dfloat dsdzM = mesh->vgeo[baseM+mesh->Np*SZID];\n dfloat dtdxM = mesh->vgeo[baseM+mesh->Np*TXID];\n dfloat dtdyM = mesh->vgeo[baseM+mesh->Np*TYID];\n dfloat dtdzM = mesh->vgeo[baseM+mesh->Np*TZID];\n\n // grab surface geometric factors\n dlong base = mesh->Nsgeo*(eM*mesh->Nfp*mesh->Nfaces + fM*mesh->Nfp + i);\n dfloat nx = mesh->sgeo[base+NXID];\n dfloat ny = mesh->sgeo[base+NYID];\n dfloat nz = mesh->sgeo[base+NZID];\n dfloat wsJ = mesh->sgeo[base+WSJID];\n dfloat hinv = mesh->sgeo[base+IHID];\n \n // form negative trace terms in IPDG\n int idnM = n*mesh->Np+vidM; \n dfloat dlndxM = drdxM*Br[idnM] + dsdxM*Bs[idnM] + dtdxM*Bt[idnM];\n dfloat dlndyM = drdyM*Br[idnM] + dsdyM*Bs[idnM] + dtdyM*Bt[idnM];\n dfloat dlndzM = drdzM*Br[idnM] + dsdzM*Bs[idnM] + dtdzM*Bt[idnM];\n dfloat ndotgradlnM = nx*dlndxM+ny*dlndyM+nz*dlndzM;\n dfloat lnM = B[idnM];\n \n dfloat penalty = elliptic->tau*hinv; \n int bc = mesh->EToB[fM+mesh->Nfaces*eM]; //raw boundary flag\n\n int bcD = 0, bcN =0;\n int bcType = 0;\n\n if(bc>0) bcType = elliptic->BCType[bc]; //find its type (Dirichlet/Neumann)\n\n // this needs to be double checked (and the code where these are used)\n if(bcType==1){ // Dirichlet\n bcD = 1;\n bcN = 0;\n } else if(bcType==2){ // Neumann\n bcD = 0;\n bcN = 1;\n } \n\n A[n] += -0.5*(1+bcD)*(1-bcN)*wsJ*lnM*ndotgradlnM; // -(ln^-, N.grad lm^-)\n A[n] += -0.5*(1+bcD)*(1-bcN)*wsJ*ndotgradlnM*lnM; // -(N.grad ln^-, lm^-)\n A[n] += +0.5*(1+bcD)*(1-bcN)*wsJ*penalty*lnM*lnM; // +((tau/h)*ln^-,lm^-)\n }\n }\n }\n}\n\nvoid BuildLocalContinuousDiagHex3D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *B, dfloat *Br, dfloat *Bs, dfloat *Bt, dfloat *A) {\n for (int nz=0;nz<mesh->Nq;nz++) {\n for (int ny=0;ny<mesh->Nq;ny++) {\n for (int nx=0;nx<mesh->Nq;nx++) {\n int idn = nx+ny*mesh->Nq+nz*mesh->Nq*mesh->Nq;\n if (elliptic->mapB[idn+eM*mesh->Np]!=1) { \n A[idn] = 0;\n\n int id = nx+ny*mesh->Nq+nz*mesh->Nq*mesh->Nq;\n dlong base = eM*mesh->Np*mesh->Nggeo;\n\n \n dfloat Grs = mesh->ggeo[base + id + G01ID*mesh->Np];\n A[idn] += 2*Grs*mesh->D[nx+nx*mesh->Nq]*mesh->D[ny+ny*mesh->Nq];\n\n dfloat Grt = mesh->ggeo[base + id + G02ID*mesh->Np];\n A[idn] += 2*Grt*mesh->D[nx+nx*mesh->Nq]*mesh->D[nz+nz*mesh->Nq];\n \n dfloat Gst = mesh->ggeo[base + id + G12ID*mesh->Np];\n A[idn] += 2*Gst*mesh->D[ny+ny*mesh->Nq]*mesh->D[nz+nz*mesh->Nq];\n\n for (int k=0;k<mesh->Nq;k++) {\n int iid = k+ny*mesh->Nq+nz*mesh->Nq*mesh->Nq;\n dfloat Grr = mesh->ggeo[base + iid + G00ID*mesh->Np];\n A[idn] += Grr*mesh->D[nx+k*mesh->Nq]*mesh->D[nx+k*mesh->Nq];\n }\n\n for (int k=0;k<mesh->Nq;k++) {\n int iid = nx+k*mesh->Nq+nz*mesh->Nq*mesh->Nq;\n dfloat Gss = mesh->ggeo[base + iid + G11ID*mesh->Np];\n A[idn] += Gss*mesh->D[ny+k*mesh->Nq]*mesh->D[ny+k*mesh->Nq];\n }\n \n for (int k=0;k<mesh->Nq;k++) {\n int iid = nx+ny*mesh->Nq+k*mesh->Nq*mesh->Nq;\n dfloat Gtt = mesh->ggeo[base + iid + G22ID*mesh->Np];\n A[idn] += Gtt*mesh->D[nz+k*mesh->Nq]*mesh->D[nz+k*mesh->Nq];\n }\n \n dfloat JW = mesh->ggeo[base + id + GWJID*mesh->Np];\n A[idn] += JW*lambda;\n } else {\n A[idn] = 1; //just put a 1 so A is invertable\n }\n }\n }\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n } \n }\n }\n}\n"},"no_omp_formatted":{"kind":"string","value":"\n\n#include \"elliptic.h\"\n\nvoid BuildLocalIpdgBBDiagTri2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A);\nvoid BuildLocalIpdgDiagTri2D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A);\nvoid BuildLocalIpdgDiagQuad2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dfloat *B, dfloat *Br, dfloat *Bs, dlong eM, dfloat *A);\nvoid BuildLocalIpdgDiagTet3D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A);\nvoid BuildLocalIpdgDiagHex3D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dfloat *B, dfloat *Br, dfloat *Bs, dfloat *Bt, dlong eM, dfloat *A);\n\nvoid BuildLocalContinuousDiagTri2D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *A);\nvoid BuildLocalContinuousDiagQuad2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *B, dfloat *Br, dfloat *Bs, dfloat *A);\nvoid BuildLocalContinuousDiagTet3D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *A);\nvoid BuildLocalContinuousDiagHex3D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *B, dfloat *Br, dfloat *Bs, dfloat *Bt, dfloat *A);\n\nvoid ellipticBuildJacobi(elliptic_t* elliptic, dfloat lambda, dfloat **invDiagA){\n\n mesh_t *mesh = elliptic->mesh;\n setupAide options = elliptic->options;\n\n // surface mass matrices MS = MM*LIFT\n dfloat *MS = (dfloat *) calloc(mesh->Nfaces*mesh->Nfp*mesh->Nfp,sizeof(dfloat));\n for (int f=0;f<mesh->Nfaces;f++) {\n for (int n=0;n<mesh->Nfp;n++) {\n int fn = mesh->faceNodes[f*mesh->Nfp+n];\n\n for (int m=0;m<mesh->Nfp;m++) {\n dfloat MSnm = 0;\n\n for (int i=0;i<mesh->Np;i++){\n MSnm += mesh->MM[fn+i*mesh->Np]*mesh->LIFT[i*mesh->Nfp*mesh->Nfaces+f*mesh->Nfp+m];\n }\n\n MS[m+n*mesh->Nfp + f*mesh->Nfp*mesh->Nfp] = MSnm;\n }\n }\n }\n\n // build some monolithic basis arrays (for quads and hexes)\n dfloat *B = (dfloat*) calloc(mesh->Np*mesh->Np, sizeof(dfloat));\n dfloat *Br = (dfloat*) calloc(mesh->Np*mesh->Np, sizeof(dfloat));\n dfloat *Bs = (dfloat*) calloc(mesh->Np*mesh->Np, sizeof(dfloat));\n dfloat *Bt = (dfloat*) calloc(mesh->Np*mesh->Np, sizeof(dfloat));\n\n if (elliptic->elementType==QUADRILATERALS) {\n int mode = 0;\n for(int nj=0;nj<mesh->N+1;++nj){\n for(int ni=0;ni<mesh->N+1;++ni){\n\n int node = 0;\n\n for(int j=0;j<mesh->N+1;++j){\n for(int i=0;i<mesh->N+1;++i){\n\n if(nj==j && ni==i)\n B[mode*mesh->Np+node] = 1;\n if(nj==j)\n Br[mode*mesh->Np+node] = mesh->D[ni+mesh->Nq*i]; \n if(ni==i)\n Bs[mode*mesh->Np+node] = mesh->D[nj+mesh->Nq*j]; \n \n ++node;\n }\n }\n ++mode;\n }\n }\n }\n\n if (elliptic->elementType==HEXAHEDRA) {\n int mode = 0;\n for(int nk=0;nk<mesh->N+1;++nk){\n for(int nj=0;nj<mesh->N+1;++nj){\n for(int ni=0;ni<mesh->N+1;++ni){\n\n int node = 0;\n\n for(int k=0;k<mesh->N+1;++k){\n for(int j=0;j<mesh->N+1;++j){\n for(int i=0;i<mesh->N+1;++i){\n\n if(nk==k && nj==j && ni==i)\n B[mode*mesh->Np+node] = 1;\n if(nj==j && nk==k)\n Br[mode*mesh->Np+node] = mesh->D[ni+mesh->Nq*i]; \n if(ni==i && nk==k)\n Bs[mode*mesh->Np+node] = mesh->D[nj+mesh->Nq*j]; \n if(ni==i && nj==j)\n Bt[mode*mesh->Np+node] = mesh->D[nk+mesh->Nq*k]; \n \n ++node;\n }\n }\n }\n \n ++mode;\n }\n }\n }\n }\n\n\n\n dlong diagNnum = mesh->Np*mesh->Nelements;\n\n dfloat *diagA = (dfloat*) calloc(diagNnum, sizeof(dfloat));\n\n if(mesh->rank==0) printf(\"Building diagonal...\");fflush(stdout);\n\n if (options.compareArgs(\"DISCRETIZATION\",\"IPDG\")) {\n switch(elliptic->elementType){\n case TRIANGLES: \n if (options.compareArgs(\"BASIS\",\"BERN\")) {\n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalIpdgBBDiagTri2D(elliptic, mesh, lambda, MS, eM, diagA + eM*mesh->Np); \n } else {\n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalIpdgDiagTri2D(elliptic, mesh, lambda, MS, eM, diagA + eM*mesh->Np); \n } \n break;\n case QUADRILATERALS:\n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalIpdgDiagQuad2D(elliptic, mesh, lambda, MS, B, Br, Bs, eM, diagA + eM*mesh->Np);\n break;\n case TETRAHEDRA:\n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalIpdgDiagTet3D(elliptic, mesh, lambda, MS, eM, diagA + eM*mesh->Np); \n break;\n case HEXAHEDRA:\n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalIpdgDiagHex3D(elliptic, mesh, lambda, MS, B, Br, Bs, Bt, eM, diagA + eM*mesh->Np); \n break;\n }\n } else if (options.compareArgs(\"DISCRETIZATION\",\"CONTINUOUS\")) {\n switch(elliptic->elementType){\n case TRIANGLES:\n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalContinuousDiagTri2D(elliptic, mesh, lambda, eM, diagA + eM*mesh->Np);\n break;\n case QUADRILATERALS:\n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalContinuousDiagQuad2D(elliptic, mesh, lambda, eM, B, Br, Bs, diagA + eM*mesh->Np);\n break;\n case TETRAHEDRA:\n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalContinuousDiagTet3D(elliptic, mesh, lambda, eM, diagA + eM*mesh->Np);\n break;\n case HEXAHEDRA:\n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalContinuousDiagHex3D(elliptic, mesh, lambda, eM, B, Br, Bs, Bt, diagA + eM*mesh->Np);\n break;\n }\n }\n\n if (options.compareArgs(\"DISCRETIZATION\",\"CONTINUOUS\")) \n gsParallelGatherScatter(mesh->hostGsh, diagA, dfloatString, \"add\"); \n \n *invDiagA = (dfloat*) calloc(diagNnum, sizeof(dfloat));\n for (dlong n=0;n<mesh->Nelements*mesh->Np;n++) {\n (*invDiagA)[n] = 1/diagA[n];\n }\n\n if(mesh->rank==0) printf(\"done.\\n\");\n\n free(diagA);\n free(MS);\n free(B); free(Br); free(Bs); free(Bt);\n}\n\nvoid BuildLocalIpdgDiagTri2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A) {\n\n dlong vbase = eM*mesh->Nvgeo;\n dfloat drdx = mesh->vgeo[vbase+RXID];\n dfloat drdy = mesh->vgeo[vbase+RYID];\n dfloat dsdx = mesh->vgeo[vbase+SXID];\n dfloat dsdy = mesh->vgeo[vbase+SYID];\n dfloat J = mesh->vgeo[vbase+JID];\n\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n A[n] = J*lambda*mesh->MM[n*mesh->Np+n];\n A[n] += J*drdx*drdx*mesh->Srr[n*mesh->Np+n];\n A[n] += J*drdx*dsdx*mesh->Srs[n*mesh->Np+n];\n A[n] += J*dsdx*drdx*mesh->Ssr[n*mesh->Np+n];\n A[n] += J*dsdx*dsdx*mesh->Sss[n*mesh->Np+n];\n A[n] += J*drdy*drdy*mesh->Srr[n*mesh->Np+n];\n A[n] += J*drdy*dsdy*mesh->Srs[n*mesh->Np+n];\n A[n] += J*dsdy*drdy*mesh->Ssr[n*mesh->Np+n];\n A[n] += J*dsdy*dsdy*mesh->Sss[n*mesh->Np+n];\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n }\n }\n\n for (int fM=0;fM<mesh->Nfaces;fM++) {\n // load surface geofactors for this face\n dlong sid = mesh->Nsgeo*(eM*mesh->Nfaces+fM);\n dfloat nx = mesh->sgeo[sid+NXID];\n dfloat ny = mesh->sgeo[sid+NYID];\n dfloat sJ = mesh->sgeo[sid+SJID];\n dfloat hinv = mesh->sgeo[sid+IHID];\n\n int bc = mesh->EToB[fM+mesh->Nfaces*eM]; //raw boundary flag\n\n dfloat penalty = elliptic->tau*hinv;\n\n int bcD = 0, bcN =0;\n int bcType = 0;\n\n if(bc>0) bcType = elliptic->BCType[bc]; //find its type (Dirichlet/Neumann)\n\n // this needs to be double checked (and the code where these are used)\n if(bcType==1){ // Dirichlet\n bcD = 1;\n bcN = 0;\n } else if(bcType==2){ // Neumann\n bcD = 0;\n bcN = 1;\n }\n\n // mass matrix for this face\n dfloat *MSf = MS+fM*mesh->Nfp*mesh->Nfp;\n\n // penalty term just involves face nodes\n for(int n=0;n<mesh->Nfp;++n){\n int nM = mesh->faceNodes[fM*mesh->Nfp+n];\n \n for(int m=0;m<mesh->Nfp;++m){\n int mM = mesh->faceNodes[fM*mesh->Nfp+m];\n if (mM == nM) {\n // OP11 = OP11 + 0.5*( gtau*mmE )\n dfloat MSfnm = sJ*MSf[n*mesh->Nfp+m];\n A[nM] += 0.5*(1.-bcN)*(1.+bcD)*penalty*MSfnm;\n }\n }\n }\n\n // now add differential surface terms\n for(int n=0;n<mesh->Nfp;++n){\n int nM = mesh->faceNodes[fM*mesh->Nfp+n];\n\n for(int i=0;i<mesh->Nfp;++i){\n int iM = mesh->faceNodes[fM*mesh->Nfp+i];\n\n dfloat MSfni = sJ*MSf[n*mesh->Nfp+i]; // surface Jacobian built in\n\n dfloat DxMim = drdx*mesh->Dr[iM*mesh->Np+nM] + dsdx*mesh->Ds[iM*mesh->Np+nM];\n dfloat DyMim = drdy*mesh->Dr[iM*mesh->Np+nM] + dsdy*mesh->Ds[iM*mesh->Np+nM];\n\n // OP11 = OP11 + 0.5*( - mmE*Dn1)\n A[nM] += -0.5*nx*(1+bcD)*(1-bcN)*MSfni*DxMim;\n A[nM] += -0.5*ny*(1+bcD)*(1-bcN)*MSfni*DyMim;\n }\n }\n\n for(int n=0;n<mesh->Np;++n){\n for(int m=0;m<mesh->Nfp;++m){\n int mM = mesh->faceNodes[fM*mesh->Nfp+m];\n\n if (mM==n) {\n for(int i=0;i<mesh->Nfp;++i){\n int iM = mesh->faceNodes[fM*mesh->Nfp+i];\n\n dfloat MSfim = sJ*MSf[i*mesh->Nfp+m];\n\n dfloat DxMin = drdx*mesh->Dr[iM*mesh->Np+n] + dsdx*mesh->Ds[iM*mesh->Np+n];\n dfloat DyMin = drdy*mesh->Dr[iM*mesh->Np+n] + dsdy*mesh->Ds[iM*mesh->Np+n];\n\n // OP11 = OP11 + (- Dn1'*mmE );\n A[n] += -0.5*nx*(1+bcD)*(1-bcN)*DxMin*MSfim;\n A[n] += -0.5*ny*(1+bcD)*(1-bcN)*DyMin*MSfim;\n }\n }\n }\n }\n }\n}\n\nvoid BuildLocalIpdgPatchAxTri2D(elliptic_t* elliptic, mesh_t* mesh, int basisNp, dfloat *basis, dfloat lambda,\n dfloat *MS, dlong eM, dfloat *A);\n\n//generate the BB diagonal by extracting it from the transformed patch\nvoid BuildLocalIpdgBBDiagTri2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A) {\n\n dfloat *patchA = (dfloat *) calloc(mesh->Np*mesh->Np,sizeof(dfloat));\n\n int basisNp = mesh->Np;\n dfloat *basis = mesh->VB;\n\n BuildLocalIpdgPatchAxTri2D(elliptic, mesh, basisNp, basis, lambda, MS, eM, patchA);\n\n for(int n=0;n<mesh->Np;++n) {\n A[n] = patchA[n*mesh->Np+n]; //store the diagonal entry\n }\n free(patchA);\n}\n\n//returns the continuous C0 patch A matrix for element eM\nvoid BuildLocalContinuousDiagTri2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *A) {\n\n dlong gbase = eM*mesh->Nggeo;\n dfloat Grr = mesh->ggeo[gbase + G00ID];\n dfloat Grs = mesh->ggeo[gbase + G01ID];\n dfloat Gss = mesh->ggeo[gbase + G11ID];\n dfloat J = mesh->ggeo[gbase + GWJID];\n\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] = J*lambda*mesh->MM[n+n*mesh->Np];\n A[n] += Grr*mesh->Srr[n+n*mesh->Np];\n A[n] += Grs*mesh->Srs[n+n*mesh->Np];\n A[n] += Grs*mesh->Ssr[n+n*mesh->Np];\n A[n] += Gss*mesh->Sss[n+n*mesh->Np];\n } else {\n A[n] = 1; //just put a 1 so A is invertable\n }\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n } \n }\n }\n}\n\nvoid BuildLocalIpdgDiagQuad2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dfloat *B, dfloat *Br, dfloat *Bs, dlong eM, dfloat *A) {\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n A[n] = 0;\n\n // (grad phi_n, grad phi_m)_{D^e}\n for(int i=0;i<mesh->Np;++i){\n dlong base = eM*mesh->Np*mesh->Nvgeo + i;\n dfloat drdx = mesh->vgeo[base+mesh->Np*RXID];\n dfloat drdy = mesh->vgeo[base+mesh->Np*RYID];\n dfloat dsdx = mesh->vgeo[base+mesh->Np*SXID];\n dfloat dsdy = mesh->vgeo[base+mesh->Np*SYID];\n dfloat JW = mesh->vgeo[base+mesh->Np*JWID];\n \n int idn = n*mesh->Np+i;\n dfloat dlndx = drdx*Br[idn] + dsdx*Bs[idn];\n dfloat dlndy = drdy*Br[idn] + dsdy*Bs[idn];\n A[n] += JW*(dlndx*dlndx+dlndy*dlndy);\n A[n] += lambda*JW*B[idn]*B[idn];\n }\n\n for (int fM=0;fM<mesh->Nfaces;fM++) {\n // accumulate flux terms for negative and positive traces\n for(int i=0;i<mesh->Nfp;++i){\n int vidM = mesh->faceNodes[i+fM*mesh->Nfp];\n\n // grab vol geofacs at surface nodes\n dlong baseM = eM*mesh->Np*mesh->Nvgeo + vidM;\n dfloat drdxM = mesh->vgeo[baseM+mesh->Np*RXID];\n dfloat drdyM = mesh->vgeo[baseM+mesh->Np*RYID];\n dfloat dsdxM = mesh->vgeo[baseM+mesh->Np*SXID];\n dfloat dsdyM = mesh->vgeo[baseM+mesh->Np*SYID];\n\n // grab surface geometric factors\n dlong base = mesh->Nsgeo*(eM*mesh->Nfp*mesh->Nfaces + fM*mesh->Nfp + i);\n dfloat nx = mesh->sgeo[base+NXID];\n dfloat ny = mesh->sgeo[base+NYID];\n dfloat wsJ = mesh->sgeo[base+WSJID];\n dfloat hinv = mesh->sgeo[base+IHID];\n \n // form negative trace terms in IPDG\n int idnM = n*mesh->Np+vidM; \n\n dfloat dlndxM = drdxM*Br[idnM] + dsdxM*Bs[idnM];\n dfloat dlndyM = drdyM*Br[idnM] + dsdyM*Bs[idnM];\n dfloat ndotgradlnM = nx*dlndxM+ny*dlndyM;\n dfloat lnM = B[idnM];\n \n dfloat penalty = elliptic->tau*hinv; \n int bc = mesh->EToB[fM+mesh->Nfaces*eM]; //raw boundary flag\n\n int bcD = 0, bcN =0;\n int bcType = 0;\n\n if(bc>0) bcType = elliptic->BCType[bc]; //find its type (Dirichlet/Neumann)\n\n // this needs to be double checked (and the code where these are used)\n if(bcType==1){ // Dirichlet\n bcD = 1;\n bcN = 0;\n } else if(bcType==2){ // Neumann\n bcD = 0;\n bcN = 1;\n } \n\n A[n] += -0.5*(1+bcD)*(1-bcN)*wsJ*lnM*ndotgradlnM; // -(ln^-, N.grad lm^-)\n A[n] += -0.5*(1+bcD)*(1-bcN)*wsJ*ndotgradlnM*lnM; // -(N.grad ln^-, lm^-)\n A[n] += +0.5*(1+bcD)*(1-bcN)*wsJ*penalty*lnM*lnM; // +((tau/h)*ln^-,lm^-)\n }\n }\n }\n}\n\nvoid BuildLocalContinuousDiagQuad2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, \n dfloat *B, dfloat *Br, dfloat* Bs, dfloat *A) {\n\n for (int ny=0;ny<mesh->Nq;ny++) {\n for (int nx=0;nx<mesh->Nq;nx++) {\n int iid = nx+ny*mesh->Nq;\n if (elliptic->mapB[nx+ny*mesh->Nq+eM*mesh->Np]!=1) { \n A[iid] = 0;\n\n for (int k=0;k<mesh->Nq;k++) {\n int id = k+ny*mesh->Nq;\n dfloat Grr = mesh->ggeo[eM*mesh->Np*mesh->Nggeo + id + G00ID*mesh->Np];\n A[iid] += Grr*mesh->D[nx+k*mesh->Nq]*mesh->D[nx+k*mesh->Nq];\n }\n\n for (int k=0;k<mesh->Nq;k++) {\n int id = nx+k*mesh->Nq;\n dfloat Gss = mesh->ggeo[eM*mesh->Np*mesh->Nggeo + id + G11ID*mesh->Np];\n A[iid] += Gss*mesh->D[ny+k*mesh->Nq]*mesh->D[ny+k*mesh->Nq];\n }\n\n int id = nx+ny*mesh->Nq;\n dfloat Grs = mesh->ggeo[eM*mesh->Np*mesh->Nggeo + id + G01ID*mesh->Np];\n A[iid] += 2*Grs*mesh->D[nx+nx*mesh->Nq]*mesh->D[ny+ny*mesh->Nq];\n\n dfloat JW = mesh->ggeo[eM*mesh->Np*mesh->Nggeo + id + GWJID*mesh->Np];\n A[iid] += JW*lambda;\n\n } else {\n A[iid] = 1; //just put a 1 so A is invertable\n }\n }\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n } \n }\n }\n}\n\nvoid BuildLocalIpdgDiagTet3D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A) {\n dlong vbase = eM*mesh->Nvgeo;\n dfloat drdx = mesh->vgeo[vbase+RXID];\n dfloat drdy = mesh->vgeo[vbase+RYID];\n dfloat drdz = mesh->vgeo[vbase+RZID];\n dfloat dsdx = mesh->vgeo[vbase+SXID];\n dfloat dsdy = mesh->vgeo[vbase+SYID];\n dfloat dsdz = mesh->vgeo[vbase+SZID];\n dfloat dtdx = mesh->vgeo[vbase+TXID];\n dfloat dtdy = mesh->vgeo[vbase+TYID];\n dfloat dtdz = mesh->vgeo[vbase+TZID];\n dfloat J = mesh->vgeo[vbase+JID];\n\n dfloat G00 = drdx*drdx + drdy*drdy + drdz*drdz;\n dfloat G01 = drdx*dsdx + drdy*dsdy + drdz*dsdz;\n dfloat G02 = drdx*dtdx + drdy*dtdy + drdz*dtdz;\n\n dfloat G10 = dsdx*drdx + dsdy*drdy + dsdz*drdz;\n dfloat G11 = dsdx*dsdx + dsdy*dsdy + dsdz*dsdz;\n dfloat G12 = dsdx*dtdx + dsdy*dtdy + dsdz*dtdz;\n\n dfloat G20 = dtdx*drdx + dtdy*drdy + dtdz*drdz;\n dfloat G21 = dtdx*dsdx + dtdy*dsdy + dtdz*dsdz;\n dfloat G22 = dtdx*dtdx + dtdy*dtdy + dtdz*dtdz;\n\n\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n A[n] = J*lambda*mesh->MM[n*mesh->Np+n];\n A[n] += J*G00*mesh->Srr[n*mesh->Np+n];\n A[n] += J*G01*mesh->Srs[n*mesh->Np+n];\n A[n] += J*G02*mesh->Srt[n*mesh->Np+n];\n A[n] += J*G10*mesh->Ssr[n*mesh->Np+n];\n A[n] += J*G11*mesh->Sss[n*mesh->Np+n];\n A[n] += J*G12*mesh->Sst[n*mesh->Np+n];\n A[n] += J*G20*mesh->Str[n*mesh->Np+n];\n A[n] += J*G21*mesh->Sts[n*mesh->Np+n];\n A[n] += J*G22*mesh->Stt[n*mesh->Np+n];\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n }\n }\n\n for (int fM=0;fM<mesh->Nfaces;fM++) {\n // load surface geofactors for this face\n dlong sid = mesh->Nsgeo*(eM*mesh->Nfaces+fM);\n dfloat nx = mesh->sgeo[sid+NXID];\n dfloat ny = mesh->sgeo[sid+NYID];\n dfloat nz = mesh->sgeo[sid+NZID];\n dfloat sJ = mesh->sgeo[sid+SJID];\n dfloat hinv = mesh->sgeo[sid+IHID];\n\n int bc = mesh->EToB[fM+mesh->Nfaces*eM]; //raw boundary flag\n\n dfloat penalty = elliptic->tau*hinv;\n\n int bcD = 0, bcN =0;\n int bcType = 0;\n\n if(bc>0) bcType = elliptic->BCType[bc]; //find its type (Dirichlet/Neumann)\n\n // this needs to be double checked (and the code where these are used)\n if(bcType==1){ // Dirichlet\n bcD = 1;\n bcN = 0;\n } else if(bcType==2){ // Neumann\n bcD = 0;\n bcN = 1;\n }\n\n // mass matrix for this face\n dfloat *MSf = MS+fM*mesh->Nfp*mesh->Nfp;\n\n // penalty term just involves face nodes\n for(int n=0;n<mesh->Nfp;++n){\n for(int m=0;m<mesh->Nfp;++m){\n int nM = mesh->faceNodes[fM*mesh->Nfp+n];\n int mM = mesh->faceNodes[fM*mesh->Nfp+m];\n\n if (mM==nM) {\n // OP11 = OP11 + 0.5*( gtau*mmE )\n dfloat MSfnm = sJ*MSf[n*mesh->Nfp+m];\n A[nM] += 0.5*(1.-bcN)*(1.+bcD)*penalty*MSfnm;\n }\n }\n }\n\n // now add differential surface terms\n for(int n=0;n<mesh->Nfp;++n){\n int nM = mesh->faceNodes[fM*mesh->Nfp+n];\n\n for(int i=0;i<mesh->Nfp;++i){\n int iM = mesh->faceNodes[fM*mesh->Nfp+i];\n\n dfloat MSfni = sJ*MSf[n*mesh->Nfp+i]; // surface Jacobian built in\n\n dfloat DxMim = drdx*mesh->Dr[iM*mesh->Np+nM] + dsdx*mesh->Ds[iM*mesh->Np+nM] + dtdx*mesh->Dt[iM*mesh->Np+nM];\n dfloat DyMim = drdy*mesh->Dr[iM*mesh->Np+nM] + dsdy*mesh->Ds[iM*mesh->Np+nM] + dtdy*mesh->Dt[iM*mesh->Np+nM];\n dfloat DzMim = drdz*mesh->Dr[iM*mesh->Np+nM] + dsdz*mesh->Ds[iM*mesh->Np+nM] + dtdz*mesh->Dt[iM*mesh->Np+nM];\n\n // OP11 = OP11 + 0.5*( - mmE*Dn1)\n A[nM] += -0.5*nx*(1+bcD)*(1-bcN)*MSfni*DxMim;\n A[nM] += -0.5*ny*(1+bcD)*(1-bcN)*MSfni*DyMim;\n A[nM] += -0.5*nz*(1+bcD)*(1-bcN)*MSfni*DzMim;\n }\n }\n\n for(int n=0;n<mesh->Np;++n){\n for(int m=0;m<mesh->Nfp;++m){\n int mM = mesh->faceNodes[fM*mesh->Nfp+m];\n\n if (mM==n) {\n for(int i=0;i<mesh->Nfp;++i){\n int iM = mesh->faceNodes[fM*mesh->Nfp+i];\n\n dfloat MSfim = sJ*MSf[i*mesh->Nfp+m];\n\n dfloat DxMin = drdx*mesh->Dr[iM*mesh->Np+n] + dsdx*mesh->Ds[iM*mesh->Np+n] + dtdx*mesh->Dt[iM*mesh->Np+n];\n dfloat DyMin = drdy*mesh->Dr[iM*mesh->Np+n] + dsdy*mesh->Ds[iM*mesh->Np+n] + dtdy*mesh->Dt[iM*mesh->Np+n];\n dfloat DzMin = drdz*mesh->Dr[iM*mesh->Np+n] + dsdz*mesh->Ds[iM*mesh->Np+n] + dtdz*mesh->Dt[iM*mesh->Np+n];\n\n // OP11 = OP11 + (- Dn1'*mmE );\n A[n] += -0.5*nx*(1+bcD)*(1-bcN)*DxMin*MSfim;\n A[n] += -0.5*ny*(1+bcD)*(1-bcN)*DyMin*MSfim;\n A[n] += -0.5*nz*(1+bcD)*(1-bcN)*DzMin*MSfim;\n }\n }\n }\n }\n }\n}\n\nvoid BuildLocalContinuousDiagTet3D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *A) {\n dlong gbase = eM*mesh->Nggeo;\n dfloat Grr = mesh->ggeo[gbase + G00ID];\n dfloat Grs = mesh->ggeo[gbase + G01ID];\n dfloat Grt = mesh->ggeo[gbase + G02ID];\n dfloat Gss = mesh->ggeo[gbase + G11ID];\n dfloat Gst = mesh->ggeo[gbase + G12ID];\n dfloat Gtt = mesh->ggeo[gbase + G22ID];\n dfloat J = mesh->ggeo[gbase + GWJID];\n\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] = J*lambda*mesh->MM[n+n*mesh->Np];\n A[n] += Grr*mesh->Srr[n+n*mesh->Np];\n A[n] += Grs*mesh->Srs[n+n*mesh->Np];\n A[n] += Grt*mesh->Srt[n+n*mesh->Np];\n A[n] += Grs*mesh->Ssr[n+n*mesh->Np];\n A[n] += Gss*mesh->Sss[n+n*mesh->Np];\n A[n] += Gst*mesh->Sst[n+n*mesh->Np];\n A[n] += Grt*mesh->Str[n+n*mesh->Np];\n A[n] += Gst*mesh->Sts[n+n*mesh->Np];\n A[n] += Gtt*mesh->Stt[n+n*mesh->Np];\n } else {\n A[n] = 1; //just put a 1 so A is invertable\n }\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n } \n }\n }\n}\n\nvoid BuildLocalIpdgDiagHex3D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dfloat *B, dfloat *Br, dfloat *Bs, dfloat *Bt, dlong eM, dfloat *A) {\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n A[n] = 0;\n\n // (grad phi_n, grad phi_m)_{D^e}\n for(int i=0;i<mesh->Np;++i){\n dlong base = eM*mesh->Np*mesh->Nvgeo + i;\n dfloat drdx = mesh->vgeo[base+mesh->Np*RXID];\n dfloat drdy = mesh->vgeo[base+mesh->Np*RYID];\n dfloat drdz = mesh->vgeo[base+mesh->Np*RZID];\n dfloat dsdx = mesh->vgeo[base+mesh->Np*SXID];\n dfloat dsdy = mesh->vgeo[base+mesh->Np*SYID];\n dfloat dsdz = mesh->vgeo[base+mesh->Np*SZID];\n dfloat dtdx = mesh->vgeo[base+mesh->Np*TXID];\n dfloat dtdy = mesh->vgeo[base+mesh->Np*TYID];\n dfloat dtdz = mesh->vgeo[base+mesh->Np*TZID];\n dfloat JW = mesh->vgeo[base+mesh->Np*JWID];\n \n int idn = n*mesh->Np+i;\n dfloat dlndx = drdx*Br[idn] + dsdx*Bs[idn] + dtdx*Bt[idn];\n dfloat dlndy = drdy*Br[idn] + dsdy*Bs[idn] + dtdy*Bt[idn];\n dfloat dlndz = drdz*Br[idn] + dsdz*Bs[idn] + dtdz*Bt[idn]; \n A[n] += JW*(dlndx*dlndx+dlndy*dlndy+dlndz*dlndz);\n A[n] += lambda*JW*B[idn]*B[idn];\n }\n\n for (int fM=0;fM<mesh->Nfaces;fM++) {\n // accumulate flux terms for negative and positive traces\n for(int i=0;i<mesh->Nfp;++i){\n int vidM = mesh->faceNodes[i+fM*mesh->Nfp];\n\n // grab vol geofacs at surface nodes\n dlong baseM = eM*mesh->Np*mesh->Nvgeo + vidM;\n dfloat drdxM = mesh->vgeo[baseM+mesh->Np*RXID];\n dfloat drdyM = mesh->vgeo[baseM+mesh->Np*RYID];\n dfloat drdzM = mesh->vgeo[baseM+mesh->Np*RZID];\n dfloat dsdxM = mesh->vgeo[baseM+mesh->Np*SXID];\n dfloat dsdyM = mesh->vgeo[baseM+mesh->Np*SYID];\n dfloat dsdzM = mesh->vgeo[baseM+mesh->Np*SZID];\n dfloat dtdxM = mesh->vgeo[baseM+mesh->Np*TXID];\n dfloat dtdyM = mesh->vgeo[baseM+mesh->Np*TYID];\n dfloat dtdzM = mesh->vgeo[baseM+mesh->Np*TZID];\n\n // grab surface geometric factors\n dlong base = mesh->Nsgeo*(eM*mesh->Nfp*mesh->Nfaces + fM*mesh->Nfp + i);\n dfloat nx = mesh->sgeo[base+NXID];\n dfloat ny = mesh->sgeo[base+NYID];\n dfloat nz = mesh->sgeo[base+NZID];\n dfloat wsJ = mesh->sgeo[base+WSJID];\n dfloat hinv = mesh->sgeo[base+IHID];\n \n // form negative trace terms in IPDG\n int idnM = n*mesh->Np+vidM; \n dfloat dlndxM = drdxM*Br[idnM] + dsdxM*Bs[idnM] + dtdxM*Bt[idnM];\n dfloat dlndyM = drdyM*Br[idnM] + dsdyM*Bs[idnM] + dtdyM*Bt[idnM];\n dfloat dlndzM = drdzM*Br[idnM] + dsdzM*Bs[idnM] + dtdzM*Bt[idnM];\n dfloat ndotgradlnM = nx*dlndxM+ny*dlndyM+nz*dlndzM;\n dfloat lnM = B[idnM];\n \n dfloat penalty = elliptic->tau*hinv; \n int bc = mesh->EToB[fM+mesh->Nfaces*eM]; //raw boundary flag\n\n int bcD = 0, bcN =0;\n int bcType = 0;\n\n if(bc>0) bcType = elliptic->BCType[bc]; //find its type (Dirichlet/Neumann)\n\n // this needs to be double checked (and the code where these are used)\n if(bcType==1){ // Dirichlet\n bcD = 1;\n bcN = 0;\n } else if(bcType==2){ // Neumann\n bcD = 0;\n bcN = 1;\n } \n\n A[n] += -0.5*(1+bcD)*(1-bcN)*wsJ*lnM*ndotgradlnM; // -(ln^-, N.grad lm^-)\n A[n] += -0.5*(1+bcD)*(1-bcN)*wsJ*ndotgradlnM*lnM; // -(N.grad ln^-, lm^-)\n A[n] += +0.5*(1+bcD)*(1-bcN)*wsJ*penalty*lnM*lnM; // +((tau/h)*ln^-,lm^-)\n }\n }\n }\n}\n\nvoid BuildLocalContinuousDiagHex3D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *B, dfloat *Br, dfloat *Bs, dfloat *Bt, dfloat *A) {\n for (int nz=0;nz<mesh->Nq;nz++) {\n for (int ny=0;ny<mesh->Nq;ny++) {\n for (int nx=0;nx<mesh->Nq;nx++) {\n int idn = nx+ny*mesh->Nq+nz*mesh->Nq*mesh->Nq;\n if (elliptic->mapB[idn+eM*mesh->Np]!=1) { \n A[idn] = 0;\n\n int id = nx+ny*mesh->Nq+nz*mesh->Nq*mesh->Nq;\n dlong base = eM*mesh->Np*mesh->Nggeo;\n\n \n dfloat Grs = mesh->ggeo[base + id + G01ID*mesh->Np];\n A[idn] += 2*Grs*mesh->D[nx+nx*mesh->Nq]*mesh->D[ny+ny*mesh->Nq];\n\n dfloat Grt = mesh->ggeo[base + id + G02ID*mesh->Np];\n A[idn] += 2*Grt*mesh->D[nx+nx*mesh->Nq]*mesh->D[nz+nz*mesh->Nq];\n \n dfloat Gst = mesh->ggeo[base + id + G12ID*mesh->Np];\n A[idn] += 2*Gst*mesh->D[ny+ny*mesh->Nq]*mesh->D[nz+nz*mesh->Nq];\n\n for (int k=0;k<mesh->Nq;k++) {\n int iid = k+ny*mesh->Nq+nz*mesh->Nq*mesh->Nq;\n dfloat Grr = mesh->ggeo[base + iid + G00ID*mesh->Np];\n A[idn] += Grr*mesh->D[nx+k*mesh->Nq]*mesh->D[nx+k*mesh->Nq];\n }\n\n for (int k=0;k<mesh->Nq;k++) {\n int iid = nx+k*mesh->Nq+nz*mesh->Nq*mesh->Nq;\n dfloat Gss = mesh->ggeo[base + iid + G11ID*mesh->Np];\n A[idn] += Gss*mesh->D[ny+k*mesh->Nq]*mesh->D[ny+k*mesh->Nq];\n }\n \n for (int k=0;k<mesh->Nq;k++) {\n int iid = nx+ny*mesh->Nq+k*mesh->Nq*mesh->Nq;\n dfloat Gtt = mesh->ggeo[base + iid + G22ID*mesh->Np];\n A[idn] += Gtt*mesh->D[nz+k*mesh->Nq]*mesh->D[nz+k*mesh->Nq];\n }\n \n dfloat JW = mesh->ggeo[base + id + GWJID*mesh->Np];\n A[idn] += JW*lambda;\n } else {\n A[idn] = 1; //just put a 1 so A is invertable\n }\n }\n }\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n } \n }\n }\n}\n"},"omp_formatted":{"kind":"string","value":"\n\n#include \"elliptic.h\"\n\nvoid BuildLocalIpdgBBDiagTri2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A);\nvoid BuildLocalIpdgDiagTri2D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A);\nvoid BuildLocalIpdgDiagQuad2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dfloat *B, dfloat *Br, dfloat *Bs, dlong eM, dfloat *A);\nvoid BuildLocalIpdgDiagTet3D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A);\nvoid BuildLocalIpdgDiagHex3D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dfloat *B, dfloat *Br, dfloat *Bs, dfloat *Bt, dlong eM, dfloat *A);\n\nvoid BuildLocalContinuousDiagTri2D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *A);\nvoid BuildLocalContinuousDiagQuad2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *B, dfloat *Br, dfloat *Bs, dfloat *A);\nvoid BuildLocalContinuousDiagTet3D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *A);\nvoid BuildLocalContinuousDiagHex3D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *B, dfloat *Br, dfloat *Bs, dfloat *Bt, dfloat *A);\n\nvoid ellipticBuildJacobi(elliptic_t* elliptic, dfloat lambda, dfloat **invDiagA){\n\n mesh_t *mesh = elliptic->mesh;\n setupAide options = elliptic->options;\n\n // surface mass matrices MS = MM*LIFT\n dfloat *MS = (dfloat *) calloc(mesh->Nfaces*mesh->Nfp*mesh->Nfp,sizeof(dfloat));\n for (int f=0;f<mesh->Nfaces;f++) {\n for (int n=0;n<mesh->Nfp;n++) {\n int fn = mesh->faceNodes[f*mesh->Nfp+n];\n\n for (int m=0;m<mesh->Nfp;m++) {\n dfloat MSnm = 0;\n\n for (int i=0;i<mesh->Np;i++){\n MSnm += mesh->MM[fn+i*mesh->Np]*mesh->LIFT[i*mesh->Nfp*mesh->Nfaces+f*mesh->Nfp+m];\n }\n\n MS[m+n*mesh->Nfp + f*mesh->Nfp*mesh->Nfp] = MSnm;\n }\n }\n }\n\n // build some monolithic basis arrays (for quads and hexes)\n dfloat *B = (dfloat*) calloc(mesh->Np*mesh->Np, sizeof(dfloat));\n dfloat *Br = (dfloat*) calloc(mesh->Np*mesh->Np, sizeof(dfloat));\n dfloat *Bs = (dfloat*) calloc(mesh->Np*mesh->Np, sizeof(dfloat));\n dfloat *Bt = (dfloat*) calloc(mesh->Np*mesh->Np, sizeof(dfloat));\n\n if (elliptic->elementType==QUADRILATERALS) {\n int mode = 0;\n for(int nj=0;nj<mesh->N+1;++nj){\n for(int ni=0;ni<mesh->N+1;++ni){\n\n int node = 0;\n\n for(int j=0;j<mesh->N+1;++j){\n for(int i=0;i<mesh->N+1;++i){\n\n if(nj==j && ni==i)\n B[mode*mesh->Np+node] = 1;\n if(nj==j)\n Br[mode*mesh->Np+node] = mesh->D[ni+mesh->Nq*i]; \n if(ni==i)\n Bs[mode*mesh->Np+node] = mesh->D[nj+mesh->Nq*j]; \n \n ++node;\n }\n }\n ++mode;\n }\n }\n }\n\n if (elliptic->elementType==HEXAHEDRA) {\n int mode = 0;\n for(int nk=0;nk<mesh->N+1;++nk){\n for(int nj=0;nj<mesh->N+1;++nj){\n for(int ni=0;ni<mesh->N+1;++ni){\n\n int node = 0;\n\n for(int k=0;k<mesh->N+1;++k){\n for(int j=0;j<mesh->N+1;++j){\n for(int i=0;i<mesh->N+1;++i){\n\n if(nk==k && nj==j && ni==i)\n B[mode*mesh->Np+node] = 1;\n if(nj==j && nk==k)\n Br[mode*mesh->Np+node] = mesh->D[ni+mesh->Nq*i]; \n if(ni==i && nk==k)\n Bs[mode*mesh->Np+node] = mesh->D[nj+mesh->Nq*j]; \n if(ni==i && nj==j)\n Bt[mode*mesh->Np+node] = mesh->D[nk+mesh->Nq*k]; \n \n ++node;\n }\n }\n }\n \n ++mode;\n }\n }\n }\n }\n\n\n\n dlong diagNnum = mesh->Np*mesh->Nelements;\n\n dfloat *diagA = (dfloat*) calloc(diagNnum, sizeof(dfloat));\n\n if(mesh->rank==0) printf(\"Building diagonal...\");fflush(stdout);\n\n if (options.compareArgs(\"DISCRETIZATION\",\"IPDG\")) {\n switch(elliptic->elementType){\n case TRIANGLES: \n if (options.compareArgs(\"BASIS\",\"BERN\")) {\n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalIpdgBBDiagTri2D(elliptic, mesh, lambda, MS, eM, diagA + eM*mesh->Np); \n } else {\n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalIpdgDiagTri2D(elliptic, mesh, lambda, MS, eM, diagA + eM*mesh->Np); \n } \n break;\n case QUADRILATERALS:\n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalIpdgDiagQuad2D(elliptic, mesh, lambda, MS, B, Br, Bs, eM, diagA + eM*mesh->Np);\n break;\n case TETRAHEDRA:\n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalIpdgDiagTet3D(elliptic, mesh, lambda, MS, eM, diagA + eM*mesh->Np); \n break;\n case HEXAHEDRA:\n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalIpdgDiagHex3D(elliptic, mesh, lambda, MS, B, Br, Bs, Bt, eM, diagA + eM*mesh->Np); \n break;\n }\n } else if (options.compareArgs(\"DISCRETIZATION\",\"CONTINUOUS\")) {\n switch(elliptic->elementType){\n case TRIANGLES: \n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalContinuousDiagTri2D(elliptic, mesh, lambda, eM, diagA + eM*mesh->Np);\n break;\n case QUADRILATERALS:\n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalContinuousDiagQuad2D(elliptic, mesh, lambda, eM, B, Br, Bs, diagA + eM*mesh->Np);\n break;\n case TETRAHEDRA:\n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalContinuousDiagTet3D(elliptic, mesh, lambda, eM, diagA + eM*mesh->Np);\n break;\n case HEXAHEDRA:\n #pragma omp parallel for \n for(dlong eM=0;eM<mesh->Nelements;++eM)\n BuildLocalContinuousDiagHex3D(elliptic, mesh, lambda, eM, B, Br, Bs, Bt, diagA + eM*mesh->Np);\n break;\n }\n }\n\n if (options.compareArgs(\"DISCRETIZATION\",\"CONTINUOUS\")) \n gsParallelGatherScatter(mesh->hostGsh, diagA, dfloatString, \"add\"); \n \n *invDiagA = (dfloat*) calloc(diagNnum, sizeof(dfloat));\n for (dlong n=0;n<mesh->Nelements*mesh->Np;n++) {\n (*invDiagA)[n] = 1/diagA[n];\n }\n\n if(mesh->rank==0) printf(\"done.\\n\");\n\n free(diagA);\n free(MS);\n free(B); free(Br); free(Bs); free(Bt);\n}\n\nvoid BuildLocalIpdgDiagTri2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A) {\n\n dlong vbase = eM*mesh->Nvgeo;\n dfloat drdx = mesh->vgeo[vbase+RXID];\n dfloat drdy = mesh->vgeo[vbase+RYID];\n dfloat dsdx = mesh->vgeo[vbase+SXID];\n dfloat dsdy = mesh->vgeo[vbase+SYID];\n dfloat J = mesh->vgeo[vbase+JID];\n\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n A[n] = J*lambda*mesh->MM[n*mesh->Np+n];\n A[n] += J*drdx*drdx*mesh->Srr[n*mesh->Np+n];\n A[n] += J*drdx*dsdx*mesh->Srs[n*mesh->Np+n];\n A[n] += J*dsdx*drdx*mesh->Ssr[n*mesh->Np+n];\n A[n] += J*dsdx*dsdx*mesh->Sss[n*mesh->Np+n];\n A[n] += J*drdy*drdy*mesh->Srr[n*mesh->Np+n];\n A[n] += J*drdy*dsdy*mesh->Srs[n*mesh->Np+n];\n A[n] += J*dsdy*drdy*mesh->Ssr[n*mesh->Np+n];\n A[n] += J*dsdy*dsdy*mesh->Sss[n*mesh->Np+n];\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n }\n }\n\n for (int fM=0;fM<mesh->Nfaces;fM++) {\n // load surface geofactors for this face\n dlong sid = mesh->Nsgeo*(eM*mesh->Nfaces+fM);\n dfloat nx = mesh->sgeo[sid+NXID];\n dfloat ny = mesh->sgeo[sid+NYID];\n dfloat sJ = mesh->sgeo[sid+SJID];\n dfloat hinv = mesh->sgeo[sid+IHID];\n\n int bc = mesh->EToB[fM+mesh->Nfaces*eM]; //raw boundary flag\n\n dfloat penalty = elliptic->tau*hinv;\n\n int bcD = 0, bcN =0;\n int bcType = 0;\n\n if(bc>0) bcType = elliptic->BCType[bc]; //find its type (Dirichlet/Neumann)\n\n // this needs to be double checked (and the code where these are used)\n if(bcType==1){ // Dirichlet\n bcD = 1;\n bcN = 0;\n } else if(bcType==2){ // Neumann\n bcD = 0;\n bcN = 1;\n }\n\n // mass matrix for this face\n dfloat *MSf = MS+fM*mesh->Nfp*mesh->Nfp;\n\n // penalty term just involves face nodes\n for(int n=0;n<mesh->Nfp;++n){\n int nM = mesh->faceNodes[fM*mesh->Nfp+n];\n \n for(int m=0;m<mesh->Nfp;++m){\n int mM = mesh->faceNodes[fM*mesh->Nfp+m];\n if (mM == nM) {\n // OP11 = OP11 + 0.5*( gtau*mmE )\n dfloat MSfnm = sJ*MSf[n*mesh->Nfp+m];\n A[nM] += 0.5*(1.-bcN)*(1.+bcD)*penalty*MSfnm;\n }\n }\n }\n\n // now add differential surface terms\n for(int n=0;n<mesh->Nfp;++n){\n int nM = mesh->faceNodes[fM*mesh->Nfp+n];\n\n for(int i=0;i<mesh->Nfp;++i){\n int iM = mesh->faceNodes[fM*mesh->Nfp+i];\n\n dfloat MSfni = sJ*MSf[n*mesh->Nfp+i]; // surface Jacobian built in\n\n dfloat DxMim = drdx*mesh->Dr[iM*mesh->Np+nM] + dsdx*mesh->Ds[iM*mesh->Np+nM];\n dfloat DyMim = drdy*mesh->Dr[iM*mesh->Np+nM] + dsdy*mesh->Ds[iM*mesh->Np+nM];\n\n // OP11 = OP11 + 0.5*( - mmE*Dn1)\n A[nM] += -0.5*nx*(1+bcD)*(1-bcN)*MSfni*DxMim;\n A[nM] += -0.5*ny*(1+bcD)*(1-bcN)*MSfni*DyMim;\n }\n }\n\n for(int n=0;n<mesh->Np;++n){\n for(int m=0;m<mesh->Nfp;++m){\n int mM = mesh->faceNodes[fM*mesh->Nfp+m];\n\n if (mM==n) {\n for(int i=0;i<mesh->Nfp;++i){\n int iM = mesh->faceNodes[fM*mesh->Nfp+i];\n\n dfloat MSfim = sJ*MSf[i*mesh->Nfp+m];\n\n dfloat DxMin = drdx*mesh->Dr[iM*mesh->Np+n] + dsdx*mesh->Ds[iM*mesh->Np+n];\n dfloat DyMin = drdy*mesh->Dr[iM*mesh->Np+n] + dsdy*mesh->Ds[iM*mesh->Np+n];\n\n // OP11 = OP11 + (- Dn1'*mmE );\n A[n] += -0.5*nx*(1+bcD)*(1-bcN)*DxMin*MSfim;\n A[n] += -0.5*ny*(1+bcD)*(1-bcN)*DyMin*MSfim;\n }\n }\n }\n }\n }\n}\n\nvoid BuildLocalIpdgPatchAxTri2D(elliptic_t* elliptic, mesh_t* mesh, int basisNp, dfloat *basis, dfloat lambda,\n dfloat *MS, dlong eM, dfloat *A);\n\n//generate the BB diagonal by extracting it from the transformed patch\nvoid BuildLocalIpdgBBDiagTri2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A) {\n\n dfloat *patchA = (dfloat *) calloc(mesh->Np*mesh->Np,sizeof(dfloat));\n\n int basisNp = mesh->Np;\n dfloat *basis = mesh->VB;\n\n BuildLocalIpdgPatchAxTri2D(elliptic, mesh, basisNp, basis, lambda, MS, eM, patchA);\n\n for(int n=0;n<mesh->Np;++n) {\n A[n] = patchA[n*mesh->Np+n]; //store the diagonal entry\n }\n free(patchA);\n}\n\n//returns the continuous C0 patch A matrix for element eM\nvoid BuildLocalContinuousDiagTri2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *A) {\n\n dlong gbase = eM*mesh->Nggeo;\n dfloat Grr = mesh->ggeo[gbase + G00ID];\n dfloat Grs = mesh->ggeo[gbase + G01ID];\n dfloat Gss = mesh->ggeo[gbase + G11ID];\n dfloat J = mesh->ggeo[gbase + GWJID];\n\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] = J*lambda*mesh->MM[n+n*mesh->Np];\n A[n] += Grr*mesh->Srr[n+n*mesh->Np];\n A[n] += Grs*mesh->Srs[n+n*mesh->Np];\n A[n] += Grs*mesh->Ssr[n+n*mesh->Np];\n A[n] += Gss*mesh->Sss[n+n*mesh->Np];\n } else {\n A[n] = 1; //just put a 1 so A is invertable\n }\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n } \n }\n }\n}\n\nvoid BuildLocalIpdgDiagQuad2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dfloat *B, dfloat *Br, dfloat *Bs, dlong eM, dfloat *A) {\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n A[n] = 0;\n\n // (grad phi_n, grad phi_m)_{D^e}\n for(int i=0;i<mesh->Np;++i){\n dlong base = eM*mesh->Np*mesh->Nvgeo + i;\n dfloat drdx = mesh->vgeo[base+mesh->Np*RXID];\n dfloat drdy = mesh->vgeo[base+mesh->Np*RYID];\n dfloat dsdx = mesh->vgeo[base+mesh->Np*SXID];\n dfloat dsdy = mesh->vgeo[base+mesh->Np*SYID];\n dfloat JW = mesh->vgeo[base+mesh->Np*JWID];\n \n int idn = n*mesh->Np+i;\n dfloat dlndx = drdx*Br[idn] + dsdx*Bs[idn];\n dfloat dlndy = drdy*Br[idn] + dsdy*Bs[idn];\n A[n] += JW*(dlndx*dlndx+dlndy*dlndy);\n A[n] += lambda*JW*B[idn]*B[idn];\n }\n\n for (int fM=0;fM<mesh->Nfaces;fM++) {\n // accumulate flux terms for negative and positive traces\n for(int i=0;i<mesh->Nfp;++i){\n int vidM = mesh->faceNodes[i+fM*mesh->Nfp];\n\n // grab vol geofacs at surface nodes\n dlong baseM = eM*mesh->Np*mesh->Nvgeo + vidM;\n dfloat drdxM = mesh->vgeo[baseM+mesh->Np*RXID];\n dfloat drdyM = mesh->vgeo[baseM+mesh->Np*RYID];\n dfloat dsdxM = mesh->vgeo[baseM+mesh->Np*SXID];\n dfloat dsdyM = mesh->vgeo[baseM+mesh->Np*SYID];\n\n // grab surface geometric factors\n dlong base = mesh->Nsgeo*(eM*mesh->Nfp*mesh->Nfaces + fM*mesh->Nfp + i);\n dfloat nx = mesh->sgeo[base+NXID];\n dfloat ny = mesh->sgeo[base+NYID];\n dfloat wsJ = mesh->sgeo[base+WSJID];\n dfloat hinv = mesh->sgeo[base+IHID];\n \n // form negative trace terms in IPDG\n int idnM = n*mesh->Np+vidM; \n\n dfloat dlndxM = drdxM*Br[idnM] + dsdxM*Bs[idnM];\n dfloat dlndyM = drdyM*Br[idnM] + dsdyM*Bs[idnM];\n dfloat ndotgradlnM = nx*dlndxM+ny*dlndyM;\n dfloat lnM = B[idnM];\n \n dfloat penalty = elliptic->tau*hinv; \n int bc = mesh->EToB[fM+mesh->Nfaces*eM]; //raw boundary flag\n\n int bcD = 0, bcN =0;\n int bcType = 0;\n\n if(bc>0) bcType = elliptic->BCType[bc]; //find its type (Dirichlet/Neumann)\n\n // this needs to be double checked (and the code where these are used)\n if(bcType==1){ // Dirichlet\n bcD = 1;\n bcN = 0;\n } else if(bcType==2){ // Neumann\n bcD = 0;\n bcN = 1;\n } \n\n A[n] += -0.5*(1+bcD)*(1-bcN)*wsJ*lnM*ndotgradlnM; // -(ln^-, N.grad lm^-)\n A[n] += -0.5*(1+bcD)*(1-bcN)*wsJ*ndotgradlnM*lnM; // -(N.grad ln^-, lm^-)\n A[n] += +0.5*(1+bcD)*(1-bcN)*wsJ*penalty*lnM*lnM; // +((tau/h)*ln^-,lm^-)\n }\n }\n }\n}\n\nvoid BuildLocalContinuousDiagQuad2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, \n dfloat *B, dfloat *Br, dfloat* Bs, dfloat *A) {\n\n for (int ny=0;ny<mesh->Nq;ny++) {\n for (int nx=0;nx<mesh->Nq;nx++) {\n int iid = nx+ny*mesh->Nq;\n if (elliptic->mapB[nx+ny*mesh->Nq+eM*mesh->Np]!=1) { \n A[iid] = 0;\n\n for (int k=0;k<mesh->Nq;k++) {\n int id = k+ny*mesh->Nq;\n dfloat Grr = mesh->ggeo[eM*mesh->Np*mesh->Nggeo + id + G00ID*mesh->Np];\n A[iid] += Grr*mesh->D[nx+k*mesh->Nq]*mesh->D[nx+k*mesh->Nq];\n }\n\n for (int k=0;k<mesh->Nq;k++) {\n int id = nx+k*mesh->Nq;\n dfloat Gss = mesh->ggeo[eM*mesh->Np*mesh->Nggeo + id + G11ID*mesh->Np];\n A[iid] += Gss*mesh->D[ny+k*mesh->Nq]*mesh->D[ny+k*mesh->Nq];\n }\n\n int id = nx+ny*mesh->Nq;\n dfloat Grs = mesh->ggeo[eM*mesh->Np*mesh->Nggeo + id + G01ID*mesh->Np];\n A[iid] += 2*Grs*mesh->D[nx+nx*mesh->Nq]*mesh->D[ny+ny*mesh->Nq];\n\n dfloat JW = mesh->ggeo[eM*mesh->Np*mesh->Nggeo + id + GWJID*mesh->Np];\n A[iid] += JW*lambda;\n\n } else {\n A[iid] = 1; //just put a 1 so A is invertable\n }\n }\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n } \n }\n }\n}\n\nvoid BuildLocalIpdgDiagTet3D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A) {\n dlong vbase = eM*mesh->Nvgeo;\n dfloat drdx = mesh->vgeo[vbase+RXID];\n dfloat drdy = mesh->vgeo[vbase+RYID];\n dfloat drdz = mesh->vgeo[vbase+RZID];\n dfloat dsdx = mesh->vgeo[vbase+SXID];\n dfloat dsdy = mesh->vgeo[vbase+SYID];\n dfloat dsdz = mesh->vgeo[vbase+SZID];\n dfloat dtdx = mesh->vgeo[vbase+TXID];\n dfloat dtdy = mesh->vgeo[vbase+TYID];\n dfloat dtdz = mesh->vgeo[vbase+TZID];\n dfloat J = mesh->vgeo[vbase+JID];\n\n dfloat G00 = drdx*drdx + drdy*drdy + drdz*drdz;\n dfloat G01 = drdx*dsdx + drdy*dsdy + drdz*dsdz;\n dfloat G02 = drdx*dtdx + drdy*dtdy + drdz*dtdz;\n\n dfloat G10 = dsdx*drdx + dsdy*drdy + dsdz*drdz;\n dfloat G11 = dsdx*dsdx + dsdy*dsdy + dsdz*dsdz;\n dfloat G12 = dsdx*dtdx + dsdy*dtdy + dsdz*dtdz;\n\n dfloat G20 = dtdx*drdx + dtdy*drdy + dtdz*drdz;\n dfloat G21 = dtdx*dsdx + dtdy*dsdy + dtdz*dsdz;\n dfloat G22 = dtdx*dtdx + dtdy*dtdy + dtdz*dtdz;\n\n\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n A[n] = J*lambda*mesh->MM[n*mesh->Np+n];\n A[n] += J*G00*mesh->Srr[n*mesh->Np+n];\n A[n] += J*G01*mesh->Srs[n*mesh->Np+n];\n A[n] += J*G02*mesh->Srt[n*mesh->Np+n];\n A[n] += J*G10*mesh->Ssr[n*mesh->Np+n];\n A[n] += J*G11*mesh->Sss[n*mesh->Np+n];\n A[n] += J*G12*mesh->Sst[n*mesh->Np+n];\n A[n] += J*G20*mesh->Str[n*mesh->Np+n];\n A[n] += J*G21*mesh->Sts[n*mesh->Np+n];\n A[n] += J*G22*mesh->Stt[n*mesh->Np+n];\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n }\n }\n\n for (int fM=0;fM<mesh->Nfaces;fM++) {\n // load surface geofactors for this face\n dlong sid = mesh->Nsgeo*(eM*mesh->Nfaces+fM);\n dfloat nx = mesh->sgeo[sid+NXID];\n dfloat ny = mesh->sgeo[sid+NYID];\n dfloat nz = mesh->sgeo[sid+NZID];\n dfloat sJ = mesh->sgeo[sid+SJID];\n dfloat hinv = mesh->sgeo[sid+IHID];\n\n int bc = mesh->EToB[fM+mesh->Nfaces*eM]; //raw boundary flag\n\n dfloat penalty = elliptic->tau*hinv;\n\n int bcD = 0, bcN =0;\n int bcType = 0;\n\n if(bc>0) bcType = elliptic->BCType[bc]; //find its type (Dirichlet/Neumann)\n\n // this needs to be double checked (and the code where these are used)\n if(bcType==1){ // Dirichlet\n bcD = 1;\n bcN = 0;\n } else if(bcType==2){ // Neumann\n bcD = 0;\n bcN = 1;\n }\n\n // mass matrix for this face\n dfloat *MSf = MS+fM*mesh->Nfp*mesh->Nfp;\n\n // penalty term just involves face nodes\n for(int n=0;n<mesh->Nfp;++n){\n for(int m=0;m<mesh->Nfp;++m){\n int nM = mesh->faceNodes[fM*mesh->Nfp+n];\n int mM = mesh->faceNodes[fM*mesh->Nfp+m];\n\n if (mM==nM) {\n // OP11 = OP11 + 0.5*( gtau*mmE )\n dfloat MSfnm = sJ*MSf[n*mesh->Nfp+m];\n A[nM] += 0.5*(1.-bcN)*(1.+bcD)*penalty*MSfnm;\n }\n }\n }\n\n // now add differential surface terms\n for(int n=0;n<mesh->Nfp;++n){\n int nM = mesh->faceNodes[fM*mesh->Nfp+n];\n\n for(int i=0;i<mesh->Nfp;++i){\n int iM = mesh->faceNodes[fM*mesh->Nfp+i];\n\n dfloat MSfni = sJ*MSf[n*mesh->Nfp+i]; // surface Jacobian built in\n\n dfloat DxMim = drdx*mesh->Dr[iM*mesh->Np+nM] + dsdx*mesh->Ds[iM*mesh->Np+nM] + dtdx*mesh->Dt[iM*mesh->Np+nM];\n dfloat DyMim = drdy*mesh->Dr[iM*mesh->Np+nM] + dsdy*mesh->Ds[iM*mesh->Np+nM] + dtdy*mesh->Dt[iM*mesh->Np+nM];\n dfloat DzMim = drdz*mesh->Dr[iM*mesh->Np+nM] + dsdz*mesh->Ds[iM*mesh->Np+nM] + dtdz*mesh->Dt[iM*mesh->Np+nM];\n\n // OP11 = OP11 + 0.5*( - mmE*Dn1)\n A[nM] += -0.5*nx*(1+bcD)*(1-bcN)*MSfni*DxMim;\n A[nM] += -0.5*ny*(1+bcD)*(1-bcN)*MSfni*DyMim;\n A[nM] += -0.5*nz*(1+bcD)*(1-bcN)*MSfni*DzMim;\n }\n }\n\n for(int n=0;n<mesh->Np;++n){\n for(int m=0;m<mesh->Nfp;++m){\n int mM = mesh->faceNodes[fM*mesh->Nfp+m];\n\n if (mM==n) {\n for(int i=0;i<mesh->Nfp;++i){\n int iM = mesh->faceNodes[fM*mesh->Nfp+i];\n\n dfloat MSfim = sJ*MSf[i*mesh->Nfp+m];\n\n dfloat DxMin = drdx*mesh->Dr[iM*mesh->Np+n] + dsdx*mesh->Ds[iM*mesh->Np+n] + dtdx*mesh->Dt[iM*mesh->Np+n];\n dfloat DyMin = drdy*mesh->Dr[iM*mesh->Np+n] + dsdy*mesh->Ds[iM*mesh->Np+n] + dtdy*mesh->Dt[iM*mesh->Np+n];\n dfloat DzMin = drdz*mesh->Dr[iM*mesh->Np+n] + dsdz*mesh->Ds[iM*mesh->Np+n] + dtdz*mesh->Dt[iM*mesh->Np+n];\n\n // OP11 = OP11 + (- Dn1'*mmE );\n A[n] += -0.5*nx*(1+bcD)*(1-bcN)*DxMin*MSfim;\n A[n] += -0.5*ny*(1+bcD)*(1-bcN)*DyMin*MSfim;\n A[n] += -0.5*nz*(1+bcD)*(1-bcN)*DzMin*MSfim;\n }\n }\n }\n }\n }\n}\n\nvoid BuildLocalContinuousDiagTet3D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *A) {\n dlong gbase = eM*mesh->Nggeo;\n dfloat Grr = mesh->ggeo[gbase + G00ID];\n dfloat Grs = mesh->ggeo[gbase + G01ID];\n dfloat Grt = mesh->ggeo[gbase + G02ID];\n dfloat Gss = mesh->ggeo[gbase + G11ID];\n dfloat Gst = mesh->ggeo[gbase + G12ID];\n dfloat Gtt = mesh->ggeo[gbase + G22ID];\n dfloat J = mesh->ggeo[gbase + GWJID];\n\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] = J*lambda*mesh->MM[n+n*mesh->Np];\n A[n] += Grr*mesh->Srr[n+n*mesh->Np];\n A[n] += Grs*mesh->Srs[n+n*mesh->Np];\n A[n] += Grt*mesh->Srt[n+n*mesh->Np];\n A[n] += Grs*mesh->Ssr[n+n*mesh->Np];\n A[n] += Gss*mesh->Sss[n+n*mesh->Np];\n A[n] += Gst*mesh->Sst[n+n*mesh->Np];\n A[n] += Grt*mesh->Str[n+n*mesh->Np];\n A[n] += Gst*mesh->Sts[n+n*mesh->Np];\n A[n] += Gtt*mesh->Stt[n+n*mesh->Np];\n } else {\n A[n] = 1; //just put a 1 so A is invertable\n }\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n } \n }\n }\n}\n\nvoid BuildLocalIpdgDiagHex3D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dfloat *B, dfloat *Br, dfloat *Bs, dfloat *Bt, dlong eM, dfloat *A) {\n /* start with stiffness matrix */\n for(int n=0;n<mesh->Np;++n){\n A[n] = 0;\n\n // (grad phi_n, grad phi_m)_{D^e}\n for(int i=0;i<mesh->Np;++i){\n dlong base = eM*mesh->Np*mesh->Nvgeo + i;\n dfloat drdx = mesh->vgeo[base+mesh->Np*RXID];\n dfloat drdy = mesh->vgeo[base+mesh->Np*RYID];\n dfloat drdz = mesh->vgeo[base+mesh->Np*RZID];\n dfloat dsdx = mesh->vgeo[base+mesh->Np*SXID];\n dfloat dsdy = mesh->vgeo[base+mesh->Np*SYID];\n dfloat dsdz = mesh->vgeo[base+mesh->Np*SZID];\n dfloat dtdx = mesh->vgeo[base+mesh->Np*TXID];\n dfloat dtdy = mesh->vgeo[base+mesh->Np*TYID];\n dfloat dtdz = mesh->vgeo[base+mesh->Np*TZID];\n dfloat JW = mesh->vgeo[base+mesh->Np*JWID];\n \n int idn = n*mesh->Np+i;\n dfloat dlndx = drdx*Br[idn] + dsdx*Bs[idn] + dtdx*Bt[idn];\n dfloat dlndy = drdy*Br[idn] + dsdy*Bs[idn] + dtdy*Bt[idn];\n dfloat dlndz = drdz*Br[idn] + dsdz*Bs[idn] + dtdz*Bt[idn]; \n A[n] += JW*(dlndx*dlndx+dlndy*dlndy+dlndz*dlndz);\n A[n] += lambda*JW*B[idn]*B[idn];\n }\n\n for (int fM=0;fM<mesh->Nfaces;fM++) {\n // accumulate flux terms for negative and positive traces\n for(int i=0;i<mesh->Nfp;++i){\n int vidM = mesh->faceNodes[i+fM*mesh->Nfp];\n\n // grab vol geofacs at surface nodes\n dlong baseM = eM*mesh->Np*mesh->Nvgeo + vidM;\n dfloat drdxM = mesh->vgeo[baseM+mesh->Np*RXID];\n dfloat drdyM = mesh->vgeo[baseM+mesh->Np*RYID];\n dfloat drdzM = mesh->vgeo[baseM+mesh->Np*RZID];\n dfloat dsdxM = mesh->vgeo[baseM+mesh->Np*SXID];\n dfloat dsdyM = mesh->vgeo[baseM+mesh->Np*SYID];\n dfloat dsdzM = mesh->vgeo[baseM+mesh->Np*SZID];\n dfloat dtdxM = mesh->vgeo[baseM+mesh->Np*TXID];\n dfloat dtdyM = mesh->vgeo[baseM+mesh->Np*TYID];\n dfloat dtdzM = mesh->vgeo[baseM+mesh->Np*TZID];\n\n // grab surface geometric factors\n dlong base = mesh->Nsgeo*(eM*mesh->Nfp*mesh->Nfaces + fM*mesh->Nfp + i);\n dfloat nx = mesh->sgeo[base+NXID];\n dfloat ny = mesh->sgeo[base+NYID];\n dfloat nz = mesh->sgeo[base+NZID];\n dfloat wsJ = mesh->sgeo[base+WSJID];\n dfloat hinv = mesh->sgeo[base+IHID];\n \n // form negative trace terms in IPDG\n int idnM = n*mesh->Np+vidM; \n dfloat dlndxM = drdxM*Br[idnM] + dsdxM*Bs[idnM] + dtdxM*Bt[idnM];\n dfloat dlndyM = drdyM*Br[idnM] + dsdyM*Bs[idnM] + dtdyM*Bt[idnM];\n dfloat dlndzM = drdzM*Br[idnM] + dsdzM*Bs[idnM] + dtdzM*Bt[idnM];\n dfloat ndotgradlnM = nx*dlndxM+ny*dlndyM+nz*dlndzM;\n dfloat lnM = B[idnM];\n \n dfloat penalty = elliptic->tau*hinv; \n int bc = mesh->EToB[fM+mesh->Nfaces*eM]; //raw boundary flag\n\n int bcD = 0, bcN =0;\n int bcType = 0;\n\n if(bc>0) bcType = elliptic->BCType[bc]; //find its type (Dirichlet/Neumann)\n\n // this needs to be double checked (and the code where these are used)\n if(bcType==1){ // Dirichlet\n bcD = 1;\n bcN = 0;\n } else if(bcType==2){ // Neumann\n bcD = 0;\n bcN = 1;\n } \n\n A[n] += -0.5*(1+bcD)*(1-bcN)*wsJ*lnM*ndotgradlnM; // -(ln^-, N.grad lm^-)\n A[n] += -0.5*(1+bcD)*(1-bcN)*wsJ*ndotgradlnM*lnM; // -(N.grad ln^-, lm^-)\n A[n] += +0.5*(1+bcD)*(1-bcN)*wsJ*penalty*lnM*lnM; // +((tau/h)*ln^-,lm^-)\n }\n }\n }\n}\n\nvoid BuildLocalContinuousDiagHex3D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dlong eM, dfloat *B, dfloat *Br, dfloat *Bs, dfloat *Bt, dfloat *A) {\n for (int nz=0;nz<mesh->Nq;nz++) {\n for (int ny=0;ny<mesh->Nq;ny++) {\n for (int nx=0;nx<mesh->Nq;nx++) {\n int idn = nx+ny*mesh->Nq+nz*mesh->Nq*mesh->Nq;\n if (elliptic->mapB[idn+eM*mesh->Np]!=1) { \n A[idn] = 0;\n\n int id = nx+ny*mesh->Nq+nz*mesh->Nq*mesh->Nq;\n dlong base = eM*mesh->Np*mesh->Nggeo;\n\n \n dfloat Grs = mesh->ggeo[base + id + G01ID*mesh->Np];\n A[idn] += 2*Grs*mesh->D[nx+nx*mesh->Nq]*mesh->D[ny+ny*mesh->Nq];\n\n dfloat Grt = mesh->ggeo[base + id + G02ID*mesh->Np];\n A[idn] += 2*Grt*mesh->D[nx+nx*mesh->Nq]*mesh->D[nz+nz*mesh->Nq];\n \n dfloat Gst = mesh->ggeo[base + id + G12ID*mesh->Np];\n A[idn] += 2*Gst*mesh->D[ny+ny*mesh->Nq]*mesh->D[nz+nz*mesh->Nq];\n\n for (int k=0;k<mesh->Nq;k++) {\n int iid = k+ny*mesh->Nq+nz*mesh->Nq*mesh->Nq;\n dfloat Grr = mesh->ggeo[base + iid + G00ID*mesh->Np];\n A[idn] += Grr*mesh->D[nx+k*mesh->Nq]*mesh->D[nx+k*mesh->Nq];\n }\n\n for (int k=0;k<mesh->Nq;k++) {\n int iid = nx+k*mesh->Nq+nz*mesh->Nq*mesh->Nq;\n dfloat Gss = mesh->ggeo[base + iid + G11ID*mesh->Np];\n A[idn] += Gss*mesh->D[ny+k*mesh->Nq]*mesh->D[ny+k*mesh->Nq];\n }\n \n for (int k=0;k<mesh->Nq;k++) {\n int iid = nx+ny*mesh->Nq+k*mesh->Nq*mesh->Nq;\n dfloat Gtt = mesh->ggeo[base + iid + G22ID*mesh->Np];\n A[idn] += Gtt*mesh->D[nz+k*mesh->Nq]*mesh->D[nz+k*mesh->Nq];\n }\n \n dfloat JW = mesh->ggeo[base + id + GWJID*mesh->Np];\n A[idn] += JW*lambda;\n } else {\n A[idn] = 1; //just put a 1 so A is invertable\n }\n }\n }\n }\n\n //add the rank boost for the allNeumann Poisson problem\n if (elliptic->allNeumann) {\n for(int n=0;n<mesh->Np;++n){\n if (elliptic->mapB[n+eM*mesh->Np]!=1) { //dont fill rows for masked nodes\n A[n] += elliptic->allNeumannPenalty*elliptic->allNeumannScale*elliptic->allNeumannScale;\n } \n }\n }\n}\n"}}},{"rowIdx":93,"cells":{"source":{"kind":"string","value":"integral_omp_sync.c"},"original_c":{"kind":"string","value":"// Author: Fabio Rodrigues Pereira\n// E-mail: fabior@uio.no\n\n// compiling & running\n// clang -Xpreprocessor -fopenmp integral_omp_sync.c -lomp\n// ./a.out\n\n// SPMD technique *video9\n\n#include <stdlib.h> // rand, malloc, calloc and free.\n#include <stdio.h> // printf\n#include <math.h>\n#include <time.h>\n#include <omp.h>\n\n#define NUM_THREADS 2\n\nint main()\n{\n static long num_steps = 100000;\n double step;\n double pi=0.0;\n step=1.0/(double)num_steps;\n omp_set_num_threads(NUM_THREADS);\n\n#pragma omp parallel\n {\n int i, id, nthrds;\n double x, sum;\n\n // being sure that the compiler gave a correct num of threads\n id = omp_get_thread_num();\n nthrds = omp_get_num_threads();\n\n for (i = id, sum = 0.0; i < num_steps; i = i + nthrds) {\n x = (i + 0.5) * step;\n sum += 4.0 / (1.0 + x * x);\n }\n\n #pragma omp critical\n pi+=sum*step;\n }\n\n printf(\"%f\", pi);\n\n return 0;\n}"},"no_omp_formatted":{"kind":"string","value":"// Author: Fabio Rodrigues Pereira\n// E-mail: fabior@uio.no\n\n// compiling & running\n// clang -Xpreprocessor -fopenmp integral_omp_sync.c -lomp\n// ./a.out\n\n// SPMD technique *video9\n\n#include <stdlib.h> // rand, malloc, calloc and free.\n#include <stdio.h> // printf\n#include <math.h>\n#include <time.h>\n#include <omp.h>\n\n#define NUM_THREADS 2\n\nint main()\n{\n static long num_steps = 100000;\n double step;\n double pi=0.0;\n step=1.0/(double)num_steps;\n omp_set_num_threads(NUM_THREADS);\n int i, id, nthrds;\n double x, sum;\n\n // being sure that the compiler gave a correct num of threads\n id = omp_get_thread_num();\n nthrds = omp_get_num_threads();\n\n for (i = id, sum = 0.0; i < num_steps; i = i + nthrds) {\n x = (i + 0.5) * step;\n sum += 4.0 / (1.0 + x * x);\n }\n pi+=sum*step;\n \n\n printf(\"%f\", pi);\n\n return 0;\n}"},"omp_formatted":{"kind":"string","value":"// Author: Fabio Rodrigues Pereira\n// E-mail: fabior@uio.no\n\n// compiling & running\n// clang -Xpreprocessor -fopenmp integral_omp_sync.c -lomp\n// ./a.out\n\n// SPMD technique *video9\n\n#include <stdlib.h> // rand, malloc, calloc and free.\n#include <stdio.h> // printf\n#include <math.h>\n#include <time.h>\n#include <omp.h>\n\n#define NUM_THREADS 2\n\nint main()\n{\n static long num_steps = 100000;\n double step;\n double pi=0.0;\n step=1.0/(double)num_steps;\n omp_set_num_threads(NUM_THREADS);\n\n#pragma omp parallel\n {\n int i, id, nthrds;\n double x, sum;\n\n // being sure that the compiler gave a correct num of threads\n id = omp_get_thread_num();\n nthrds = omp_get_num_threads();\n\n for (i = id, sum = 0.0; i < num_steps; i = i + nthrds) {\n x = (i + 0.5) * step;\n sum += 4.0 / (1.0 + x * x);\n }\n\n #pragma omp critical\n pi+=sum*step;\n }\n\n printf(\"%f\", pi);\n\n return 0;\n}"}}},{"rowIdx":94,"cells":{"source":{"kind":"string","value":"GB_unaryop__abs_int64_uint64.c"},"original_c":{"kind":"string","value":"//------------------------------------------------------------------------------\n// GB_unaryop: hard-coded functions for each built-in unary operator\n//------------------------------------------------------------------------------\n\n// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2019, All Rights Reserved.\n// http://suitesparse.com See GraphBLAS/Doc/License.txt for license.\n\n//------------------------------------------------------------------------------\n\n// If this file is in the Generated/ folder, do not edit it (auto-generated).\n\n#include \"GB.h\"\n#ifndef GBCOMPACT\n#include \"GB_control.h\"\n#include \"GB_iterator.h\"\n#include \"GB_unaryop__include.h\"\n\n// C=unop(A) is defined by the following types and operators:\n\n// op(A) function: GB_unop__abs_int64_uint64\n// op(A') function: GB_tran__abs_int64_uint64\n\n// C type: int64_t\n// A type: uint64_t\n// cast: int64_t cij = (int64_t) aij\n// unaryop: cij = GB_IABS (aij)\n\n#define GB_ATYPE \\\n uint64_t\n\n#define GB_CTYPE \\\n int64_t\n\n// aij = Ax [pA]\n#define GB_GETA(aij,Ax,pA) \\\n uint64_t aij = Ax [pA]\n\n#define GB_CX(p) Cx [p]\n\n// unary operator\n#define GB_OP(z, x) \\\n z = GB_IABS (x) ;\n\n// casting\n#define GB_CASTING(z, x) \\\n int64_t z = (int64_t) x ;\n\n// cij = op (cast (aij))\n#define GB_CAST_OP(pC,pA) \\\n{ \\\n /* aij = Ax [pA] */ \\\n GB_GETA (aij, Ax, pA) ; \\\n /* Cx [pC] = op (cast (aij)) */ \\\n GB_CASTING (x, aij) ; \\\n GB_OP (GB_CX (pC), x) ; \\\n}\n\n// disable this operator and use the generic case if these conditions hold\n#define GB_DISABLE \\\n (GxB_NO_ABS || GxB_NO_INT64 || GxB_NO_UINT64)\n\n//------------------------------------------------------------------------------\n// Cx = op (cast (Ax)): apply a unary operator\n//------------------------------------------------------------------------------\n\nGrB_Info GB_unop__abs_int64_uint64\n(\n int64_t *restrict Cx,\n const uint64_t *restrict Ax,\n int64_t anz,\n int nthreads\n)\n{ \n #if GB_DISABLE\n return (GrB_NO_VALUE) ;\n #else\n #pragma omp parallel for num_threads(nthreads) schedule(static)\n for (int64_t p = 0 ; p < anz ; p++)\n {\n GB_CAST_OP (p, p) ;\n }\n return (GrB_SUCCESS) ;\n #endif\n}\n\n//------------------------------------------------------------------------------\n// C = op (cast (A')): transpose, typecast, and apply a unary operator\n//------------------------------------------------------------------------------\n\nGrB_Info GB_tran__abs_int64_uint64\n(\n GrB_Matrix C,\n const GrB_Matrix A,\n int64_t **Rowcounts,\n GBI_single_iterator Iter,\n const int64_t *restrict A_slice,\n int naslice\n)\n{ \n #if GB_DISABLE\n return (GrB_NO_VALUE) ;\n #else\n #define GB_PHASE_2_OF_2\n #include \"GB_unaryop_transpose.c\"\n return (GrB_SUCCESS) ;\n #endif\n}\n\n#endif\n\n"},"no_omp_formatted":{"kind":"string","value":"//------------------------------------------------------------------------------\n// GB_unaryop: hard-coded functions for each built-in unary operator\n//------------------------------------------------------------------------------\n\n// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2019, All Rights Reserved.\n// http://suitesparse.com See GraphBLAS/Doc/License.txt for license.\n\n//------------------------------------------------------------------------------\n\n// If this file is in the Generated/ folder, do not edit it (auto-generated).\n\n#include \"GB.h\"\n#ifndef GBCOMPACT\n#include \"GB_control.h\"\n#include \"GB_iterator.h\"\n#include \"GB_unaryop__include.h\"\n\n// C=unop(A) is defined by the following types and operators:\n\n// op(A) function: GB_unop__abs_int64_uint64\n// op(A') function: GB_tran__abs_int64_uint64\n\n// C type: int64_t\n// A type: uint64_t\n// cast: int64_t cij = (int64_t) aij\n// unaryop: cij = GB_IABS (aij)\n\n#define GB_ATYPE \\\n uint64_t\n\n#define GB_CTYPE \\\n int64_t\n\n// aij = Ax [pA]\n#define GB_GETA(aij,Ax,pA) \\\n uint64_t aij = Ax [pA]\n\n#define GB_CX(p) Cx [p]\n\n// unary operator\n#define GB_OP(z, x) \\\n z = GB_IABS (x) ;\n\n// casting\n#define GB_CASTING(z, x) \\\n int64_t z = (int64_t) x ;\n\n// cij = op (cast (aij))\n#define GB_CAST_OP(pC,pA) \\\n{ \\\n /* aij = Ax [pA] */ \\\n GB_GETA (aij, Ax, pA) ; \\\n /* Cx [pC] = op (cast (aij)) */ \\\n GB_CASTING (x, aij) ; \\\n GB_OP (GB_CX (pC), x) ; \\\n}\n\n// disable this operator and use the generic case if these conditions hold\n#define GB_DISABLE \\\n (GxB_NO_ABS || GxB_NO_INT64 || GxB_NO_UINT64)\n\n//------------------------------------------------------------------------------\n// Cx = op (cast (Ax)): apply a unary operator\n//------------------------------------------------------------------------------\n\nGrB_Info GB_unop__abs_int64_uint64\n(\n int64_t *restrict Cx,\n const uint64_t *restrict Ax,\n int64_t anz,\n int nthreads\n)\n{ \n #if GB_DISABLE\n return (GrB_NO_VALUE) ;\n #else\n for (int64_t p = 0 ; p < anz ; p++)\n {\n GB_CAST_OP (p, p) ;\n }\n return (GrB_SUCCESS) ;\n #endif\n}\n\n//------------------------------------------------------------------------------\n// C = op (cast (A')): transpose, typecast, and apply a unary operator\n//------------------------------------------------------------------------------\n\nGrB_Info GB_tran__abs_int64_uint64\n(\n GrB_Matrix C,\n const GrB_Matrix A,\n int64_t **Rowcounts,\n GBI_single_iterator Iter,\n const int64_t *restrict A_slice,\n int naslice\n)\n{ \n #if GB_DISABLE\n return (GrB_NO_VALUE) ;\n #else\n #define GB_PHASE_2_OF_2\n #include \"GB_unaryop_transpose.c\"\n return (GrB_SUCCESS) ;\n #endif\n}\n\n#endif\n\n"},"omp_formatted":{"kind":"string","value":"//------------------------------------------------------------------------------\n// GB_unaryop: hard-coded functions for each built-in unary operator\n//------------------------------------------------------------------------------\n\n// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2019, All Rights Reserved.\n// http://suitesparse.com See GraphBLAS/Doc/License.txt for license.\n\n//------------------------------------------------------------------------------\n\n// If this file is in the Generated/ folder, do not edit it (auto-generated).\n\n#include \"GB.h\"\n#ifndef GBCOMPACT\n#include \"GB_control.h\"\n#include \"GB_iterator.h\"\n#include \"GB_unaryop__include.h\"\n\n// C=unop(A) is defined by the following types and operators:\n\n// op(A) function: GB_unop__abs_int64_uint64\n// op(A') function: GB_tran__abs_int64_uint64\n\n// C type: int64_t\n// A type: uint64_t\n// cast: int64_t cij = (int64_t) aij\n// unaryop: cij = GB_IABS (aij)\n\n#define GB_ATYPE \\\n uint64_t\n\n#define GB_CTYPE \\\n int64_t\n\n// aij = Ax [pA]\n#define GB_GETA(aij,Ax,pA) \\\n uint64_t aij = Ax [pA]\n\n#define GB_CX(p) Cx [p]\n\n// unary operator\n#define GB_OP(z, x) \\\n z = GB_IABS (x) ;\n\n// casting\n#define GB_CASTING(z, x) \\\n int64_t z = (int64_t) x ;\n\n// cij = op (cast (aij))\n#define GB_CAST_OP(pC,pA) \\\n{ \\\n /* aij = Ax [pA] */ \\\n GB_GETA (aij, Ax, pA) ; \\\n /* Cx [pC] = op (cast (aij)) */ \\\n GB_CASTING (x, aij) ; \\\n GB_OP (GB_CX (pC), x) ; \\\n}\n\n// disable this operator and use the generic case if these conditions hold\n#define GB_DISABLE \\\n (GxB_NO_ABS || GxB_NO_INT64 || GxB_NO_UINT64)\n\n//------------------------------------------------------------------------------\n// Cx = op (cast (Ax)): apply a unary operator\n//------------------------------------------------------------------------------\n\nGrB_Info GB_unop__abs_int64_uint64\n(\n int64_t *restrict Cx,\n const uint64_t *restrict Ax,\n int64_t anz,\n int nthreads\n)\n{ \n #if GB_DISABLE\n return (GrB_NO_VALUE) ;\n #else\n #pragma omp parallel for num_threads(nthreads) schedule(static)\n for (int64_t p = 0 ; p < anz ; p++)\n {\n GB_CAST_OP (p, p) ;\n }\n return (GrB_SUCCESS) ;\n #endif\n}\n\n//------------------------------------------------------------------------------\n// C = op (cast (A')): transpose, typecast, and apply a unary operator\n//------------------------------------------------------------------------------\n\nGrB_Info GB_tran__abs_int64_uint64\n(\n GrB_Matrix C,\n const GrB_Matrix A,\n int64_t **Rowcounts,\n GBI_single_iterator Iter,\n const int64_t *restrict A_slice,\n int naslice\n)\n{ \n #if GB_DISABLE\n return (GrB_NO_VALUE) ;\n #else\n #define GB_PHASE_2_OF_2\n #include \"GB_unaryop_transpose.c\"\n return (GrB_SUCCESS) ;\n #endif\n}\n\n#endif\n\n"}}},{"rowIdx":95,"cells":{"source":{"kind":"string","value":"linear.c"},"original_c":{"kind":"string","value":"//IN method.\n//Linear transformation (weights only, no biases) of Ni inputs to No outputs.\n\n//Input X has Ni neurons and output Y has No neurons.\n\n//The vecs of length Ni are always contiguous in memory, such that:\n\n//If col-major: Y[:,l] = W' * X[:,l]\n//where:\n//X has size Ni x L\n//Y has size No x L\n//W has size Ni x No\n\n//If row-major: Y[l,:] = X[l,:] * W'\n//X has size L x Ni\n//Y has size L x No\n//W has size No x Ni\n\n//For a different set-up that allows linear transformation of vecs in\n//any orientation, use the linear function from math.\n\n//#include <omp.h>\n\n#ifdef __cplusplus\nnamespace codee {\nextern \"C\" {\n#endif\n\nint linear_s (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L);\nint linear_d (double *Y, const double *X, const double *W, const size_t Ni, const size_t No, const size_t L);\nint linear_c (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L);\nint linear_z (double *Y, const double *X, const double *W, const size_t Ni, const size_t No, const size_t L);\n\n\nint linear_s (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L)\n{\n const size_t Nw = Ni*No;\n float sm;\n\n for (size_t l=L; l>0u; --l, W-=Nw, X+=Ni)\n {\n for (size_t o=No; o>0u; --o, X-=Ni, ++Y)\n {\n sm = 0.0f;\n for (size_t i=Ni; i>0u; --i, ++X, ++W)\n {\n sm += *X * *W;\n }\n *Y = sm;\n }\n }\n\n return 0;\n}\n\n\nint linear_d (double *Y, const double *X, const double *W, const size_t Ni, const size_t No, const size_t L)\n{\n const size_t Nw = Ni*No;\n double sm;\n\n for (size_t l=L; l>0u; --l, W-=Nw, X+=Ni)\n {\n for (size_t o=No; o>0u; --o, X-=Ni, ++Y)\n {\n sm = 0.0;\n for (size_t i=Ni; i>0u; --i, ++X, ++W)\n {\n sm += *X * *W;\n }\n *Y = sm;\n }\n }\n\n return 0;\n}\n\n\nint linear_c (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L)\n{\n const size_t Nw = Ni*No;\n float smr, smi;\n\n for (size_t l=L; l>0u; --l, W-=2u*Nw, X+=2u*Ni)\n {\n for (size_t o=No; o>0u; --o, X-=2u*Ni)\n {\n smr = smi = 0.0f;\n for (size_t i=Ni; i>0u; --i, X+=2, W+=2)\n {\n smr += *X**W - *(X+1)**(W+1);\n smi += *X**(W+1) + *(X+1)**W;\n }\n *Y++ = smr; *Y++ = smi;\n }\n }\n\n return 0;\n}\n\n\nint linear_z (double *Y, const double *X, const double *W, const size_t Ni, const size_t No, const size_t L)\n{\n const size_t Nw = Ni*No;\n double smr, smi;\n\n for (size_t l=L; l>0u; --l, W-=2u*Nw, X+=2u*Ni)\n {\n for (size_t o=No; o>0u; --o, X-=2u*Ni)\n {\n smr = smi = 0.0;\n for (size_t i=Ni; i>0u; --i, X+=2, W+=2)\n {\n smr += *X**W - *(X+1)**(W+1);\n smi += *X**(W+1) + *(X+1)**W;\n }\n *Y++ = smr; *Y++ = smi;\n }\n }\n\n return 0;\n}\n\n\n//Although this compiles and runs, it does not give the right output\n// int linear_omp_s (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L)\n// {\n// for (size_t l=L; l>0u; --l)\n// {\n// #pragma omp parallel for\n// for (size_t o=No; o>0u; --o)\n// {\n// float sm = 0.0f;\n// for (size_t i=Ni; i>0u; --i)\n// {\n// sm += X[i+l*Ni] * W[i+o*Ni];\n// }\n// Y[o] = sm;\n// }\n// }\n\n// return 0;\n// }\n\n\n#ifdef __cplusplus\n}\n}\n#endif\n"},"no_omp_formatted":{"kind":"string","value":"//IN method.\n//Linear transformation (weights only, no biases) of Ni inputs to No outputs.\n\n//Input X has Ni neurons and output Y has No neurons.\n\n//The vecs of length Ni are always contiguous in memory, such that:\n\n//If col-major: Y[:,l] = W' * X[:,l]\n//where:\n//X has size Ni x L\n//Y has size No x L\n//W has size Ni x No\n\n//If row-major: Y[l,:] = X[l,:] * W'\n//X has size L x Ni\n//Y has size L x No\n//W has size No x Ni\n\n//For a different set-up that allows linear transformation of vecs in\n//any orientation, use the linear function from math.\n\n//#include <omp.h>\n\n#ifdef __cplusplus\nnamespace codee {\nextern \"C\" {\n#endif\n\nint linear_s (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L);\nint linear_d (double *Y, const double *X, const double *W, const size_t Ni, const size_t No, const size_t L);\nint linear_c (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L);\nint linear_z (double *Y, const double *X, const double *W, const size_t Ni, const size_t No, const size_t L);\n\n\nint linear_s (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L)\n{\n const size_t Nw = Ni*No;\n float sm;\n\n for (size_t l=L; l>0u; --l, W-=Nw, X+=Ni)\n {\n for (size_t o=No; o>0u; --o, X-=Ni, ++Y)\n {\n sm = 0.0f;\n for (size_t i=Ni; i>0u; --i, ++X, ++W)\n {\n sm += *X * *W;\n }\n *Y = sm;\n }\n }\n\n return 0;\n}\n\n\nint linear_d (double *Y, const double *X, const double *W, const size_t Ni, const size_t No, const size_t L)\n{\n const size_t Nw = Ni*No;\n double sm;\n\n for (size_t l=L; l>0u; --l, W-=Nw, X+=Ni)\n {\n for (size_t o=No; o>0u; --o, X-=Ni, ++Y)\n {\n sm = 0.0;\n for (size_t i=Ni; i>0u; --i, ++X, ++W)\n {\n sm += *X * *W;\n }\n *Y = sm;\n }\n }\n\n return 0;\n}\n\n\nint linear_c (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L)\n{\n const size_t Nw = Ni*No;\n float smr, smi;\n\n for (size_t l=L; l>0u; --l, W-=2u*Nw, X+=2u*Ni)\n {\n for (size_t o=No; o>0u; --o, X-=2u*Ni)\n {\n smr = smi = 0.0f;\n for (size_t i=Ni; i>0u; --i, X+=2, W+=2)\n {\n smr += *X**W - *(X+1)**(W+1);\n smi += *X**(W+1) + *(X+1)**W;\n }\n *Y++ = smr; *Y++ = smi;\n }\n }\n\n return 0;\n}\n\n\nint linear_z (double *Y, const double *X, const double *W, const size_t Ni, const size_t No, const size_t L)\n{\n const size_t Nw = Ni*No;\n double smr, smi;\n\n for (size_t l=L; l>0u; --l, W-=2u*Nw, X+=2u*Ni)\n {\n for (size_t o=No; o>0u; --o, X-=2u*Ni)\n {\n smr = smi = 0.0;\n for (size_t i=Ni; i>0u; --i, X+=2, W+=2)\n {\n smr += *X**W - *(X+1)**(W+1);\n smi += *X**(W+1) + *(X+1)**W;\n }\n *Y++ = smr; *Y++ = smi;\n }\n }\n\n return 0;\n}\n\n\n//Although this compiles and runs, it does not give the right output\n// int linear_omp_s (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L)\n// {\n// for (size_t l=L; l>0u; --l)\n// {\n//\n// for (size_t o=No; o>0u; --o)\n// {\n// float sm = 0.0f;\n// for (size_t i=Ni; i>0u; --i)\n// {\n// sm += X[i+l*Ni] * W[i+o*Ni];\n// }\n// Y[o] = sm;\n// }\n// }\n\n// return 0;\n// }\n\n\n#ifdef __cplusplus\n}\n}\n#endif\n"},"omp_formatted":{"kind":"string","value":"//IN method.\n//Linear transformation (weights only, no biases) of Ni inputs to No outputs.\n\n//Input X has Ni neurons and output Y has No neurons.\n\n//The vecs of length Ni are always contiguous in memory, such that:\n\n//If col-major: Y[:,l] = W' * X[:,l]\n//where:\n//X has size Ni x L\n//Y has size No x L\n//W has size Ni x No\n\n//If row-major: Y[l,:] = X[l,:] * W'\n//X has size L x Ni\n//Y has size L x No\n//W has size No x Ni\n\n//For a different set-up that allows linear transformation of vecs in\n//any orientation, use the linear function from math.\n\n//#include <omp.h>\n\n#ifdef __cplusplus\nnamespace codee {\nextern \"C\" {\n#endif\n\nint linear_s (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L);\nint linear_d (double *Y, const double *X, const double *W, const size_t Ni, const size_t No, const size_t L);\nint linear_c (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L);\nint linear_z (double *Y, const double *X, const double *W, const size_t Ni, const size_t No, const size_t L);\n\n\nint linear_s (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L)\n{\n const size_t Nw = Ni*No;\n float sm;\n\n for (size_t l=L; l>0u; --l, W-=Nw, X+=Ni)\n {\n for (size_t o=No; o>0u; --o, X-=Ni, ++Y)\n {\n sm = 0.0f;\n for (size_t i=Ni; i>0u; --i, ++X, ++W)\n {\n sm += *X * *W;\n }\n *Y = sm;\n }\n }\n\n return 0;\n}\n\n\nint linear_d (double *Y, const double *X, const double *W, const size_t Ni, const size_t No, const size_t L)\n{\n const size_t Nw = Ni*No;\n double sm;\n\n for (size_t l=L; l>0u; --l, W-=Nw, X+=Ni)\n {\n for (size_t o=No; o>0u; --o, X-=Ni, ++Y)\n {\n sm = 0.0;\n for (size_t i=Ni; i>0u; --i, ++X, ++W)\n {\n sm += *X * *W;\n }\n *Y = sm;\n }\n }\n\n return 0;\n}\n\n\nint linear_c (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L)\n{\n const size_t Nw = Ni*No;\n float smr, smi;\n\n for (size_t l=L; l>0u; --l, W-=2u*Nw, X+=2u*Ni)\n {\n for (size_t o=No; o>0u; --o, X-=2u*Ni)\n {\n smr = smi = 0.0f;\n for (size_t i=Ni; i>0u; --i, X+=2, W+=2)\n {\n smr += *X**W - *(X+1)**(W+1);\n smi += *X**(W+1) + *(X+1)**W;\n }\n *Y++ = smr; *Y++ = smi;\n }\n }\n\n return 0;\n}\n\n\nint linear_z (double *Y, const double *X, const double *W, const size_t Ni, const size_t No, const size_t L)\n{\n const size_t Nw = Ni*No;\n double smr, smi;\n\n for (size_t l=L; l>0u; --l, W-=2u*Nw, X+=2u*Ni)\n {\n for (size_t o=No; o>0u; --o, X-=2u*Ni)\n {\n smr = smi = 0.0;\n for (size_t i=Ni; i>0u; --i, X+=2, W+=2)\n {\n smr += *X**W - *(X+1)**(W+1);\n smi += *X**(W+1) + *(X+1)**W;\n }\n *Y++ = smr; *Y++ = smi;\n }\n }\n\n return 0;\n}\n\n\n//Although this compiles and runs, it does not give the right output\n// int linear_omp_s (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L)\n// {\n// for (size_t l=L; l>0u; --l)\n// {\n// #pragma omp parallel for\n// for (size_t o=No; o>0u; --o)\n// {\n// float sm = 0.0f;\n// for (size_t i=Ni; i>0u; --i)\n// {\n// sm += X[i+l*Ni] * W[i+o*Ni];\n// }\n// Y[o] = sm;\n// }\n// }\n\n// return 0;\n// }\n\n\n#ifdef __cplusplus\n}\n}\n#endif\n"}}},{"rowIdx":96,"cells":{"source":{"kind":"string","value":"raytracer.h"},"original_c":{"kind":"string","value":"#pragma once\n\n#include \"resource.h\"\n\n#include <linalg.h>\n#include <memory>\n#include <omp.h>\n#include <random>\n#include <time.h>\n\nusing namespace linalg::aliases;\n\nnamespace cg::renderer\n{\nstruct ray\n{\n\tray(float3 position, float3 direction) : position(position)\n\t{\n\t\tthis->direction = normalize(direction);\n\t}\n\tfloat3 position;\n\tfloat3 direction;\n};\n\nstruct payload\n{\n\tfloat t;\n\tfloat3 bary;\n\tcg::color color;\n};\n\ntemplate<typename VB>\nstruct triangle\n{\n\ttriangle(const VB& vertex_a, const VB& vertex_b, const VB& vertex_c);\n\n\tfloat3 a;\n\tfloat3 b;\n\tfloat3 c;\n\n\tfloat3 ba;\n\tfloat3 ca;\n\n\tfloat3 na;\n\tfloat3 nb;\n\tfloat3 nc;\n\n\tfloat3 ambient;\n\tfloat3 diffuse;\n\tfloat3 emissive;\n};\n\ntemplate<typename VB>\ninline triangle<VB>::triangle(const VB& vertex_a, const VB& vertex_b, const VB& vertex_c)\n{\n\ta = float3{ vertex_a.x, vertex_a.y, vertex_a.z };\n\tb = float3{ vertex_b.x, vertex_b.y, vertex_b.z };\n\tc = float3{ vertex_c.x, vertex_c.y, vertex_c.z };\n\n\tba = b - a;\n\tca = c - a;\n\n\tna = float3{ vertex_a.nx, vertex_a.ny, vertex_a.nz };\n\tnb = float3{ vertex_b.nx, vertex_b.ny, vertex_b.nz };\n\tnc = float3{ vertex_c.nx, vertex_c.ny, vertex_c.nz };\n\n\tambient = {\n\t\tvertex_a.ambient_r,\n\t\tvertex_a.ambient_g,\n\t\tvertex_a.ambient_b,\n\t};\n\tdiffuse = {\n\t\tvertex_a.diffuse_r,\n\t\tvertex_a.diffuse_g,\n\t\tvertex_a.diffuse_b,\n\t};\n\temissive = {\n\t\tvertex_a.emissive_r,\n\t\tvertex_a.emissive_g,\n\t\tvertex_a.emissive_b,\n\t};\n}\n\ntemplate<typename VB>\nclass aabb\n{\npublic:\n\tvoid add_triangle(const triangle<VB> triangle);\n\tconst std::vector<triangle<VB>>& get_traingles() const;\n\tbool aabb_test(const ray& ray) const;\n\nprotected:\n\tstd::vector<triangle<VB>> triangles;\n\n\tfloat3 aabb_min;\n\tfloat3 aabb_max;\n};\n\nstruct light\n{\n\tfloat3 position;\n\tfloat3 color;\n};\n\ntemplate<typename VB, typename RT>\nclass raytracer\n{\npublic:\n\traytracer(){};\n\t~raytracer(){};\n\n\tvoid set_render_target(std::shared_ptr<resource<RT>> in_render_target);\n\tvoid clear_render_target(const RT& in_clear_value);\n\tvoid set_viewport(size_t in_width, size_t in_height);\n\n\tvoid set_per_shape_vertex_buffer(\n\t\tstd::vector<std::shared_ptr<cg::resource<VB>>> in_per_shape_vertex_buffer);\n\tvoid build_acceleration_structure();\n\tstd::vector<aabb<VB>> acceleration_structures;\n\n\tvoid ray_generation(float3 position, float3 direction, float3 right, float3 up);\n\n\tpayload trace_ray(const ray& ray, size_t depth, float max_t = 1000.f, float min_t = 0.001f) const;\n\tpayload intersection_shader(const triangle<VB>& triangle, const ray& ray) const;\n\n\tstd::function<payload(const ray& ray)> miss_shader = nullptr;\n\tstd::function<payload(const ray& ray, payload& payload, const triangle<VB>& triangle)> closest_hit_shader =\n\t\tnullptr;\n\tstd::function<payload(const ray& ray, payload& payload, const triangle<VB>& triangle)> any_hit_shader =\n\t\tnullptr;\n\n\nprotected:\n\tstd::shared_ptr<cg::resource<RT>> render_target;\n\tstd::vector<std::shared_ptr<cg::resource<VB>>> per_shape_vertex_buffer;\n\n\tfloat get_random(const int thread_num, float range = 0.1f) const;\n\n\tsize_t width = 1920;\n\tsize_t height = 1080;\n};\n\ntemplate<typename VB, typename RT>\ninline void raytracer<VB, RT>::set_render_target(std::shared_ptr<resource<RT>> in_render_target)\n{\n\trender_target = in_render_target;\n}\n\ntemplate<typename VB, typename RT>\ninline void raytracer<VB, RT>::clear_render_target(const RT& in_clear_value)\n{\n\tfor (size_t i = 0; i < render_target->get_number_of_elements(); i++)\n\t{\n\t\trender_target->item(i) = in_clear_value;\n\t}\n}\n\ntemplate<typename VB, typename RT>\ninline void raytracer<VB, RT>::set_per_shape_vertex_buffer(\n\tstd::vector<std::shared_ptr<cg::resource<VB>>> in_per_shape_vertex_buffer)\n{\n\tper_shape_vertex_buffer = in_per_shape_vertex_buffer;\n}\n\ntemplate<typename VB, typename RT>\ninline void raytracer<VB, RT>::build_acceleration_structure()\n{\n\tfor (auto& vertex_buffer : per_shape_vertex_buffer)\n\t{\n\t\tsize_t vertex_id = 0;\n\t\taabb<VB> aabb;\n\n\t\twhile (vertex_id < vertex_buffer->get_number_of_elements())\n\t\t{\n\t\t\ttriangle<VB> triangle(\n\t\t\t\tvertex_buffer->item(vertex_id++), vertex_buffer->item(vertex_id++),\n\t\t\t\tvertex_buffer->item(vertex_id++));\n\t\t\taabb.add_triangle(triangle);\n\t\t}\n\n\t\tacceleration_structures.push_back(aabb);\n\t}\n}\n\ntemplate<typename VB, typename RT>\ninline void raytracer<VB, RT>::set_viewport(size_t in_width, size_t in_height)\n{\n\twidth = in_width;\n\theight = in_height;\n}\n\ntemplate<typename VB, typename RT>\ninline void raytracer<VB, RT>::ray_generation(\n\tfloat3 position, float3 direction, float3 right, float3 up)\n{\n\tfor (int x = 0; x < width; x++)\n\t{\n#pragma omp parallel for\n\t\tfor (int y = 0; y < height; y++)\n\t\t{\n\t\t\t// from [0, width-1] to [-1, 1]\n\t\t\tfloat u = 2.f * x / static_cast<float>(width - 1) - 1.f;\n\t\t\tu *= static_cast<float>(width) / static_cast<float>(height);\n\t\t\tfloat v = 2.f * y / static_cast<float>(height - 1) - 1.f;\n\n\t\t\tfloat3 ray_direction = direction + u * right - v * up;\n\t\t\tray ray(position, ray_direction);\n\n\t\t\tpayload payload = trace_ray(ray, 1);\n\n\t\t\trender_target->item(x, y) = RT::from_color(payload.color);\n\t\t}\n\t}\n}\n\ntemplate<typename VB, typename RT>\ninline payload\n\traytracer<VB, RT>::trace_ray(const ray& ray, size_t depth, float max_t, float min_t) const\n{\n\tif (depth == 0)\n\t{\n\t\treturn miss_shader(ray);\n\t}\n\n\tdepth--;\n\n\tpayload closest_hit_payload = {};\n\tclosest_hit_payload.t = max_t;\n\tconst triangle<VB>* closest_triangle = nullptr;\n\n\tfor (auto& aabb : acceleration_structures)\n\t{\n\t\tif (!aabb.aabb_test(ray))\n\t\t\tcontinue;\n\n\t\tfor (auto& triangle : aabb.get_traingles())\n\t\t{\n\t\t\tpayload payload = intersection_shader(triangle, ray);\n\n\t\t\tif (payload.t > min_t && payload.t < closest_hit_payload.t)\n\t\t\t{\n\t\t\t\tclosest_hit_payload = payload;\n\t\t\t\tclosest_triangle = ▵\n\t\t\t\tif (any_hit_shader)\n\t\t\t\t\treturn any_hit_shader(ray, payload, triangle);\n\t\t\t}\n\t\t}\n\t}\n\tif (closest_hit_payload.t < max_t)\n\t{\n\t\tif (closest_hit_shader)\n\t\t{\n\t\t\treturn closest_hit_shader(ray, closest_hit_payload, *closest_triangle);\n\t\t}\n\t}\n\treturn miss_shader(ray);\n}\n\ntemplate<typename VB, typename RT>\ninline payload\n\traytracer<VB, RT>::intersection_shader(const triangle<VB>& triangle, const ray& ray) const\n{\n\tpayload payload{};\n\tpayload.t = -1.f;\n\n\tfloat3 pvec = cross(ray.direction, triangle.ca);\n\tfloat det = dot(triangle.ba, pvec);\n\n\tconst float eps = 1e-8f;\n\tif (abs(det) < eps)\n\t{\n\t\treturn payload;\n\t}\n\n\tfloat inv_det = 1.f / det;\n\tfloat3 tvec = ray.position - triangle.a;\n\tfloat u = dot(tvec, pvec) * inv_det;\n\tif (u < 0.f || u > 1.f)\n\t{\n\t\treturn payload;\n\t}\n\n\tfloat3 qvec = cross(tvec, triangle.ba);\n\tfloat v = dot(ray.direction, qvec) * inv_det;\n\tif (v < 0.f || (u + v) > 1.f)\n\t{\n\t\treturn payload;\n\t}\n\n\tpayload.t = dot(triangle.ca, qvec) * inv_det;\n\tpayload.bary = float3{ 1.f - u - v, u, v };\n\treturn payload;\n}\n\ntemplate<typename VB, typename RT>\ninline float raytracer<VB, RT>::get_random(const int thread_num, const float range) const\n{\n\tstatic std::default_random_engine generator(thread_num);\n\tstatic std::normal_distribution<float> distribution(0.f, range);\n\treturn distribution(generator);\n}\n\n\ntemplate<typename VB>\ninline void aabb<VB>::add_triangle(const triangle<VB> triangle)\n{\n\tif (triangles.empty())\n\t\taabb_max = aabb_min = triangle.a;\n\n\ttriangles.push_back(triangle);\n\n\taabb_max = max(triangle.a, aabb_max);\n\taabb_max = max(triangle.b, aabb_max);\n\taabb_max = max(triangle.c, aabb_max);\n\n\taabb_min = min(triangle.a, aabb_min);\n\taabb_min = min(triangle.b, aabb_min);\n\taabb_min = min(triangle.c, aabb_min);\n}\n\ntemplate<typename VB>\ninline const std::vector<triangle<VB>>& aabb<VB>::get_traingles() const\n{\n\treturn triangles;\n}\n\ntemplate<typename VB>\ninline bool aabb<VB>::aabb_test(const ray& ray) const\n{\n\tfloat3 inv_ray_direction = float3(1.f) / ray.direction;\n\tfloat3 t0 = (aabb_max - ray.position) * inv_ray_direction;\n\tfloat3 t1 = (aabb_min - ray.position) * inv_ray_direction;\n\tfloat3 tmin = min(t0, t1);\n\tfloat3 tmax = max(t0, t1);\n\treturn maxelem(tmin) <= minelem(tmax);\n}\n\n} // namespace cg::renderer\n"},"no_omp_formatted":{"kind":"string","value":"#pragma once\n\n#include \"resource.h\"\n\n#include <linalg.h>\n#include <memory>\n#include <omp.h>\n#include <random>\n#include <time.h>\n\nusing namespace linalg::aliases;\n\nnamespace cg::renderer\n{\n struct ray\n {\n ray(float3 position, float3 direction):position(position)\n {\n this->direction = normalize(direction);\n }\n float3 position;\n float3 direction;\n };\n\n struct payload\n {\n float t;\n float3 bary;\n cg: : color color;\n };\n\n template < typename VB >\n struct triangle\n {\n triangle(const VB & vertex_a, const VB & vertex_b, const VB & vertex_c);\n\n float3 a;\n float3 b;\n float3 c;\n\n float3 ba;\n float3 ca;\n\n float3 na;\n float3 nb;\n float3 nc;\n\n float3 ambient;\n float3 diffuse;\n float3 emissive;\n };\n\n template < typename VB >\n inline triangle < VB >: : triangle(const VB & vertex_a, const VB & vertex_b, const VB & vertex_c)\n {\n a = float3\n {\n vertex_a.x, vertex_a.y, vertex_a.z\n };\n b = float3\n {\n vertex_b.x, vertex_b.y, vertex_b.z\n };\n c = float3\n {\n vertex_c.x, vertex_c.y, vertex_c.z\n };\n\n ba = b - a;\n ca = c - a;\n\n na = float3\n {\n vertex_a.nx, vertex_a.ny, vertex_a.nz\n };\n nb = float3\n {\n vertex_b.nx, vertex_b.ny, vertex_b.nz\n };\n nc = float3\n {\n vertex_c.nx, vertex_c.ny, vertex_c.nz\n };\n\n ambient =\n {\n vertex_a.ambient_r,\n vertex_a.ambient_g,\n vertex_a.ambient_b,\n };\n diffuse =\n {\n vertex_a.diffuse_r,\n vertex_a.diffuse_g,\n vertex_a.diffuse_b,\n };\n emissive =\n {\n vertex_a.emissive_r,\n vertex_a.emissive_g,\n vertex_a.emissive_b,\n };\n }\n\n template < typename VB >\n class aabb\n {\npublic:\n void add_triangle(const triangle < VB > triangle);\n const std::vector < triangle < VB >> &get_traingles() const;\n bool aabb_test(const ray & ray)const;\n\nprotected:\nstd: : vector < triangle < VB >> triangles;\n\n float3 aabb_min;\n float3 aabb_max;\n };\n\n struct light\n {\n float3 position;\n float3 color;\n };\n\n template < typename VB, typename RT >\n class raytracer\n {\npublic:\n raytracer()\n {\n };\n ~raytracer()\n {\n };\n\n void set_render_target(std::shared_ptr < resource < RT >> in_render_target);\n void clear_render_target(const RT & in_clear_value);\n void set_viewport(size_t in_width, size_t in_height);\n\n void set_per_shape_vertex_buffer(\n std::vector < std::shared_ptr < cg::resource < VB >> >in_per_shape_vertex_buffer);\n void build_acceleration_structure();\nstd: : vector < aabb < VB >> acceleration_structures;\n\n void ray_generation(float3 position, float3 direction, float3 right, float3 up);\n\n payload trace_ray(const ray & ray, size_t depth, float max_t = 1000. f, float min_t = 0.001 f)const;\n payload intersection_shader(const triangle < VB > &triangle, const ray & ray)const;\n\nstd: : function < payload(const ray & ray)>miss_shader = nullptr;\nstd: : function < payload(const ray & ray, payload & payload, const triangle < VB > &triangle)>closest_hit_shader =\n nullptr;\nstd: : function < payload(const ray & ray, payload & payload, const triangle < VB > &triangle)>any_hit_shader =\n nullptr;\n\n\nprotected:\nstd: : shared_ptr < cg: :resource < RT >> render_target;\nstd: : vector < std: : shared_ptr < cg: :resource < VB >> >per_shape_vertex_buffer;\n\n float get_random(const int thread_num, float range = 0.1 f)const;\n\n size_t width = 1920;\n size_t height = 1080;\n };\n\n template < typename VB, typename RT >\n inline void raytracer < VB, RT >::set_render_target(std::shared_ptr < resource < RT >> in_render_target)\n {\n render_target = in_render_target;\n }\n\n template < typename VB, typename RT >\n inline void raytracer < VB, RT >::clear_render_target(const RT & in_clear_value)\n {\n for (size_t i = 0; i < render_target->get_number_of_elements(); i++)\n {\n render_target->item(i) = in_clear_value;\n }\n }\n\n template < typename VB, typename RT >\n inline void raytracer < VB, RT >::set_per_shape_vertex_buffer(\n std::vector < std::shared_ptr < cg::resource < VB >> >in_per_shape_vertex_buffer)\n {\n per_shape_vertex_buffer = in_per_shape_vertex_buffer;\n }\n\n template < typename VB, typename RT >\n inline void raytracer < VB, RT >::build_acceleration_structure()\n {\n for (auto & vertex_buffer:per_shape_vertex_buffer)\n {\n size_t vertex_id = 0;\n aabb < VB > aabb;\n\n while (vertex_id < vertex_buffer->get_number_of_elements())\n {\n triangle < VB > triangle(\n vertex_buffer->item(vertex_id++), vertex_buffer->item(vertex_id++),\n vertex_buffer->item(vertex_id++));\n aabb.add_triangle(triangle);\n }\n\n acceleration_structures.push_back(aabb);\n }\n }\n\n template < typename VB, typename RT >\n inline void raytracer < VB, RT >::set_viewport(size_t in_width, size_t in_height)\n {\n width = in_width;\n height = in_height;\n }\n\n template < typename VB, typename RT >\n inline void raytracer < VB, RT >::ray_generation(\n float3 position, float3 direction, float3 right, float3 up)\n {\n for (int x = 0; x < width; x++)\n {\n for (int y = 0; y < height; y++)\n {\n //from[0, width - 1] to[-1, 1]\n float u = 2. f * x / static_cast < float >(width - 1) - 1. f;\n u *= static_cast < float >(width) / static_cast < float >(height);\n float v = 2. f * y / static_cast < float >(height - 1) - 1. f;\n\n float3 ray_direction = direction + u * right - v * up;\n ray ray(position, ray_direction);\n\n payload payload = trace_ray(ray, 1);\n\n render_target->item(x, y) = RT: : from_color(payload.color);\n }\n }\n }\n\n template < typename VB, typename RT >\n inline payload\n raytracer < VB, RT >: : trace_ray(const ray & ray, size_t depth, float max_t, float min_t)const\n {\n if (depth == 0)\n {\n return miss_shader(ray);\n }\n depth--;\n\n payload closest_hit_payload = {};\n closest_hit_payload.t = max_t;\n const triangle < VB > *closest_triangle = nullptr;\n\nfor (auto & aabb: acceleration_structures)\n {\n if (!aabb.aabb_test(ray))\n continue;\n\n for (auto & triangle:aabb.get_traingles())\n {\n payload payload = intersection_shader(triangle, ray);\n\n if (payload.t > min_t && payload.t < closest_hit_payload.t)\n {\n closest_hit_payload = payload;\n closest_triangle = ▵\n if (any_hit_shader)\n return any_hit_shader(ray, payload, triangle);\n }\n }\n }\n if (closest_hit_payload.t < max_t)\n {\n if (closest_hit_shader)\n {\n return closest_hit_shader(ray, closest_hit_payload, *closest_triangle);\n }\n }\n return miss_shader(ray);\n }\n\n template < typename VB, typename RT >\n inline payload\nraytracer < VB, RT >: :intersection_shader(const triangle < VB > &triangle, const ray & ray)const\n {\n payload payload\n {\n };\n payload.t = -1. f;\n\n float3 pvec = cross(ray.direction, triangle.ca);\n float det = dot(triangle.ba, pvec);\n\n const float eps = 1e-8 f;\n if (abs(det) < eps)\n {\n return payload;\n }\n float inv_det = 1. f / det;\n float3 tvec = ray.position - triangle.a;\n float u = dot(tvec, pvec) * inv_det;\n if (u < 0. f || u > 1. f)\n {\n return payload;\n }\n float3 qvec = cross(tvec, triangle.ba);\n float v = dot(ray.direction, qvec) * inv_det;\n if (v < 0. f || (u + v) > 1. f)\n {\n return payload;\n }\n payload.t = dot(triangle.ca, qvec) * inv_det;\n payload.bary = float3\n {\n 1. f - u - v, u, v\n };\n return payload;\n }\n\n template < typename VB, typename RT >\n inline float raytracer < VB, RT >::get_random(const int thread_num, const float range)const\n {\n static std::default_random_engine generator(thread_num);\n static std::normal_distribution < float >distribution(0. f, range);\n return distribution(generator);\n }\n\n\n template < typename VB >\n inline void aabb < VB >::add_triangle(const triangle < VB > triangle)\n {\n if (triangles.empty())\n aabb_max = aabb_min = triangle.a;\n\n triangles.push_back(triangle);\n\n aabb_max = max(triangle.a, aabb_max);\n aabb_max = max(triangle.b, aabb_max);\n aabb_max = max(triangle.c, aabb_max);\n\n aabb_min = min(triangle.a, aabb_min);\n aabb_min = min(triangle.b, aabb_min);\n aabb_min = min(triangle.c, aabb_min);\n }\n\n template < typename VB >\n inline const std::vector < triangle < VB >> &aabb < VB >::get_traingles() const\n {\n return triangles;\n }\n\n template < typename VB >\n inline bool aabb < VB >: : aabb_test(const ray & ray)const\n {\n float3 inv_ray_direction = float3(1. f) / ray.direction;\n float3 t0 = (aabb_max - ray.position) * inv_ray_direction;\n float3 t1 = (aabb_min - ray.position) * inv_ray_direction;\n float3 tmin = min(t0, t1);\n float3 tmax = max(t0, t1);\n return maxelem(tmin) <= minelem(tmax);\n }\n\n} //namespace cg: : renderer\n"},"omp_formatted":{"kind":"string","value":"#pragma once\n\n#include \"resource.h\"\n\n#include <linalg.h>\n#include <memory>\n#include <omp.h>\n#include <random>\n#include <time.h>\n\nusing namespace linalg::aliases;\n\nnamespace cg::renderer\n{\n struct ray\n {\n ray(float3 position, float3 direction):position(position)\n {\n this->direction = normalize(direction);\n }\n float3 position;\n float3 direction;\n };\n\n struct payload\n {\n float t;\n float3 bary;\n cg: : color color;\n };\n\n template < typename VB >\n struct triangle\n {\n triangle(const VB & vertex_a, const VB & vertex_b, const VB & vertex_c);\n\n float3 a;\n float3 b;\n float3 c;\n\n float3 ba;\n float3 ca;\n\n float3 na;\n float3 nb;\n float3 nc;\n\n float3 ambient;\n float3 diffuse;\n float3 emissive;\n };\n\n template < typename VB >\n inline triangle < VB >: : triangle(const VB & vertex_a, const VB & vertex_b, const VB & vertex_c)\n {\n a = float3\n {\n vertex_a.x, vertex_a.y, vertex_a.z\n };\n b = float3\n {\n vertex_b.x, vertex_b.y, vertex_b.z\n };\n c = float3\n {\n vertex_c.x, vertex_c.y, vertex_c.z\n };\n\n ba = b - a;\n ca = c - a;\n\n na = float3\n {\n vertex_a.nx, vertex_a.ny, vertex_a.nz\n };\n nb = float3\n {\n vertex_b.nx, vertex_b.ny, vertex_b.nz\n };\n nc = float3\n {\n vertex_c.nx, vertex_c.ny, vertex_c.nz\n };\n\n ambient =\n {\n vertex_a.ambient_r,\n vertex_a.ambient_g,\n vertex_a.ambient_b,\n };\n diffuse =\n {\n vertex_a.diffuse_r,\n vertex_a.diffuse_g,\n vertex_a.diffuse_b,\n };\n emissive =\n {\n vertex_a.emissive_r,\n vertex_a.emissive_g,\n vertex_a.emissive_b,\n };\n }\n\n template < typename VB >\n class aabb\n {\npublic:\n void add_triangle(const triangle < VB > triangle);\n const std::vector < triangle < VB >> &get_traingles() const;\n bool aabb_test(const ray & ray)const;\n\nprotected:\nstd: : vector < triangle < VB >> triangles;\n\n float3 aabb_min;\n float3 aabb_max;\n };\n\n struct light\n {\n float3 position;\n float3 color;\n };\n\n template < typename VB, typename RT >\n class raytracer\n {\npublic:\n raytracer()\n {\n };\n ~raytracer()\n {\n };\n\n void set_render_target(std::shared_ptr < resource < RT >> in_render_target);\n void clear_render_target(const RT & in_clear_value);\n void set_viewport(size_t in_width, size_t in_height);\n\n void set_per_shape_vertex_buffer(\n std::vector < std::shared_ptr < cg::resource < VB >> >in_per_shape_vertex_buffer);\n void build_acceleration_structure();\nstd: : vector < aabb < VB >> acceleration_structures;\n\n void ray_generation(float3 position, float3 direction, float3 right, float3 up);\n\n payload trace_ray(const ray & ray, size_t depth, float max_t = 1000. f, float min_t = 0.001 f)const;\n payload intersection_shader(const triangle < VB > &triangle, const ray & ray)const;\n\nstd: : function < payload(const ray & ray)>miss_shader = nullptr;\nstd: : function < payload(const ray & ray, payload & payload, const triangle < VB > &triangle)>closest_hit_shader =\n nullptr;\nstd: : function < payload(const ray & ray, payload & payload, const triangle < VB > &triangle)>any_hit_shader =\n nullptr;\n\n\nprotected:\nstd: : shared_ptr < cg: :resource < RT >> render_target;\nstd: : vector < std: : shared_ptr < cg: :resource < VB >> >per_shape_vertex_buffer;\n\n float get_random(const int thread_num, float range = 0.1 f)const;\n\n size_t width = 1920;\n size_t height = 1080;\n };\n\n template < typename VB, typename RT >\n inline void raytracer < VB, RT >::set_render_target(std::shared_ptr < resource < RT >> in_render_target)\n {\n render_target = in_render_target;\n }\n\n template < typename VB, typename RT >\n inline void raytracer < VB, RT >::clear_render_target(const RT & in_clear_value)\n {\n for (size_t i = 0; i < render_target->get_number_of_elements(); i++)\n {\n render_target->item(i) = in_clear_value;\n }\n }\n\n template < typename VB, typename RT >\n inline void raytracer < VB, RT >::set_per_shape_vertex_buffer(\n std::vector < std::shared_ptr < cg::resource < VB >> >in_per_shape_vertex_buffer)\n {\n per_shape_vertex_buffer = in_per_shape_vertex_buffer;\n }\n\n template < typename VB, typename RT >\n inline void raytracer < VB, RT >::build_acceleration_structure()\n {\n for (auto & vertex_buffer:per_shape_vertex_buffer)\n {\n size_t vertex_id = 0;\n aabb < VB > aabb;\n\n while (vertex_id < vertex_buffer->get_number_of_elements())\n {\n triangle < VB > triangle(\n vertex_buffer->item(vertex_id++), vertex_buffer->item(vertex_id++),\n vertex_buffer->item(vertex_id++));\n aabb.add_triangle(triangle);\n }\n\n acceleration_structures.push_back(aabb);\n }\n }\n\n template < typename VB, typename RT >\n inline void raytracer < VB, RT >::set_viewport(size_t in_width, size_t in_height)\n {\n width = in_width;\n height = in_height;\n }\n\n template < typename VB, typename RT >\n inline void raytracer < VB, RT >::ray_generation(\n float3 position, float3 direction, float3 right, float3 up)\n {\n for (int x = 0; x < width; x++)\n {\n#pragma omp parallel for\n for (int y = 0; y < height; y++)\n {\n //from[0, width - 1] to[-1, 1]\n float u = 2. f * x / static_cast < float >(width - 1) - 1. f;\n u *= static_cast < float >(width) / static_cast < float >(height);\n float v = 2. f * y / static_cast < float >(height - 1) - 1. f;\n\n float3 ray_direction = direction + u * right - v * up;\n ray ray(position, ray_direction);\n\n payload payload = trace_ray(ray, 1);\n\n render_target->item(x, y) = RT: : from_color(payload.color);\n }\n }\n }\n\n template < typename VB, typename RT >\n inline payload\n raytracer < VB, RT >: : trace_ray(const ray & ray, size_t depth, float max_t, float min_t)const\n {\n if (depth == 0)\n {\n return miss_shader(ray);\n }\n depth--;\n\n payload closest_hit_payload = {};\n closest_hit_payload.t = max_t;\n const triangle < VB > *closest_triangle = nullptr;\n\nfor (auto & aabb: acceleration_structures)\n {\n if (!aabb.aabb_test(ray))\n continue;\n\n for (auto & triangle:aabb.get_traingles())\n {\n payload payload = intersection_shader(triangle, ray);\n\n if (payload.t > min_t && payload.t < closest_hit_payload.t)\n {\n closest_hit_payload = payload;\n closest_triangle = ▵\n if (any_hit_shader)\n return any_hit_shader(ray, payload, triangle);\n }\n }\n }\n if (closest_hit_payload.t < max_t)\n {\n if (closest_hit_shader)\n {\n return closest_hit_shader(ray, closest_hit_payload, *closest_triangle);\n }\n }\n return miss_shader(ray);\n }\n\n template < typename VB, typename RT >\n inline payload\nraytracer < VB, RT >: :intersection_shader(const triangle < VB > &triangle, const ray & ray)const\n {\n payload payload\n {\n };\n payload.t = -1. f;\n\n float3 pvec = cross(ray.direction, triangle.ca);\n float det = dot(triangle.ba, pvec);\n\n const float eps = 1e-8 f;\n if (abs(det) < eps)\n {\n return payload;\n }\n float inv_det = 1. f / det;\n float3 tvec = ray.position - triangle.a;\n float u = dot(tvec, pvec) * inv_det;\n if (u < 0. f || u > 1. f)\n {\n return payload;\n }\n float3 qvec = cross(tvec, triangle.ba);\n float v = dot(ray.direction, qvec) * inv_det;\n if (v < 0. f || (u + v) > 1. f)\n {\n return payload;\n }\n payload.t = dot(triangle.ca, qvec) * inv_det;\n payload.bary = float3\n {\n 1. f - u - v, u, v\n };\n return payload;\n }\n\n template < typename VB, typename RT >\n inline float raytracer < VB, RT >::get_random(const int thread_num, const float range)const\n {\n static std::default_random_engine generator(thread_num);\n static std::normal_distribution < float >distribution(0. f, range);\n return distribution(generator);\n }\n\n\n template < typename VB >\n inline void aabb < VB >::add_triangle(const triangle < VB > triangle)\n {\n if (triangles.empty())\n aabb_max = aabb_min = triangle.a;\n\n triangles.push_back(triangle);\n\n aabb_max = max(triangle.a, aabb_max);\n aabb_max = max(triangle.b, aabb_max);\n aabb_max = max(triangle.c, aabb_max);\n\n aabb_min = min(triangle.a, aabb_min);\n aabb_min = min(triangle.b, aabb_min);\n aabb_min = min(triangle.c, aabb_min);\n }\n\n template < typename VB >\n inline const std::vector < triangle < VB >> &aabb < VB >::get_traingles() const\n {\n return triangles;\n }\n\n template < typename VB >\n inline bool aabb < VB >: : aabb_test(const ray & ray)const\n {\n float3 inv_ray_direction = float3(1. f) / ray.direction;\n float3 t0 = (aabb_max - ray.position) * inv_ray_direction;\n float3 t1 = (aabb_min - ray.position) * inv_ray_direction;\n float3 tmin = min(t0, t1);\n float3 tmax = max(t0, t1);\n return maxelem(tmin) <= minelem(tmax);\n }\n\n} //namespace cg: : renderer\n"}}},{"rowIdx":97,"cells":{"source":{"kind":"string","value":"matrix.c"},"original_c":{"kind":"string","value":"/*\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% %\n% %\n% %\n% M M AAA TTTTT RRRR IIIII X X %\n% MM MM A A T R R I X X %\n% M M M AAAAA T RRRR I X %\n% M M A A T R R I X X %\n% M M A A T R R IIIII X X %\n% %\n% %\n% MagickCore Matrix Methods %\n% %\n% Software Design %\n% Cristy %\n% August 2007 %\n% %\n% %\n% Copyright 1999-2017 ImageMagick Studio LLC, a non-profit organization %\n% dedicated to making software imaging solutions freely available. %\n% %\n% You may not use this file except in compliance with the License. You may %\n% obtain a copy of the License at %\n% %\n% http://www.imagemagick.org/script/license.php %\n% %\n% Unless required by applicable law or agreed to in writing, software %\n% distributed under the License is distributed on an \"AS IS\" BASIS, %\n% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %\n% See the License for the specific language governing permissions and %\n% limitations under the License. %\n% %\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n%\n%\n*/\n\f\n/*\n Include declarations.\n*/\n#include \"MagickCore/studio.h\"\n#include \"MagickCore/blob.h\"\n#include \"MagickCore/blob-private.h\"\n#include \"MagickCore/cache.h\"\n#include \"MagickCore/exception.h\"\n#include \"MagickCore/exception-private.h\"\n#include \"MagickCore/image-private.h\"\n#include \"MagickCore/matrix.h\"\n#include \"MagickCore/memory_.h\"\n#include \"MagickCore/pixel-accessor.h\"\n#include \"MagickCore/pixel-private.h\"\n#include \"MagickCore/resource_.h\"\n#include \"MagickCore/semaphore.h\"\n#include \"MagickCore/thread-private.h\"\n#include \"MagickCore/utility.h\"\n\f\n/*\n Typedef declaration.\n*/\nstruct _MatrixInfo\n{\n CacheType\n type;\n\n size_t\n columns,\n rows,\n stride;\n\n MagickSizeType\n length;\n\n MagickBooleanType\n mapped,\n synchronize;\n\n char\n path[MagickPathExtent];\n\n int\n file;\n\n void\n *elements;\n\n SemaphoreInfo\n *semaphore;\n\n size_t\n signature;\n};\n\f\n/*\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% %\n% %\n% %\n% A c q u i r e M a t r i x I n f o %\n% %\n% %\n% %\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n%\n% AcquireMatrixInfo() allocates the ImageInfo structure.\n%\n% The format of the AcquireMatrixInfo method is:\n%\n% MatrixInfo *AcquireMatrixInfo(const size_t columns,const size_t rows,\n% const size_t stride,ExceptionInfo *exception)\n%\n% A description of each parameter follows:\n%\n% o columns: the matrix columns.\n%\n% o rows: the matrix rows.\n%\n% o stride: the matrix stride.\n%\n% o exception: return any errors or warnings in this structure.\n%\n*/\n\n#if defined(SIGBUS)\nstatic void MatrixSignalHandler(int status)\n{\n ThrowFatalException(CacheFatalError,\"UnableToExtendMatrixCache\");\n}\n#endif\n\nstatic inline MagickOffsetType WriteMatrixElements(\n const MatrixInfo *magick_restrict matrix_info,const MagickOffsetType offset,\n const MagickSizeType length,const unsigned char *magick_restrict buffer)\n{\n register MagickOffsetType\n i;\n\n ssize_t\n count;\n\n#if !defined(MAGICKCORE_HAVE_PWRITE)\n LockSemaphoreInfo(matrix_info->semaphore);\n if (lseek(matrix_info->file,offset,SEEK_SET) < 0)\n {\n UnlockSemaphoreInfo(matrix_info->semaphore);\n return((MagickOffsetType) -1);\n }\n#endif\n count=0;\n for (i=0; i < (MagickOffsetType) length; i+=count)\n {\n#if !defined(MAGICKCORE_HAVE_PWRITE)\n count=write(matrix_info->file,buffer+i,(size_t) MagickMin(length-i,\n (MagickSizeType) SSIZE_MAX));\n#else\n count=pwrite(matrix_info->file,buffer+i,(size_t) MagickMin(length-i,\n (MagickSizeType) SSIZE_MAX),(off_t) (offset+i));\n#endif\n if (count <= 0)\n {\n count=0;\n if (errno != EINTR)\n break;\n }\n }\n#if !defined(MAGICKCORE_HAVE_PWRITE)\n UnlockSemaphoreInfo(matrix_info->semaphore);\n#endif\n return(i);\n}\n\nstatic MagickBooleanType SetMatrixExtent(\n MatrixInfo *magick_restrict matrix_info,\n MagickSizeType length)\n{\n MagickOffsetType\n count,\n extent,\n offset;\n\n if (length != (MagickSizeType) ((MagickOffsetType) length))\n return(MagickFalse);\n offset=(MagickOffsetType) lseek(matrix_info->file,0,SEEK_END);\n if (offset < 0)\n return(MagickFalse);\n if ((MagickSizeType) offset >= length)\n return(MagickTrue);\n extent=(MagickOffsetType) length-1;\n count=WriteMatrixElements(matrix_info,extent,1,(const unsigned char *) \"\");\n#if defined(MAGICKCORE_HAVE_POSIX_FALLOCATE)\n if (matrix_info->synchronize != MagickFalse)\n (void) posix_fallocate(matrix_info->file,offset+1,extent-offset);\n#endif\n#if defined(SIGBUS)\n (void) signal(SIGBUS,MatrixSignalHandler);\n#endif\n return(count != (MagickOffsetType) 1 ? MagickFalse : MagickTrue);\n}\n\nMagickExport MatrixInfo *AcquireMatrixInfo(const size_t columns,\n const size_t rows,const size_t stride,ExceptionInfo *exception)\n{\n char\n *synchronize;\n\n MagickBooleanType\n status;\n\n MatrixInfo\n *matrix_info;\n\n matrix_info=(MatrixInfo *) AcquireMagickMemory(sizeof(*matrix_info));\n if (matrix_info == (MatrixInfo *) NULL)\n return((MatrixInfo *) NULL);\n (void) ResetMagickMemory(matrix_info,0,sizeof(*matrix_info));\n matrix_info->signature=MagickCoreSignature;\n matrix_info->columns=columns;\n matrix_info->rows=rows;\n matrix_info->stride=stride;\n matrix_info->semaphore=AcquireSemaphoreInfo();\n synchronize=GetEnvironmentValue(\"MAGICK_SYNCHRONIZE\");\n if (synchronize != (const char *) NULL)\n {\n matrix_info->synchronize=IsStringTrue(synchronize);\n synchronize=DestroyString(synchronize);\n }\n matrix_info->length=(MagickSizeType) columns*rows*stride;\n if (matrix_info->columns != (size_t) (matrix_info->length/rows/stride))\n {\n (void) ThrowMagickException(exception,GetMagickModule(),CacheError,\n \"CacheResourcesExhausted\",\"`%s'\",\"matrix cache\");\n return(DestroyMatrixInfo(matrix_info));\n }\n matrix_info->type=MemoryCache;\n status=AcquireMagickResource(AreaResource,matrix_info->length);\n if ((status != MagickFalse) &&\n (matrix_info->length == (MagickSizeType) ((size_t) matrix_info->length)))\n {\n status=AcquireMagickResource(MemoryResource,matrix_info->length);\n if (status != MagickFalse)\n {\n matrix_info->mapped=MagickFalse;\n matrix_info->elements=AcquireMagickMemory((size_t)\n matrix_info->length);\n if (matrix_info->elements == NULL)\n {\n matrix_info->mapped=MagickTrue;\n matrix_info->elements=MapBlob(-1,IOMode,0,(size_t)\n matrix_info->length);\n }\n if (matrix_info->elements == (unsigned short *) NULL)\n RelinquishMagickResource(MemoryResource,matrix_info->length);\n }\n }\n matrix_info->file=(-1);\n if (matrix_info->elements == (unsigned short *) NULL)\n {\n status=AcquireMagickResource(DiskResource,matrix_info->length);\n if (status == MagickFalse)\n {\n (void) ThrowMagickException(exception,GetMagickModule(),CacheError,\n \"CacheResourcesExhausted\",\"`%s'\",\"matrix cache\");\n return(DestroyMatrixInfo(matrix_info));\n }\n matrix_info->type=DiskCache;\n (void) AcquireMagickResource(MemoryResource,matrix_info->length);\n matrix_info->file=AcquireUniqueFileResource(matrix_info->path);\n if (matrix_info->file == -1)\n return(DestroyMatrixInfo(matrix_info));\n status=AcquireMagickResource(MapResource,matrix_info->length);\n if (status != MagickFalse)\n {\n status=SetMatrixExtent(matrix_info,matrix_info->length);\n if (status != MagickFalse)\n {\n matrix_info->elements=(void *) MapBlob(matrix_info->file,IOMode,0,\n (size_t) matrix_info->length);\n if (matrix_info->elements != NULL)\n matrix_info->type=MapCache;\n else\n RelinquishMagickResource(MapResource,matrix_info->length);\n }\n }\n }\n return(matrix_info);\n}\n\f\n/*\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% %\n% %\n% %\n% A c q u i r e M a g i c k M a t r i x %\n% %\n% %\n% %\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n%\n% AcquireMagickMatrix() allocates and returns a matrix in the form of an\n% array of pointers to an array of doubles, with all values pre-set to zero.\n%\n% This used to generate the two dimensional matrix, and vectors required\n% for the GaussJordanElimination() method below, solving some system of\n% simultanious equations.\n%\n% The format of the AcquireMagickMatrix method is:\n%\n% double **AcquireMagickMatrix(const size_t number_rows,\n% const size_t size)\n%\n% A description of each parameter follows:\n%\n% o number_rows: the number pointers for the array of pointers\n% (first dimension).\n%\n% o size: the size of the array of doubles each pointer points to\n% (second dimension).\n%\n*/\nMagickExport double **AcquireMagickMatrix(const size_t number_rows,\n const size_t size)\n{\n double\n **matrix;\n\n register ssize_t\n i,\n j;\n\n matrix=(double **) AcquireQuantumMemory(number_rows,sizeof(*matrix));\n if (matrix == (double **) NULL)\n return((double **) NULL);\n for (i=0; i < (ssize_t) number_rows; i++)\n {\n matrix[i]=(double *) AcquireQuantumMemory(size,sizeof(*matrix[i]));\n if (matrix[i] == (double *) NULL)\n {\n for (j=0; j < i; j++)\n matrix[j]=(double *) RelinquishMagickMemory(matrix[j]);\n matrix=(double **) RelinquishMagickMemory(matrix);\n return((double **) NULL);\n }\n for (j=0; j < (ssize_t) size; j++)\n matrix[i][j]=0.0;\n }\n return(matrix);\n}\n\f\n/*\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% %\n% %\n% %\n% D e s t r o y M a t r i x I n f o %\n% %\n% %\n% %\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n%\n% DestroyMatrixInfo() dereferences a matrix, deallocating memory associated\n% with the matrix.\n%\n% The format of the DestroyImage method is:\n%\n% MatrixInfo *DestroyMatrixInfo(MatrixInfo *matrix_info)\n%\n% A description of each parameter follows:\n%\n% o matrix_info: the matrix.\n%\n*/\nMagickExport MatrixInfo *DestroyMatrixInfo(MatrixInfo *matrix_info)\n{\n assert(matrix_info != (MatrixInfo *) NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n LockSemaphoreInfo(matrix_info->semaphore);\n switch (matrix_info->type)\n {\n case MemoryCache:\n {\n if (matrix_info->mapped == MagickFalse)\n matrix_info->elements=RelinquishMagickMemory(matrix_info->elements);\n else\n {\n (void) UnmapBlob(matrix_info->elements,(size_t) matrix_info->length);\n matrix_info->elements=(unsigned short *) NULL;\n }\n RelinquishMagickResource(MemoryResource,matrix_info->length);\n break;\n }\n case MapCache:\n {\n (void) UnmapBlob(matrix_info->elements,(size_t) matrix_info->length);\n matrix_info->elements=NULL;\n RelinquishMagickResource(MapResource,matrix_info->length);\n }\n case DiskCache:\n {\n if (matrix_info->file != -1)\n (void) close(matrix_info->file);\n (void) RelinquishUniqueFileResource(matrix_info->path);\n RelinquishMagickResource(DiskResource,matrix_info->length);\n break;\n }\n default:\n break;\n }\n UnlockSemaphoreInfo(matrix_info->semaphore);\n RelinquishSemaphoreInfo(&matrix_info->semaphore);\n return((MatrixInfo *) RelinquishMagickMemory(matrix_info));\n}\n\f\n/*\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% %\n% %\n% %\n+ G a u s s J o r d a n E l i m i n a t i o n %\n% %\n% %\n% %\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n%\n% GaussJordanElimination() returns a matrix in reduced row echelon form,\n% while simultaneously reducing and thus solving the augumented results\n% matrix.\n%\n% See also http://en.wikipedia.org/wiki/Gauss-Jordan_elimination\n%\n% The format of the GaussJordanElimination method is:\n%\n% MagickBooleanType GaussJordanElimination(double **matrix,\n% double **vectors,const size_t rank,const size_t number_vectors)\n%\n% A description of each parameter follows:\n%\n% o matrix: the matrix to be reduced, as an 'array of row pointers'.\n%\n% o vectors: the additional matrix argumenting the matrix for row reduction.\n% Producing an 'array of column vectors'.\n%\n% o rank: The size of the matrix (both rows and columns).\n% Also represents the number terms that need to be solved.\n%\n% o number_vectors: Number of vectors columns, argumenting the above matrix.\n% Usally 1, but can be more for more complex equation solving.\n%\n% Note that the 'matrix' is given as a 'array of row pointers' of rank size.\n% That is values can be assigned as matrix[row][column] where 'row' is\n% typically the equation, and 'column' is the term of the equation.\n% That is the matrix is in the form of a 'row first array'.\n%\n% However 'vectors' is a 'array of column pointers' which can have any number\n% of columns, with each column array the same 'rank' size as 'matrix'.\n%\n% This allows for simpler handling of the results, especially is only one\n% column 'vector' is all that is required to produce the desired solution.\n%\n% For example, the 'vectors' can consist of a pointer to a simple array of\n% doubles. when only one set of simultanious equations is to be solved from\n% the given set of coefficient weighted terms.\n%\n% double **matrix = AcquireMagickMatrix(8UL,8UL);\n% double coefficents[8];\n% ...\n% GaussJordanElimination(matrix, &coefficents, 8UL, 1UL);\n%\n% However by specifing more 'columns' (as an 'array of vector columns',\n% you can use this function to solve a set of 'separable' equations.\n%\n% For example a distortion function where u = U(x,y) v = V(x,y)\n% And the functions U() and V() have separate coefficents, but are being\n% generated from a common x,y->u,v data set.\n%\n% Another example is generation of a color gradient from a set of colors at\n% specific coordients, such as a list x,y -> r,g,b,a.\n%\n% You can also use the 'vectors' to generate an inverse of the given 'matrix'\n% though as a 'column first array' rather than a 'row first array'. For\n% details see http://en.wikipedia.org/wiki/Gauss-Jordan_elimination\n%\n*/\nMagickPrivate MagickBooleanType GaussJordanElimination(double **matrix,\n double **vectors,const size_t rank,const size_t number_vectors)\n{\n#define GaussJordanSwap(x,y) \\\n{ \\\n if ((x) != (y)) \\\n { \\\n (x)+=(y); \\\n (y)=(x)-(y); \\\n (x)=(x)-(y); \\\n } \\\n}\n\n double\n max,\n scale;\n\n register ssize_t\n i,\n j,\n k;\n\n ssize_t\n column,\n *columns,\n *pivots,\n row,\n *rows;\n\n columns=(ssize_t *) AcquireQuantumMemory(rank,sizeof(*columns));\n rows=(ssize_t *) AcquireQuantumMemory(rank,sizeof(*rows));\n pivots=(ssize_t *) AcquireQuantumMemory(rank,sizeof(*pivots));\n if ((rows == (ssize_t *) NULL) || (columns == (ssize_t *) NULL) ||\n (pivots == (ssize_t *) NULL))\n {\n if (pivots != (ssize_t *) NULL)\n pivots=(ssize_t *) RelinquishMagickMemory(pivots);\n if (columns != (ssize_t *) NULL)\n columns=(ssize_t *) RelinquishMagickMemory(columns);\n if (rows != (ssize_t *) NULL)\n rows=(ssize_t *) RelinquishMagickMemory(rows);\n return(MagickFalse);\n }\n (void) ResetMagickMemory(columns,0,rank*sizeof(*columns));\n (void) ResetMagickMemory(rows,0,rank*sizeof(*rows));\n (void) ResetMagickMemory(pivots,0,rank*sizeof(*pivots));\n column=0;\n row=0;\n for (i=0; i < (ssize_t) rank; i++)\n {\n max=0.0;\n for (j=0; j < (ssize_t) rank; j++)\n if (pivots[j] != 1)\n {\n for (k=0; k < (ssize_t) rank; k++)\n if (pivots[k] != 0)\n {\n if (pivots[k] > 1)\n return(MagickFalse);\n }\n else\n if (fabs(matrix[j][k]) >= max)\n {\n max=fabs(matrix[j][k]);\n row=j;\n column=k;\n }\n }\n pivots[column]++;\n if (row != column)\n {\n for (k=0; k < (ssize_t) rank; k++)\n GaussJordanSwap(matrix[row][k],matrix[column][k]);\n for (k=0; k < (ssize_t) number_vectors; k++)\n GaussJordanSwap(vectors[k][row],vectors[k][column]);\n }\n rows[i]=row;\n columns[i]=column;\n if (matrix[column][column] == 0.0)\n return(MagickFalse); /* sigularity */\n scale=PerceptibleReciprocal(matrix[column][column]);\n matrix[column][column]=1.0;\n for (j=0; j < (ssize_t) rank; j++)\n matrix[column][j]*=scale;\n for (j=0; j < (ssize_t) number_vectors; j++)\n vectors[j][column]*=scale;\n for (j=0; j < (ssize_t) rank; j++)\n if (j != column)\n {\n scale=matrix[j][column];\n matrix[j][column]=0.0;\n for (k=0; k < (ssize_t) rank; k++)\n matrix[j][k]-=scale*matrix[column][k];\n for (k=0; k < (ssize_t) number_vectors; k++)\n vectors[k][j]-=scale*vectors[k][column];\n }\n }\n for (j=(ssize_t) rank-1; j >= 0; j--)\n if (columns[j] != rows[j])\n for (i=0; i < (ssize_t) rank; i++)\n GaussJordanSwap(matrix[i][rows[j]],matrix[i][columns[j]]);\n pivots=(ssize_t *) RelinquishMagickMemory(pivots);\n rows=(ssize_t *) RelinquishMagickMemory(rows);\n columns=(ssize_t *) RelinquishMagickMemory(columns);\n return(MagickTrue);\n}\n\f\n/*\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% %\n% %\n% %\n% G e t M a t r i x C o l u m n s %\n% %\n% %\n% %\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n%\n% GetMatrixColumns() returns the number of columns in the matrix.\n%\n% The format of the GetMatrixColumns method is:\n%\n% size_t GetMatrixColumns(const MatrixInfo *matrix_info)\n%\n% A description of each parameter follows:\n%\n% o matrix_info: the matrix.\n%\n*/\nMagickExport size_t GetMatrixColumns(const MatrixInfo *matrix_info)\n{\n assert(matrix_info != (MatrixInfo *) NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n return(matrix_info->columns);\n}\n\f\n/*\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% %\n% %\n% %\n% G e t M a t r i x E l e m e n t %\n% %\n% %\n% %\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n%\n% GetMatrixElement() returns the specifed element in the matrix.\n%\n% The format of the GetMatrixElement method is:\n%\n% MagickBooleanType GetMatrixElement(const MatrixInfo *matrix_info,\n% const ssize_t x,const ssize_t y,void *value)\n%\n% A description of each parameter follows:\n%\n% o matrix_info: the matrix columns.\n%\n% o x: the matrix x-offset.\n%\n% o y: the matrix y-offset.\n%\n% o value: return the matrix element in this buffer.\n%\n*/\n\nstatic inline ssize_t EdgeX(const ssize_t x,const size_t columns)\n{\n if (x < 0L)\n return(0L);\n if (x >= (ssize_t) columns)\n return((ssize_t) (columns-1));\n return(x);\n}\n\nstatic inline ssize_t EdgeY(const ssize_t y,const size_t rows)\n{\n if (y < 0L)\n return(0L);\n if (y >= (ssize_t) rows)\n return((ssize_t) (rows-1));\n return(y);\n}\n\nstatic inline MagickOffsetType ReadMatrixElements(\n const MatrixInfo *magick_restrict matrix_info,const MagickOffsetType offset,\n const MagickSizeType length,unsigned char *magick_restrict buffer)\n{\n register MagickOffsetType\n i;\n\n ssize_t\n count;\n\n#if !defined(MAGICKCORE_HAVE_PREAD)\n LockSemaphoreInfo(matrix_info->semaphore);\n if (lseek(matrix_info->file,offset,SEEK_SET) < 0)\n {\n UnlockSemaphoreInfo(matrix_info->semaphore);\n return((MagickOffsetType) -1);\n }\n#endif\n count=0;\n for (i=0; i < (MagickOffsetType) length; i+=count)\n {\n#if !defined(MAGICKCORE_HAVE_PREAD)\n count=read(matrix_info->file,buffer+i,(size_t) MagickMin(length-i,\n (MagickSizeType) SSIZE_MAX));\n#else\n count=pread(matrix_info->file,buffer+i,(size_t) MagickMin(length-i,\n (MagickSizeType) SSIZE_MAX),(off_t) (offset+i));\n#endif\n if (count <= 0)\n {\n count=0;\n if (errno != EINTR)\n break;\n }\n }\n#if !defined(MAGICKCORE_HAVE_PREAD)\n UnlockSemaphoreInfo(matrix_info->semaphore);\n#endif\n return(i);\n}\n\nMagickExport MagickBooleanType GetMatrixElement(const MatrixInfo *matrix_info,\n const ssize_t x,const ssize_t y,void *value)\n{\n MagickOffsetType\n count,\n i;\n\n assert(matrix_info != (const MatrixInfo *) NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n i=(MagickOffsetType) EdgeY(y,matrix_info->rows)*matrix_info->columns+\n EdgeX(x,matrix_info->columns);\n if (matrix_info->type != DiskCache)\n {\n (void) memcpy(value,(unsigned char *) matrix_info->elements+i*\n matrix_info->stride,matrix_info->stride);\n return(MagickTrue);\n }\n count=ReadMatrixElements(matrix_info,i*matrix_info->stride,\n matrix_info->stride,(unsigned char *) value);\n if (count != (MagickOffsetType) matrix_info->stride)\n return(MagickFalse);\n return(MagickTrue);\n}\n\f\n/*\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% %\n% %\n% %\n% G e t M a t r i x R o w s %\n% %\n% %\n% %\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n%\n% GetMatrixRows() returns the number of rows in the matrix.\n%\n% The format of the GetMatrixRows method is:\n%\n% size_t GetMatrixRows(const MatrixInfo *matrix_info)\n%\n% A description of each parameter follows:\n%\n% o matrix_info: the matrix.\n%\n*/\nMagickExport size_t GetMatrixRows(const MatrixInfo *matrix_info)\n{\n assert(matrix_info != (const MatrixInfo *) NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n return(matrix_info->rows);\n}\n\f\n/*\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% %\n% %\n% %\n+ L e a s t S q u a r e s A d d T e r m s %\n% %\n% %\n% %\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n%\n% LeastSquaresAddTerms() adds one set of terms and associate results to the\n% given matrix and vectors for solving using least-squares function fitting.\n%\n% The format of the AcquireMagickMatrix method is:\n%\n% void LeastSquaresAddTerms(double **matrix,double **vectors,\n% const double *terms,const double *results,const size_t rank,\n% const size_t number_vectors);\n%\n% A description of each parameter follows:\n%\n% o matrix: the square matrix to add given terms/results to.\n%\n% o vectors: the result vectors to add terms/results to.\n%\n% o terms: the pre-calculated terms (without the unknown coefficent\n% weights) that forms the equation being added.\n%\n% o results: the result(s) that should be generated from the given terms\n% weighted by the yet-to-be-solved coefficents.\n%\n% o rank: the rank or size of the dimensions of the square matrix.\n% Also the length of vectors, and number of terms being added.\n%\n% o number_vectors: Number of result vectors, and number or results being\n% added. Also represents the number of separable systems of equations\n% that is being solved.\n%\n% Example of use...\n%\n% 2 dimensional Affine Equations (which are separable)\n% c0*x + c2*y + c4*1 => u\n% c1*x + c3*y + c5*1 => v\n%\n% double **matrix = AcquireMagickMatrix(3UL,3UL);\n% double **vectors = AcquireMagickMatrix(2UL,3UL);\n% double terms[3], results[2];\n% ...\n% for each given x,y -> u,v\n% terms[0] = x;\n% terms[1] = y;\n% terms[2] = 1;\n% results[0] = u;\n% results[1] = v;\n% LeastSquaresAddTerms(matrix,vectors,terms,results,3UL,2UL);\n% ...\n% if ( GaussJordanElimination(matrix,vectors,3UL,2UL) ) {\n% c0 = vectors[0][0];\n% c2 = vectors[0][1];\n% c4 = vectors[0][2];\n% c1 = vectors[1][0];\n% c3 = vectors[1][1];\n% c5 = vectors[1][2];\n% }\n% else\n% printf(\"Matrix unsolvable\\n);\n% RelinquishMagickMatrix(matrix,3UL);\n% RelinquishMagickMatrix(vectors,2UL);\n%\n*/\nMagickPrivate void LeastSquaresAddTerms(double **matrix,double **vectors,\n const double *terms,const double *results,const size_t rank,\n const size_t number_vectors)\n{\n register ssize_t\n i,\n j;\n\n for (j=0; j < (ssize_t) rank; j++)\n {\n for (i=0; i < (ssize_t) rank; i++)\n matrix[i][j]+=terms[i]*terms[j];\n for (i=0; i < (ssize_t) number_vectors; i++)\n vectors[i][j]+=results[i]*terms[j];\n }\n}\n\f\n/*\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% %\n% %\n% %\n% M a t r i x T o I m a g e %\n% %\n% %\n% %\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n%\n% MatrixToImage() returns a matrix as an image. The matrix elements must be\n% of type double otherwise nonsense is returned.\n%\n% The format of the MatrixToImage method is:\n%\n% Image *MatrixToImage(const MatrixInfo *matrix_info,\n% ExceptionInfo *exception)\n%\n% A description of each parameter follows:\n%\n% o matrix_info: the matrix.\n%\n% o exception: return any errors or warnings in this structure.\n%\n*/\nMagickExport Image *MatrixToImage(const MatrixInfo *matrix_info,\n ExceptionInfo *exception)\n{\n CacheView\n *image_view;\n\n double\n max_value,\n min_value,\n scale_factor,\n value;\n\n Image\n *image;\n\n MagickBooleanType\n status;\n\n ssize_t\n y;\n\n assert(matrix_info != (const MatrixInfo *) NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n assert(exception != (ExceptionInfo *) NULL);\n assert(exception->signature == MagickCoreSignature);\n if (matrix_info->stride < sizeof(double))\n return((Image *) NULL);\n /*\n Determine range of matrix.\n */\n (void) GetMatrixElement(matrix_info,0,0,&value);\n min_value=value;\n max_value=value;\n for (y=0; y < (ssize_t) matrix_info->rows; y++)\n {\n register ssize_t\n x;\n\n for (x=0; x < (ssize_t) matrix_info->columns; x++)\n {\n if (GetMatrixElement(matrix_info,x,y,&value) == MagickFalse)\n continue;\n if (value < min_value)\n min_value=value;\n else\n if (value > max_value)\n max_value=value;\n }\n }\n if ((min_value == 0.0) && (max_value == 0.0))\n scale_factor=0;\n else\n if (min_value == max_value)\n {\n scale_factor=(double) QuantumRange/min_value;\n min_value=0;\n }\n else\n scale_factor=(double) QuantumRange/(max_value-min_value);\n /*\n Convert matrix to image.\n */\n image=AcquireImage((ImageInfo *) NULL,exception);\n image->columns=matrix_info->columns;\n image->rows=matrix_info->rows;\n image->colorspace=GRAYColorspace;\n status=MagickTrue;\n image_view=AcquireAuthenticCacheView(image,exception);\n#if defined(MAGICKCORE_OPENMP_SUPPORT)\n #pragma omp parallel for schedule(static,4) shared(status) \\\n magick_threads(image,image,image->rows,1)\n#endif\n for (y=0; y < (ssize_t) image->rows; y++)\n {\n double\n value;\n\n register Quantum\n *q;\n\n register ssize_t\n x;\n\n if (status == MagickFalse)\n continue;\n q=QueueCacheViewAuthenticPixels(image_view,0,y,image->columns,1,exception);\n if (q == (Quantum *) NULL)\n {\n status=MagickFalse;\n continue;\n }\n for (x=0; x < (ssize_t) image->columns; x++)\n {\n if (GetMatrixElement(matrix_info,x,y,&value) == MagickFalse)\n continue;\n value=scale_factor*(value-min_value);\n *q=ClampToQuantum(value);\n q+=GetPixelChannels(image);\n }\n if (SyncCacheViewAuthenticPixels(image_view,exception) == MagickFalse)\n status=MagickFalse;\n }\n image_view=DestroyCacheView(image_view);\n if (status == MagickFalse)\n image=DestroyImage(image);\n return(image);\n}\n\f\n/*\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% %\n% %\n% %\n% N u l l M a t r i x %\n% %\n% %\n% %\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n%\n% NullMatrix() sets all elements of the matrix to zero.\n%\n% The format of the ResetMagickMemory method is:\n%\n% MagickBooleanType *NullMatrix(MatrixInfo *matrix_info)\n%\n% A description of each parameter follows:\n%\n% o matrix_info: the matrix.\n%\n*/\nMagickExport MagickBooleanType NullMatrix(MatrixInfo *matrix_info)\n{\n register ssize_t\n x;\n\n ssize_t\n count,\n y;\n\n unsigned char\n value;\n\n assert(matrix_info != (const MatrixInfo *) NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n if (matrix_info->type != DiskCache)\n {\n (void) ResetMagickMemory(matrix_info->elements,0,(size_t)\n matrix_info->length);\n return(MagickTrue);\n }\n value=0;\n (void) lseek(matrix_info->file,0,SEEK_SET);\n for (y=0; y < (ssize_t) matrix_info->rows; y++)\n {\n for (x=0; x < (ssize_t) matrix_info->length; x++)\n {\n count=write(matrix_info->file,&value,sizeof(value));\n if (count != (ssize_t) sizeof(value))\n break;\n }\n if (x < (ssize_t) matrix_info->length)\n break;\n }\n return(y < (ssize_t) matrix_info->rows ? MagickFalse : MagickTrue);\n}\n\f\n/*\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% %\n% %\n% %\n% R e l i n q u i s h M a g i c k M a t r i x %\n% %\n% %\n% %\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n%\n% RelinquishMagickMatrix() frees the previously acquired matrix (array of\n% pointers to arrays of doubles).\n%\n% The format of the RelinquishMagickMatrix method is:\n%\n% double **RelinquishMagickMatrix(double **matrix,\n% const size_t number_rows)\n%\n% A description of each parameter follows:\n%\n% o matrix: the matrix to relinquish\n%\n% o number_rows: the first dimension of the acquired matrix (number of\n% pointers)\n%\n*/\nMagickExport double **RelinquishMagickMatrix(double **matrix,\n const size_t number_rows)\n{\n register ssize_t\n i;\n\n if (matrix == (double **) NULL )\n return(matrix);\n for (i=0; i < (ssize_t) number_rows; i++)\n matrix[i]=(double *) RelinquishMagickMemory(matrix[i]);\n matrix=(double **) RelinquishMagickMemory(matrix);\n return(matrix);\n}\n\f\n/*\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% %\n% %\n% %\n% S e t M a t r i x E l e m e n t %\n% %\n% %\n% %\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n%\n% SetMatrixElement() sets the specifed element in the matrix.\n%\n% The format of the SetMatrixElement method is:\n%\n% MagickBooleanType SetMatrixElement(const MatrixInfo *matrix_info,\n% const ssize_t x,const ssize_t y,void *value)\n%\n% A description of each parameter follows:\n%\n% o matrix_info: the matrix columns.\n%\n% o x: the matrix x-offset.\n%\n% o y: the matrix y-offset.\n%\n% o value: set the matrix element to this value.\n%\n*/\n\nMagickExport MagickBooleanType SetMatrixElement(const MatrixInfo *matrix_info,\n const ssize_t x,const ssize_t y,const void *value)\n{\n MagickOffsetType\n count,\n i;\n\n assert(matrix_info != (const MatrixInfo *) NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n i=(MagickOffsetType) y*matrix_info->columns+x;\n if ((i < 0) ||\n ((MagickSizeType) (i*matrix_info->stride) >= matrix_info->length))\n return(MagickFalse);\n if (matrix_info->type != DiskCache)\n {\n (void) memcpy((unsigned char *) matrix_info->elements+i*\n matrix_info->stride,value,matrix_info->stride);\n return(MagickTrue);\n }\n count=WriteMatrixElements(matrix_info,i*matrix_info->stride,\n matrix_info->stride,(unsigned char *) value);\n if (count != (MagickOffsetType) matrix_info->stride)\n return(MagickFalse);\n return(MagickTrue);\n}\n"},"no_omp_formatted":{"kind":"string","value":"\n\n\n/*\n * Include declarations.\n */\n#include \"MagickCore/studio.h\"\n#include \"MagickCore/blob.h\"\n#include \"MagickCore/blob-private.h\"\n#include \"MagickCore/cache.h\"\n#include \"MagickCore/exception.h\"\n#include \"MagickCore/exception-private.h\"\n#include \"MagickCore/image-private.h\"\n#include \"MagickCore/matrix.h\"\n#include \"MagickCore/memory_.h\"\n#include \"MagickCore/pixel-accessor.h\"\n#include \"MagickCore/pixel-private.h\"\n#include \"MagickCore/resource_.h\"\n#include \"MagickCore/semaphore.h\"\n#include \"MagickCore/thread-private.h\"\n#include \"MagickCore/utility.h\"\n\n\n/*\n * Typedef declaration.\n */\nstruct _MatrixInfo\n{\n CacheType\n type;\n\n size_t\n columns,\n rows,\n stride;\n\n MagickSizeType\n length;\n\n MagickBooleanType\n mapped,\n synchronize;\n\n char\n path[MagickPathExtent];\n\n int\n file;\n\n void\n *elements;\n\n SemaphoreInfo\n * semaphore;\n\n size_t\n signature;\n};\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % A c q u i r e M a t r i x I n f o\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % AcquireMatrixInfo() allocates the ImageInfo structure. % % The\n * format of the AcquireMatrixInfo method is: % % MatrixInfo\n * *AcquireMatrixInfo(const size_t columns,const size_t rows, % const\n * size_t stride,ExceptionInfo *exception) % % A description of each\n * parameter follows: % % o columns: the matrix columns. % % o rows:\n * the matrix rows. % % o stride: the matrix stride. % % o exception:\n * return any errors or warnings in this structure. %\n */\n\n#if defined(SIGBUS)\nstatic void \nMatrixSignalHandler(int status)\n{\n ThrowFatalException(CacheFatalError, \"UnableToExtendMatrixCache\");\n}\n\n#endif\n\nstatic inline MagickOffsetType \nWriteMatrixElements(\n const MatrixInfo * magick_restrict matrix_info, const MagickOffsetType offset,\n const MagickSizeType length, const unsigned char *magick_restrict buffer)\n{\n register MagickOffsetType\n i;\n\n ssize_t\n count;\n\n#if !defined(MAGICKCORE_HAVE_PWRITE)\n LockSemaphoreInfo(matrix_info->semaphore);\n if (lseek(matrix_info->file, offset, SEEK_SET) < 0)\n {\n UnlockSemaphoreInfo(matrix_info->semaphore);\n return ((MagickOffsetType) - 1);\n }\n#endif\n count = 0;\n for (i = 0; i < (MagickOffsetType) length; i += count)\n {\n#if !defined(MAGICKCORE_HAVE_PWRITE)\n count = write(matrix_info->file, buffer + i, (size_t) MagickMin(length - i,\n (MagickSizeType) SSIZE_MAX));\n#else\n count = pwrite(matrix_info->file, buffer + i, (size_t) MagickMin(length - i,\n (MagickSizeType) SSIZE_MAX), (off_t) (offset + i));\n#endif\n if (count <= 0)\n {\n count = 0;\n if (errno != EINTR)\n break;\n }\n }\n#if !defined(MAGICKCORE_HAVE_PWRITE)\n UnlockSemaphoreInfo(matrix_info->semaphore);\n#endif\n return (i);\n}\n\nstatic MagickBooleanType \nSetMatrixExtent(\n MatrixInfo * magick_restrict matrix_info,\n MagickSizeType length)\n{\n MagickOffsetType\n count,\n extent,\n offset;\n\n if (length != (MagickSizeType) ((MagickOffsetType) length))\n return (MagickFalse);\n offset = (MagickOffsetType) lseek(matrix_info->file, 0, SEEK_END);\n if (offset < 0)\n return (MagickFalse);\n if ((MagickSizeType) offset >= length)\n return (MagickTrue);\n extent = (MagickOffsetType) length - 1;\n count = WriteMatrixElements(matrix_info, extent, 1, (const unsigned char *)\"\");\n#if defined(MAGICKCORE_HAVE_POSIX_FALLOCATE)\n if (matrix_info->synchronize != MagickFalse)\n (void)posix_fallocate(matrix_info->file, offset + 1, extent - offset);\n#endif\n#if defined(SIGBUS)\n (void)signal(SIGBUS, MatrixSignalHandler);\n#endif\n return (count != (MagickOffsetType) 1 ? MagickFalse : MagickTrue);\n}\n\nMagickExport MatrixInfo *\nAcquireMatrixInfo(const size_t columns,\n const size_t rows, const size_t stride, ExceptionInfo * exception)\n{\n char\n *synchronize;\n\n MagickBooleanType\n status;\n\n MatrixInfo\n * matrix_info;\n\n matrix_info = (MatrixInfo *) AcquireMagickMemory(sizeof(*matrix_info));\n if (matrix_info == (MatrixInfo *) NULL)\n return ((MatrixInfo *) NULL);\n (void)ResetMagickMemory(matrix_info, 0, sizeof(*matrix_info));\n matrix_info->signature = MagickCoreSignature;\n matrix_info->columns = columns;\n matrix_info->rows = rows;\n matrix_info->stride = stride;\n matrix_info->semaphore = AcquireSemaphoreInfo();\n synchronize = GetEnvironmentValue(\"MAGICK_SYNCHRONIZE\");\n if (synchronize != (const char *)NULL)\n {\n matrix_info->synchronize = IsStringTrue(synchronize);\n synchronize = DestroyString(synchronize);\n }\n matrix_info->length = (MagickSizeType) columns *rows * stride;\n if (matrix_info->columns != (size_t) (matrix_info->length / rows / stride))\n {\n (void)ThrowMagickException(exception, GetMagickModule(), CacheError,\n \"CacheResourcesExhausted\", \"`%s'\", \"matrix cache\");\n return (DestroyMatrixInfo(matrix_info));\n }\n matrix_info->type = MemoryCache;\n status = AcquireMagickResource(AreaResource, matrix_info->length);\n if ((status != MagickFalse) &&\n (matrix_info->length == (MagickSizeType) ((size_t) matrix_info->length)))\n {\n status = AcquireMagickResource(MemoryResource, matrix_info->length);\n if (status != MagickFalse)\n {\n matrix_info->mapped = MagickFalse;\n matrix_info->elements = AcquireMagickMemory((size_t)\n matrix_info->length);\n if (matrix_info->elements == NULL)\n {\n matrix_info->mapped = MagickTrue;\n matrix_info->elements = MapBlob(-1, IOMode, 0, (size_t)\n matrix_info->length);\n }\n if (matrix_info->elements == (unsigned short *)NULL)\n RelinquishMagickResource(MemoryResource, matrix_info->length);\n }\n }\n matrix_info->file = (-1);\n if (matrix_info->elements == (unsigned short *)NULL)\n {\n status = AcquireMagickResource(DiskResource, matrix_info->length);\n if (status == MagickFalse)\n {\n (void)ThrowMagickException(exception, GetMagickModule(), CacheError,\n \"CacheResourcesExhausted\", \"`%s'\", \"matrix cache\");\n return (DestroyMatrixInfo(matrix_info));\n }\n matrix_info->type = DiskCache;\n (void)AcquireMagickResource(MemoryResource, matrix_info->length);\n matrix_info->file = AcquireUniqueFileResource(matrix_info->path);\n if (matrix_info->file == -1)\n return (DestroyMatrixInfo(matrix_info));\n status = AcquireMagickResource(MapResource, matrix_info->length);\n if (status != MagickFalse)\n {\n status = SetMatrixExtent(matrix_info, matrix_info->length);\n if (status != MagickFalse)\n {\n matrix_info->elements = (void *)MapBlob(matrix_info->file, IOMode, 0,\n (size_t) matrix_info->length);\n if (matrix_info->elements != NULL)\n matrix_info->type = MapCache;\n else\n RelinquishMagickResource(MapResource, matrix_info->length);\n }\n }\n }\n return (matrix_info);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % A c q u i r e M a g i c k M a t r i x\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % AcquireMagickMatrix() allocates and returns a matrix in the form\n * of an % array of pointers to an array of doubles, with all values pre-set\n * to zero. % % This used to generate the two dimensional matrix, and\n * vectors required % for the GaussJordanElimination() method below, solving\n * some system of % simultanious equations. % % The format of the\n * AcquireMagickMatrix method is: % % double **AcquireMagickMatrix(const\n * size_t number_rows, % const size_t size) % % A description of each\n * parameter follows: % % o number_rows: the number pointers for the array\n * of pointers % (first dimension). % % o size: the size of the array\n * of doubles each pointer points to % (second dimension). %\n */\nMagickExport double **\nAcquireMagickMatrix(const size_t number_rows,\n const size_t size)\n{\n double\n **matrix;\n\n register ssize_t\n i, j;\n\n matrix = (double **)AcquireQuantumMemory(number_rows, sizeof(*matrix));\n if (matrix == (double **)NULL)\n return ((double **)NULL);\n for (i = 0; i < (ssize_t) number_rows; i++)\n {\n matrix[i] = (double *)AcquireQuantumMemory(size, sizeof(*matrix[i]));\n if (matrix[i] == (double *)NULL)\n {\n for (j = 0; j < i; j++)\n matrix[j] = (double *)RelinquishMagickMemory(matrix[j]);\n matrix = (double **)RelinquishMagickMemory(matrix);\n return ((double **)NULL);\n }\n for (j = 0; j < (ssize_t) size; j++)\n matrix[i][j] = 0.0;\n }\n return (matrix);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % D e s t r o y M a t r i x I n f o\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % DestroyMatrixInfo() dereferences a matrix, deallocating memory\n * associated % with the matrix. % % The format of the DestroyImage method\n * is: % % MatrixInfo *DestroyMatrixInfo(MatrixInfo *matrix_info) % % A\n * description of each parameter follows: % % o matrix_info: the matrix. %\n */\nMagickExport MatrixInfo * DestroyMatrixInfo(MatrixInfo * matrix_info)\n{\n assert(matrix_info != (MatrixInfo *) NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n LockSemaphoreInfo(matrix_info->semaphore);\n switch (matrix_info->type)\n {\n case MemoryCache:\n {\n if (matrix_info->mapped == MagickFalse)\n matrix_info->elements = RelinquishMagickMemory(matrix_info->elements);\n else\n {\n (void)UnmapBlob(matrix_info->elements, (size_t) matrix_info->length);\n matrix_info->elements = (unsigned short *)NULL;\n }\n RelinquishMagickResource(MemoryResource, matrix_info->length);\n break;\n }\n case MapCache:\n {\n (void)UnmapBlob(matrix_info->elements, (size_t) matrix_info->length);\n matrix_info->elements = NULL;\n RelinquishMagickResource(MapResource, matrix_info->length);\n }\n case DiskCache:\n {\n if (matrix_info->file != -1)\n (void)close(matrix_info->file);\n (void)RelinquishUniqueFileResource(matrix_info->path);\n RelinquishMagickResource(DiskResource, matrix_info->length);\n break;\n }\n default:\n break;\n }\n UnlockSemaphoreInfo(matrix_info->semaphore);\n RelinquishSemaphoreInfo(&matrix_info->semaphore);\n return ((MatrixInfo *) RelinquishMagickMemory(matrix_info));\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % + G a u s s J o r d a n E l i m i n a t i o n\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % GaussJordanElimination() returns a matrix in reduced row echelon\n * form, % while simultaneously reducing and thus solving the augumented\n * results % matrix. % % See also\n * http://en.wikipedia.org/wiki/Gauss-Jordan_elimination % % The format of\n * the GaussJordanElimination method is: % % MagickBooleanType\n * GaussJordanElimination(double **matrix, % double **vectors,const\n * size_t rank,const size_t number_vectors) % % A description of each\n * parameter follows: % % o matrix: the matrix to be reduced, as an 'array\n * of row pointers'. % % o vectors: the additional matrix argumenting the\n * matrix for row reduction. % Producing an 'array of column\n * vectors'. % % o rank: The size of the matrix (both rows and columns).\n * % Also represents the number terms that need to be solved. % %\n * o number_vectors: Number of vectors columns, argumenting the above matrix.\n * % Usally 1, but can be more for more complex equation solving.\n * % % Note that the 'matrix' is given as a 'array of row pointers' of rank\n * size. % That is values can be assigned as matrix[row][column] where\n * 'row' is % typically the equation, and 'column' is the term of the\n * equation. % That is the matrix is in the form of a 'row first array'. % %\n * However 'vectors' is a 'array of column pointers' which can have any\n * number % of columns, with each column array the same 'rank' size as\n * 'matrix'. % % This allows for simpler handling of the results, especially\n * is only one % column 'vector' is all that is required to produce the\n * desired solution. % % For example, the 'vectors' can consist of a pointer\n * to a simple array of % doubles. when only one set of simultanious\n * equations is to be solved from % the given set of coefficient weighted\n * terms. % % double **matrix = AcquireMagickMatrix(8UL,8UL); %\n * double coefficents[8]; % ... % GaussJordanElimination(matrix,\n * &coefficents, 8UL, 1UL); % % However by specifing more 'columns' (as an\n * 'array of vector columns', % you can use this function to solve a set of\n * 'separable' equations. % % For example a distortion function where u =\n * U(x,y) v = V(x,y) % And the functions U() and V() have separate\n * coefficents, but are being % generated from a common x,y->u,v data set.\n * % % Another example is generation of a color gradient from a set of\n * colors at % specific coordients, such as a list x,y -> r,g,b,a. % % You\n * can also use the 'vectors' to generate an inverse of the given 'matrix' %\n * though as a 'column first array' rather than a 'row first array'. For %\n * details see http://en.wikipedia.org/wiki/Gauss-Jordan_elimination %\n */\nMagickPrivate MagickBooleanType GaussJordanElimination(double **matrix,\n double **vectors, const size_t rank, const size_t number_vectors)\n{\n#define GaussJordanSwap(x,y) \\\n{ \\\n if ((x) != (y)) \\\n { \\\n (x)+=(y); \\\n (y)=(x)-(y); \\\n (x)=(x)-(y); \\\n } \\\n}\n\n double\n max, scale;\n\n register ssize_t\n i, j, k;\n\n ssize_t\n column,\n *columns,\n *pivots,\n row,\n *rows;\n\n columns = (ssize_t *) AcquireQuantumMemory(rank, sizeof(*columns));\n rows = (ssize_t *) AcquireQuantumMemory(rank, sizeof(*rows));\n pivots = (ssize_t *) AcquireQuantumMemory(rank, sizeof(*pivots));\n if ((rows == (ssize_t *) NULL) || (columns == (ssize_t *) NULL) ||\n (pivots == (ssize_t *) NULL))\n {\n if (pivots != (ssize_t *) NULL)\n pivots = (ssize_t *) RelinquishMagickMemory(pivots);\n if (columns != (ssize_t *) NULL)\n columns = (ssize_t *) RelinquishMagickMemory(columns);\n if (rows != (ssize_t *) NULL)\n rows = (ssize_t *) RelinquishMagickMemory(rows);\n return (MagickFalse);\n }\n (void)ResetMagickMemory(columns, 0, rank * sizeof(*columns));\n (void)ResetMagickMemory(rows, 0, rank * sizeof(*rows));\n (void)ResetMagickMemory(pivots, 0, rank * sizeof(*pivots));\n column = 0;\n row = 0;\n for (i = 0; i < (ssize_t) rank; i++)\n {\n max = 0.0;\n for (j = 0; j < (ssize_t) rank; j++)\n if (pivots[j] != 1)\n {\n for (k = 0; k < (ssize_t) rank; k++)\n if (pivots[k] != 0)\n {\n if (pivots[k] > 1)\n return (MagickFalse);\n } else if (fabs(matrix[j][k]) >= max)\n {\n max = fabs(matrix[j][k]);\n row = j;\n column = k;\n }\n }\n pivots[column]++;\n if (row != column)\n {\n for (k = 0; k < (ssize_t) rank; k++)\n GaussJordanSwap(matrix[row][k], matrix[column][k]);\n for (k = 0; k < (ssize_t) number_vectors; k++)\n GaussJordanSwap(vectors[k][row], vectors[k][column]);\n }\n rows[i] = row;\n columns[i] = column;\n if (matrix[column][column] == 0.0)\n return (MagickFalse); /* sigularity */\n scale = PerceptibleReciprocal(matrix[column][column]);\n matrix[column][column] = 1.0;\n for (j = 0; j < (ssize_t) rank; j++)\n matrix[column][j] *= scale;\n for (j = 0; j < (ssize_t) number_vectors; j++)\n vectors[j][column] *= scale;\n for (j = 0; j < (ssize_t) rank; j++)\n if (j != column)\n {\n scale = matrix[j][column];\n matrix[j][column] = 0.0;\n for (k = 0; k < (ssize_t) rank; k++)\n matrix[j][k] -= scale * matrix[column][k];\n for (k = 0; k < (ssize_t) number_vectors; k++)\n vectors[k][j] -= scale * vectors[k][column];\n }\n }\n for (j = (ssize_t) rank - 1; j >= 0; j--)\n if (columns[j] != rows[j])\n for (i = 0; i < (ssize_t) rank; i++)\n GaussJordanSwap(matrix[i][rows[j]], matrix[i][columns[j]]);\n pivots = (ssize_t *) RelinquishMagickMemory(pivots);\n rows = (ssize_t *) RelinquishMagickMemory(rows);\n columns = (ssize_t *) RelinquishMagickMemory(columns);\n return (MagickTrue);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % G e t M a t r i x C o l u m n s\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % GetMatrixColumns() returns the number of columns in the matrix.\n * % % The format of the GetMatrixColumns method is: % % size_t\n * GetMatrixColumns(const MatrixInfo *matrix_info) % % A description of each\n * parameter follows: % % o matrix_info: the matrix. %\n */\nMagickExport size_t GetMatrixColumns(const MatrixInfo * matrix_info)\n{\n assert(matrix_info != (MatrixInfo *) NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n return (matrix_info->columns);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % G e t M a t r i x E l e m e n t\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % GetMatrixElement() returns the specifed element in the matrix. %\n * % The format of the GetMatrixElement method is: % %\n * MagickBooleanType GetMatrixElement(const MatrixInfo *matrix_info, %\n * const ssize_t x,const ssize_t y,void *value) % % A description of each\n * parameter follows: % % o matrix_info: the matrix columns. % % o x:\n * the matrix x-offset. % % o y: the matrix y-offset. % % o value:\n * return the matrix element in this buffer. %\n */\n\nstatic inline ssize_t \nEdgeX(const ssize_t x, const size_t columns)\n{\n if (x < 0L)\n return (0L);\n if (x >= (ssize_t) columns)\n return ((ssize_t) (columns - 1));\n return (x);\n}\n\nstatic inline ssize_t \nEdgeY(const ssize_t y, const size_t rows)\n{\n if (y < 0L)\n return (0L);\n if (y >= (ssize_t) rows)\n return ((ssize_t) (rows - 1));\n return (y);\n}\n\nstatic inline MagickOffsetType \nReadMatrixElements(\n const MatrixInfo * magick_restrict matrix_info, const MagickOffsetType offset,\n const MagickSizeType length, unsigned char *magick_restrict buffer)\n{\n register MagickOffsetType\n i;\n\n ssize_t\n count;\n\n#if !defined(MAGICKCORE_HAVE_PREAD)\n LockSemaphoreInfo(matrix_info->semaphore);\n if (lseek(matrix_info->file, offset, SEEK_SET) < 0)\n {\n UnlockSemaphoreInfo(matrix_info->semaphore);\n return ((MagickOffsetType) - 1);\n }\n#endif\n count = 0;\n for (i = 0; i < (MagickOffsetType) length; i += count)\n {\n#if !defined(MAGICKCORE_HAVE_PREAD)\n count = read(matrix_info->file, buffer + i, (size_t) MagickMin(length - i,\n (MagickSizeType) SSIZE_MAX));\n#else\n count = pread(matrix_info->file, buffer + i, (size_t) MagickMin(length - i,\n (MagickSizeType) SSIZE_MAX), (off_t) (offset + i));\n#endif\n if (count <= 0)\n {\n count = 0;\n if (errno != EINTR)\n break;\n }\n }\n#if !defined(MAGICKCORE_HAVE_PREAD)\n UnlockSemaphoreInfo(matrix_info->semaphore);\n#endif\n return (i);\n}\n\nMagickExport MagickBooleanType \nGetMatrixElement(const MatrixInfo * matrix_info,\n const ssize_t x, const ssize_t y, void *value)\n{\n MagickOffsetType\n count,\n i;\n\n assert(matrix_info != (const MatrixInfo *)NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n i = (MagickOffsetType) EdgeY(y, matrix_info->rows) * matrix_info->columns +\n EdgeX(x, matrix_info->columns);\n if (matrix_info->type != DiskCache)\n {\n (void)memcpy(value, (unsigned char *)matrix_info->elements + i *\n matrix_info->stride, matrix_info->stride);\n return (MagickTrue);\n }\n count = ReadMatrixElements(matrix_info, i * matrix_info->stride,\n matrix_info->stride, (unsigned char *)value);\n if (count != (MagickOffsetType) matrix_info->stride)\n return (MagickFalse);\n return (MagickTrue);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % G e t M a t r i x R o w s\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % GetMatrixRows() returns the number of rows in the matrix. % %\n * The format of the GetMatrixRows method is: % % size_t\n * GetMatrixRows(const MatrixInfo *matrix_info) % % A description of each\n * parameter follows: % % o matrix_info: the matrix. %\n */\nMagickExport size_t GetMatrixRows(const MatrixInfo * matrix_info)\n{\n assert(matrix_info != (const MatrixInfo *)NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n return (matrix_info->rows);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % + L e a s t S q u a r e s A d d T e r m s\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % LeastSquaresAddTerms() adds one set of terms and associate\n * results to the % given matrix and vectors for solving using least-squares\n * function fitting. % % The format of the AcquireMagickMatrix method is: %\n * % void LeastSquaresAddTerms(double **matrix,double **vectors, %\n * const double *terms,const double *results,const size_t rank, %\n * const size_t number_vectors); % % A description of each parameter\n * follows: % % o matrix: the square matrix to add given terms/results to.\n * % % o vectors: the result vectors to add terms/results to. % % o\n * terms: the pre-calculated terms (without the unknown coefficent %\n * weights) that forms the equation being added. % % o results: the\n * result(s) that should be generated from the given terms %\n * weighted by the yet-to-be-solved coefficents. % % o rank: the rank or\n * size of the dimensions of the square matrix. % Also the length\n * of vectors, and number of terms being added. % % o number_vectors:\n * Number of result vectors, and number or results being % added. Also\n * represents the number of separable systems of equations % that is\n * being solved. % % Example of use... % % 2 dimensional Affine\n * Equations (which are separable) % c0*x + c2*y + c4*1 => u %\n * c1*x + c3*y + c5*1 => v % % double **matrix =\n * AcquireMagickMatrix(3UL,3UL); % double **vectors =\n * AcquireMagickMatrix(2UL,3UL); % double terms[3], results[2]; % ...\n * % for each given x,y -> u,v % terms[0] = x; % terms[1] =\n * y; % terms[2] = 1; % results[0] = u; % results[1] =\n * v; % LeastSquaresAddTerms(matrix,vectors,terms,results,3UL,2UL); %\n * ... % if ( GaussJordanElimination(matrix,vectors,3UL,2UL) ) { %\n * c0 = vectors[0][0]; % c2 = vectors[0][1]; % c4 =\n * vectors[0][2]; % c1 = vectors[1][0]; % c3 = vectors[1][1]; %\n * c5 = vectors[1][2]; % } % else % printf(\"Matrix\n * unsolvable\\n); % RelinquishMagickMatrix(matrix,3UL); %\n * RelinquishMagickMatrix(vectors,2UL); %\n */\nMagickPrivate void \nLeastSquaresAddTerms(double **matrix, double **vectors,\n const double *terms, const double *results, const size_t rank,\n const size_t number_vectors)\n{\n register ssize_t\n i, j;\n\n for (j = 0; j < (ssize_t) rank; j++)\n {\n for (i = 0; i < (ssize_t) rank; i++)\n matrix[i][j] += terms[i] * terms[j];\n for (i = 0; i < (ssize_t) number_vectors; i++)\n vectors[i][j] += results[i] * terms[j];\n }\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % M a t r i x T o I m a g e\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % MatrixToImage() returns a matrix as an image. The matrix\n * elements must be % of type double otherwise nonsense is returned. % %\n * The format of the MatrixToImage method is: % % Image\n * *MatrixToImage(const MatrixInfo *matrix_info, % ExceptionInfo\n * *exception) % % A description of each parameter follows: % % o\n * matrix_info: the matrix. % % o exception: return any errors or warnings\n * in this structure. %\n */\nMagickExport Image * MatrixToImage(const MatrixInfo * matrix_info,\n ExceptionInfo * exception)\n{\n CacheView\n * image_view;\n\n double\n max_value, min_value, scale_factor, value;\n\n Image\n * image;\n\n MagickBooleanType\n status;\n\n ssize_t\n y;\n\n assert(matrix_info != (const MatrixInfo *)NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n assert(exception != (ExceptionInfo *) NULL);\n assert(exception->signature == MagickCoreSignature);\n if (matrix_info->stride < sizeof(double))\n return ((Image *) NULL);\n /*\n * Determine range of matrix.\n */\n (void)GetMatrixElement(matrix_info, 0, 0, &value);\n min_value = value;\n max_value = value;\n for (y = 0; y < (ssize_t) matrix_info->rows; y++)\n {\n register ssize_t\n x;\n\n for (x = 0; x < (ssize_t) matrix_info->columns; x++)\n {\n if (GetMatrixElement(matrix_info, x, y, &value) == MagickFalse)\n continue;\n if (value < min_value)\n min_value = value;\n else if (value > max_value)\n max_value = value;\n }\n }\n if ((min_value == 0.0) && (max_value == 0.0))\n scale_factor = 0;\n else if (min_value == max_value)\n {\n scale_factor = (double)QuantumRange / min_value;\n min_value = 0;\n } else\n scale_factor = (double)QuantumRange / (max_value - min_value);\n /*\n * Convert matrix to image.\n */\n image = AcquireImage((ImageInfo *) NULL, exception);\n image->columns = matrix_info->columns;\n image->rows = matrix_info->rows;\n image->colorspace = GRAYColorspace;\n status = MagickTrue;\n image_view = AcquireAuthenticCacheView(image, exception);\n for (y = 0; y < (ssize_t) image->rows; y++)\n {\n double\n value;\n\n register Quantum\n * q;\n\n register ssize_t\n x;\n\n if (status == MagickFalse)\n continue;\n q = QueueCacheViewAuthenticPixels(image_view, 0, y, image->columns, 1, exception);\n if (q == (Quantum *) NULL)\n {\n status = MagickFalse;\n continue;\n }\n for (x = 0; x < (ssize_t) image->columns; x++)\n {\n if (GetMatrixElement(matrix_info, x, y, &value) == MagickFalse)\n continue;\n value = scale_factor * (value - min_value);\n *q = ClampToQuantum(value);\n q += GetPixelChannels(image);\n }\n if (SyncCacheViewAuthenticPixels(image_view, exception) == MagickFalse)\n status = MagickFalse;\n }\n image_view = DestroyCacheView(image_view);\n if (status == MagickFalse)\n image = DestroyImage(image);\n return (image);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % N u l l M a t r i x\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % NullMatrix() sets all elements of the matrix to zero. % % The\n * format of the ResetMagickMemory method is: % % MagickBooleanType\n * *NullMatrix(MatrixInfo *matrix_info) % % A description of each parameter\n * follows: % % o matrix_info: the matrix. %\n */\nMagickExport MagickBooleanType NullMatrix(MatrixInfo * matrix_info)\n{\n register ssize_t\n x;\n\n ssize_t\n count,\n y;\n\n unsigned char\n value;\n\n assert(matrix_info != (const MatrixInfo *)NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n if (matrix_info->type != DiskCache)\n {\n (void)ResetMagickMemory(matrix_info->elements, 0, (size_t)\n matrix_info->length);\n return (MagickTrue);\n }\n value = 0;\n (void)lseek(matrix_info->file, 0, SEEK_SET);\n for (y = 0; y < (ssize_t) matrix_info->rows; y++)\n {\n for (x = 0; x < (ssize_t) matrix_info->length; x++)\n {\n count = write(matrix_info->file, &value, sizeof(value));\n if (count != (ssize_t) sizeof(value))\n break;\n }\n if (x < (ssize_t) matrix_info->length)\n break;\n }\n return (y < (ssize_t) matrix_info->rows ? MagickFalse : MagickTrue);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % R e l i n q u i s h M a g i c k M a t r i x\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % RelinquishMagickMatrix() frees the previously acquired matrix\n * (array of % pointers to arrays of doubles). % % The format of the\n * RelinquishMagickMatrix method is: % % double\n * **RelinquishMagickMatrix(double **matrix, % const size_t\n * number_rows) % % A description of each parameter follows: % % o\n * matrix: the matrix to relinquish % % o number_rows: the first dimension\n * of the acquired matrix (number of % pointers) %\n */\nMagickExport double **\nRelinquishMagickMatrix(double **matrix,\n const size_t number_rows)\n{\n register ssize_t\n i;\n\n if (matrix == (double **)NULL)\n return (matrix);\n for (i = 0; i < (ssize_t) number_rows; i++)\n matrix[i] = (double *)RelinquishMagickMemory(matrix[i]);\n matrix = (double **)RelinquishMagickMemory(matrix);\n return (matrix);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % S e t M a t r i x E l e m e n t\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % SetMatrixElement() sets the specifed element in the matrix. % %\n * The format of the SetMatrixElement method is: % % MagickBooleanType\n * SetMatrixElement(const MatrixInfo *matrix_info, % const ssize_t\n * x,const ssize_t y,void *value) % % A description of each parameter\n * follows: % % o matrix_info: the matrix columns. % % o x: the matrix\n * x-offset. % % o y: the matrix y-offset. % % o value: set the matrix\n * element to this value. %\n */\n\nMagickExport MagickBooleanType SetMatrixElement(const MatrixInfo * matrix_info,\n const ssize_t x, const ssize_t y, const void *value)\n{\n MagickOffsetType\n count,\n i;\n\n assert(matrix_info != (const MatrixInfo *)NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n i = (MagickOffsetType) y *matrix_info->columns + x;\n if ((i < 0) ||\n ((MagickSizeType) (i * matrix_info->stride) >= matrix_info->length))\n return (MagickFalse);\n if (matrix_info->type != DiskCache)\n {\n (void)memcpy((unsigned char *)matrix_info->elements + i *\n matrix_info->stride, value, matrix_info->stride);\n return (MagickTrue);\n }\n count = WriteMatrixElements(matrix_info, i * matrix_info->stride,\n matrix_info->stride, (unsigned char *)value);\n if (count != (MagickOffsetType) matrix_info->stride)\n return (MagickFalse);\n return (MagickTrue);\n}\n"},"omp_formatted":{"kind":"string","value":"\n\n\n/*\n * Include declarations.\n */\n#include \"MagickCore/studio.h\"\n#include \"MagickCore/blob.h\"\n#include \"MagickCore/blob-private.h\"\n#include \"MagickCore/cache.h\"\n#include \"MagickCore/exception.h\"\n#include \"MagickCore/exception-private.h\"\n#include \"MagickCore/image-private.h\"\n#include \"MagickCore/matrix.h\"\n#include \"MagickCore/memory_.h\"\n#include \"MagickCore/pixel-accessor.h\"\n#include \"MagickCore/pixel-private.h\"\n#include \"MagickCore/resource_.h\"\n#include \"MagickCore/semaphore.h\"\n#include \"MagickCore/thread-private.h\"\n#include \"MagickCore/utility.h\"\n\n\n/*\n * Typedef declaration.\n */\nstruct _MatrixInfo\n{\n CacheType\n type;\n\n size_t\n columns,\n rows,\n stride;\n\n MagickSizeType\n length;\n\n MagickBooleanType\n mapped,\n synchronize;\n\n char\n path[MagickPathExtent];\n\n int\n file;\n\n void\n *elements;\n\n SemaphoreInfo\n * semaphore;\n\n size_t\n signature;\n};\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % A c q u i r e M a t r i x I n f o\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % AcquireMatrixInfo() allocates the ImageInfo structure. % % The\n * format of the AcquireMatrixInfo method is: % % MatrixInfo\n * *AcquireMatrixInfo(const size_t columns,const size_t rows, % const\n * size_t stride,ExceptionInfo *exception) % % A description of each\n * parameter follows: % % o columns: the matrix columns. % % o rows:\n * the matrix rows. % % o stride: the matrix stride. % % o exception:\n * return any errors or warnings in this structure. %\n */\n\n#if defined(SIGBUS)\nstatic void \nMatrixSignalHandler(int status)\n{\n ThrowFatalException(CacheFatalError, \"UnableToExtendMatrixCache\");\n}\n\n#endif\n\nstatic inline MagickOffsetType \nWriteMatrixElements(\n const MatrixInfo * magick_restrict matrix_info, const MagickOffsetType offset,\n const MagickSizeType length, const unsigned char *magick_restrict buffer)\n{\n register MagickOffsetType\n i;\n\n ssize_t\n count;\n\n#if !defined(MAGICKCORE_HAVE_PWRITE)\n LockSemaphoreInfo(matrix_info->semaphore);\n if (lseek(matrix_info->file, offset, SEEK_SET) < 0)\n {\n UnlockSemaphoreInfo(matrix_info->semaphore);\n return ((MagickOffsetType) - 1);\n }\n#endif\n count = 0;\n for (i = 0; i < (MagickOffsetType) length; i += count)\n {\n#if !defined(MAGICKCORE_HAVE_PWRITE)\n count = write(matrix_info->file, buffer + i, (size_t) MagickMin(length - i,\n (MagickSizeType) SSIZE_MAX));\n#else\n count = pwrite(matrix_info->file, buffer + i, (size_t) MagickMin(length - i,\n (MagickSizeType) SSIZE_MAX), (off_t) (offset + i));\n#endif\n if (count <= 0)\n {\n count = 0;\n if (errno != EINTR)\n break;\n }\n }\n#if !defined(MAGICKCORE_HAVE_PWRITE)\n UnlockSemaphoreInfo(matrix_info->semaphore);\n#endif\n return (i);\n}\n\nstatic MagickBooleanType \nSetMatrixExtent(\n MatrixInfo * magick_restrict matrix_info,\n MagickSizeType length)\n{\n MagickOffsetType\n count,\n extent,\n offset;\n\n if (length != (MagickSizeType) ((MagickOffsetType) length))\n return (MagickFalse);\n offset = (MagickOffsetType) lseek(matrix_info->file, 0, SEEK_END);\n if (offset < 0)\n return (MagickFalse);\n if ((MagickSizeType) offset >= length)\n return (MagickTrue);\n extent = (MagickOffsetType) length - 1;\n count = WriteMatrixElements(matrix_info, extent, 1, (const unsigned char *)\"\");\n#if defined(MAGICKCORE_HAVE_POSIX_FALLOCATE)\n if (matrix_info->synchronize != MagickFalse)\n (void)posix_fallocate(matrix_info->file, offset + 1, extent - offset);\n#endif\n#if defined(SIGBUS)\n (void)signal(SIGBUS, MatrixSignalHandler);\n#endif\n return (count != (MagickOffsetType) 1 ? MagickFalse : MagickTrue);\n}\n\nMagickExport MatrixInfo *\nAcquireMatrixInfo(const size_t columns,\n const size_t rows, const size_t stride, ExceptionInfo * exception)\n{\n char\n *synchronize;\n\n MagickBooleanType\n status;\n\n MatrixInfo\n * matrix_info;\n\n matrix_info = (MatrixInfo *) AcquireMagickMemory(sizeof(*matrix_info));\n if (matrix_info == (MatrixInfo *) NULL)\n return ((MatrixInfo *) NULL);\n (void)ResetMagickMemory(matrix_info, 0, sizeof(*matrix_info));\n matrix_info->signature = MagickCoreSignature;\n matrix_info->columns = columns;\n matrix_info->rows = rows;\n matrix_info->stride = stride;\n matrix_info->semaphore = AcquireSemaphoreInfo();\n synchronize = GetEnvironmentValue(\"MAGICK_SYNCHRONIZE\");\n if (synchronize != (const char *)NULL)\n {\n matrix_info->synchronize = IsStringTrue(synchronize);\n synchronize = DestroyString(synchronize);\n }\n matrix_info->length = (MagickSizeType) columns *rows * stride;\n if (matrix_info->columns != (size_t) (matrix_info->length / rows / stride))\n {\n (void)ThrowMagickException(exception, GetMagickModule(), CacheError,\n \"CacheResourcesExhausted\", \"`%s'\", \"matrix cache\");\n return (DestroyMatrixInfo(matrix_info));\n }\n matrix_info->type = MemoryCache;\n status = AcquireMagickResource(AreaResource, matrix_info->length);\n if ((status != MagickFalse) &&\n (matrix_info->length == (MagickSizeType) ((size_t) matrix_info->length)))\n {\n status = AcquireMagickResource(MemoryResource, matrix_info->length);\n if (status != MagickFalse)\n {\n matrix_info->mapped = MagickFalse;\n matrix_info->elements = AcquireMagickMemory((size_t)\n matrix_info->length);\n if (matrix_info->elements == NULL)\n {\n matrix_info->mapped = MagickTrue;\n matrix_info->elements = MapBlob(-1, IOMode, 0, (size_t)\n matrix_info->length);\n }\n if (matrix_info->elements == (unsigned short *)NULL)\n RelinquishMagickResource(MemoryResource, matrix_info->length);\n }\n }\n matrix_info->file = (-1);\n if (matrix_info->elements == (unsigned short *)NULL)\n {\n status = AcquireMagickResource(DiskResource, matrix_info->length);\n if (status == MagickFalse)\n {\n (void)ThrowMagickException(exception, GetMagickModule(), CacheError,\n \"CacheResourcesExhausted\", \"`%s'\", \"matrix cache\");\n return (DestroyMatrixInfo(matrix_info));\n }\n matrix_info->type = DiskCache;\n (void)AcquireMagickResource(MemoryResource, matrix_info->length);\n matrix_info->file = AcquireUniqueFileResource(matrix_info->path);\n if (matrix_info->file == -1)\n return (DestroyMatrixInfo(matrix_info));\n status = AcquireMagickResource(MapResource, matrix_info->length);\n if (status != MagickFalse)\n {\n status = SetMatrixExtent(matrix_info, matrix_info->length);\n if (status != MagickFalse)\n {\n matrix_info->elements = (void *)MapBlob(matrix_info->file, IOMode, 0,\n (size_t) matrix_info->length);\n if (matrix_info->elements != NULL)\n matrix_info->type = MapCache;\n else\n RelinquishMagickResource(MapResource, matrix_info->length);\n }\n }\n }\n return (matrix_info);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % A c q u i r e M a g i c k M a t r i x\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % AcquireMagickMatrix() allocates and returns a matrix in the form\n * of an % array of pointers to an array of doubles, with all values pre-set\n * to zero. % % This used to generate the two dimensional matrix, and\n * vectors required % for the GaussJordanElimination() method below, solving\n * some system of % simultanious equations. % % The format of the\n * AcquireMagickMatrix method is: % % double **AcquireMagickMatrix(const\n * size_t number_rows, % const size_t size) % % A description of each\n * parameter follows: % % o number_rows: the number pointers for the array\n * of pointers % (first dimension). % % o size: the size of the array\n * of doubles each pointer points to % (second dimension). %\n */\nMagickExport double **\nAcquireMagickMatrix(const size_t number_rows,\n const size_t size)\n{\n double\n **matrix;\n\n register ssize_t\n i, j;\n\n matrix = (double **)AcquireQuantumMemory(number_rows, sizeof(*matrix));\n if (matrix == (double **)NULL)\n return ((double **)NULL);\n for (i = 0; i < (ssize_t) number_rows; i++)\n {\n matrix[i] = (double *)AcquireQuantumMemory(size, sizeof(*matrix[i]));\n if (matrix[i] == (double *)NULL)\n {\n for (j = 0; j < i; j++)\n matrix[j] = (double *)RelinquishMagickMemory(matrix[j]);\n matrix = (double **)RelinquishMagickMemory(matrix);\n return ((double **)NULL);\n }\n for (j = 0; j < (ssize_t) size; j++)\n matrix[i][j] = 0.0;\n }\n return (matrix);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % D e s t r o y M a t r i x I n f o\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % DestroyMatrixInfo() dereferences a matrix, deallocating memory\n * associated % with the matrix. % % The format of the DestroyImage method\n * is: % % MatrixInfo *DestroyMatrixInfo(MatrixInfo *matrix_info) % % A\n * description of each parameter follows: % % o matrix_info: the matrix. %\n */\nMagickExport MatrixInfo * DestroyMatrixInfo(MatrixInfo * matrix_info)\n{\n assert(matrix_info != (MatrixInfo *) NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n LockSemaphoreInfo(matrix_info->semaphore);\n switch (matrix_info->type)\n {\n case MemoryCache:\n {\n if (matrix_info->mapped == MagickFalse)\n matrix_info->elements = RelinquishMagickMemory(matrix_info->elements);\n else\n {\n (void)UnmapBlob(matrix_info->elements, (size_t) matrix_info->length);\n matrix_info->elements = (unsigned short *)NULL;\n }\n RelinquishMagickResource(MemoryResource, matrix_info->length);\n break;\n }\n case MapCache:\n {\n (void)UnmapBlob(matrix_info->elements, (size_t) matrix_info->length);\n matrix_info->elements = NULL;\n RelinquishMagickResource(MapResource, matrix_info->length);\n }\n case DiskCache:\n {\n if (matrix_info->file != -1)\n (void)close(matrix_info->file);\n (void)RelinquishUniqueFileResource(matrix_info->path);\n RelinquishMagickResource(DiskResource, matrix_info->length);\n break;\n }\n default:\n break;\n }\n UnlockSemaphoreInfo(matrix_info->semaphore);\n RelinquishSemaphoreInfo(&matrix_info->semaphore);\n return ((MatrixInfo *) RelinquishMagickMemory(matrix_info));\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % + G a u s s J o r d a n E l i m i n a t i o n\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % GaussJordanElimination() returns a matrix in reduced row echelon\n * form, % while simultaneously reducing and thus solving the augumented\n * results % matrix. % % See also\n * http://en.wikipedia.org/wiki/Gauss-Jordan_elimination % % The format of\n * the GaussJordanElimination method is: % % MagickBooleanType\n * GaussJordanElimination(double **matrix, % double **vectors,const\n * size_t rank,const size_t number_vectors) % % A description of each\n * parameter follows: % % o matrix: the matrix to be reduced, as an 'array\n * of row pointers'. % % o vectors: the additional matrix argumenting the\n * matrix for row reduction. % Producing an 'array of column\n * vectors'. % % o rank: The size of the matrix (both rows and columns).\n * % Also represents the number terms that need to be solved. % %\n * o number_vectors: Number of vectors columns, argumenting the above matrix.\n * % Usally 1, but can be more for more complex equation solving.\n * % % Note that the 'matrix' is given as a 'array of row pointers' of rank\n * size. % That is values can be assigned as matrix[row][column] where\n * 'row' is % typically the equation, and 'column' is the term of the\n * equation. % That is the matrix is in the form of a 'row first array'. % %\n * However 'vectors' is a 'array of column pointers' which can have any\n * number % of columns, with each column array the same 'rank' size as\n * 'matrix'. % % This allows for simpler handling of the results, especially\n * is only one % column 'vector' is all that is required to produce the\n * desired solution. % % For example, the 'vectors' can consist of a pointer\n * to a simple array of % doubles. when only one set of simultanious\n * equations is to be solved from % the given set of coefficient weighted\n * terms. % % double **matrix = AcquireMagickMatrix(8UL,8UL); %\n * double coefficents[8]; % ... % GaussJordanElimination(matrix,\n * &coefficents, 8UL, 1UL); % % However by specifing more 'columns' (as an\n * 'array of vector columns', % you can use this function to solve a set of\n * 'separable' equations. % % For example a distortion function where u =\n * U(x,y) v = V(x,y) % And the functions U() and V() have separate\n * coefficents, but are being % generated from a common x,y->u,v data set.\n * % % Another example is generation of a color gradient from a set of\n * colors at % specific coordients, such as a list x,y -> r,g,b,a. % % You\n * can also use the 'vectors' to generate an inverse of the given 'matrix' %\n * though as a 'column first array' rather than a 'row first array'. For %\n * details see http://en.wikipedia.org/wiki/Gauss-Jordan_elimination %\n */\nMagickPrivate MagickBooleanType GaussJordanElimination(double **matrix,\n double **vectors, const size_t rank, const size_t number_vectors)\n{\n#define GaussJordanSwap(x,y) \\\n{ \\\n if ((x) != (y)) \\\n { \\\n (x)+=(y); \\\n (y)=(x)-(y); \\\n (x)=(x)-(y); \\\n } \\\n}\n\n double\n max, scale;\n\n register ssize_t\n i, j, k;\n\n ssize_t\n column,\n *columns,\n *pivots,\n row,\n *rows;\n\n columns = (ssize_t *) AcquireQuantumMemory(rank, sizeof(*columns));\n rows = (ssize_t *) AcquireQuantumMemory(rank, sizeof(*rows));\n pivots = (ssize_t *) AcquireQuantumMemory(rank, sizeof(*pivots));\n if ((rows == (ssize_t *) NULL) || (columns == (ssize_t *) NULL) ||\n (pivots == (ssize_t *) NULL))\n {\n if (pivots != (ssize_t *) NULL)\n pivots = (ssize_t *) RelinquishMagickMemory(pivots);\n if (columns != (ssize_t *) NULL)\n columns = (ssize_t *) RelinquishMagickMemory(columns);\n if (rows != (ssize_t *) NULL)\n rows = (ssize_t *) RelinquishMagickMemory(rows);\n return (MagickFalse);\n }\n (void)ResetMagickMemory(columns, 0, rank * sizeof(*columns));\n (void)ResetMagickMemory(rows, 0, rank * sizeof(*rows));\n (void)ResetMagickMemory(pivots, 0, rank * sizeof(*pivots));\n column = 0;\n row = 0;\n for (i = 0; i < (ssize_t) rank; i++)\n {\n max = 0.0;\n for (j = 0; j < (ssize_t) rank; j++)\n if (pivots[j] != 1)\n {\n for (k = 0; k < (ssize_t) rank; k++)\n if (pivots[k] != 0)\n {\n if (pivots[k] > 1)\n return (MagickFalse);\n } else if (fabs(matrix[j][k]) >= max)\n {\n max = fabs(matrix[j][k]);\n row = j;\n column = k;\n }\n }\n pivots[column]++;\n if (row != column)\n {\n for (k = 0; k < (ssize_t) rank; k++)\n GaussJordanSwap(matrix[row][k], matrix[column][k]);\n for (k = 0; k < (ssize_t) number_vectors; k++)\n GaussJordanSwap(vectors[k][row], vectors[k][column]);\n }\n rows[i] = row;\n columns[i] = column;\n if (matrix[column][column] == 0.0)\n return (MagickFalse); /* sigularity */\n scale = PerceptibleReciprocal(matrix[column][column]);\n matrix[column][column] = 1.0;\n for (j = 0; j < (ssize_t) rank; j++)\n matrix[column][j] *= scale;\n for (j = 0; j < (ssize_t) number_vectors; j++)\n vectors[j][column] *= scale;\n for (j = 0; j < (ssize_t) rank; j++)\n if (j != column)\n {\n scale = matrix[j][column];\n matrix[j][column] = 0.0;\n for (k = 0; k < (ssize_t) rank; k++)\n matrix[j][k] -= scale * matrix[column][k];\n for (k = 0; k < (ssize_t) number_vectors; k++)\n vectors[k][j] -= scale * vectors[k][column];\n }\n }\n for (j = (ssize_t) rank - 1; j >= 0; j--)\n if (columns[j] != rows[j])\n for (i = 0; i < (ssize_t) rank; i++)\n GaussJordanSwap(matrix[i][rows[j]], matrix[i][columns[j]]);\n pivots = (ssize_t *) RelinquishMagickMemory(pivots);\n rows = (ssize_t *) RelinquishMagickMemory(rows);\n columns = (ssize_t *) RelinquishMagickMemory(columns);\n return (MagickTrue);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % G e t M a t r i x C o l u m n s\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % GetMatrixColumns() returns the number of columns in the matrix.\n * % % The format of the GetMatrixColumns method is: % % size_t\n * GetMatrixColumns(const MatrixInfo *matrix_info) % % A description of each\n * parameter follows: % % o matrix_info: the matrix. %\n */\nMagickExport size_t GetMatrixColumns(const MatrixInfo * matrix_info)\n{\n assert(matrix_info != (MatrixInfo *) NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n return (matrix_info->columns);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % G e t M a t r i x E l e m e n t\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % GetMatrixElement() returns the specifed element in the matrix. %\n * % The format of the GetMatrixElement method is: % %\n * MagickBooleanType GetMatrixElement(const MatrixInfo *matrix_info, %\n * const ssize_t x,const ssize_t y,void *value) % % A description of each\n * parameter follows: % % o matrix_info: the matrix columns. % % o x:\n * the matrix x-offset. % % o y: the matrix y-offset. % % o value:\n * return the matrix element in this buffer. %\n */\n\nstatic inline ssize_t \nEdgeX(const ssize_t x, const size_t columns)\n{\n if (x < 0L)\n return (0L);\n if (x >= (ssize_t) columns)\n return ((ssize_t) (columns - 1));\n return (x);\n}\n\nstatic inline ssize_t \nEdgeY(const ssize_t y, const size_t rows)\n{\n if (y < 0L)\n return (0L);\n if (y >= (ssize_t) rows)\n return ((ssize_t) (rows - 1));\n return (y);\n}\n\nstatic inline MagickOffsetType \nReadMatrixElements(\n const MatrixInfo * magick_restrict matrix_info, const MagickOffsetType offset,\n const MagickSizeType length, unsigned char *magick_restrict buffer)\n{\n register MagickOffsetType\n i;\n\n ssize_t\n count;\n\n#if !defined(MAGICKCORE_HAVE_PREAD)\n LockSemaphoreInfo(matrix_info->semaphore);\n if (lseek(matrix_info->file, offset, SEEK_SET) < 0)\n {\n UnlockSemaphoreInfo(matrix_info->semaphore);\n return ((MagickOffsetType) - 1);\n }\n#endif\n count = 0;\n for (i = 0; i < (MagickOffsetType) length; i += count)\n {\n#if !defined(MAGICKCORE_HAVE_PREAD)\n count = read(matrix_info->file, buffer + i, (size_t) MagickMin(length - i,\n (MagickSizeType) SSIZE_MAX));\n#else\n count = pread(matrix_info->file, buffer + i, (size_t) MagickMin(length - i,\n (MagickSizeType) SSIZE_MAX), (off_t) (offset + i));\n#endif\n if (count <= 0)\n {\n count = 0;\n if (errno != EINTR)\n break;\n }\n }\n#if !defined(MAGICKCORE_HAVE_PREAD)\n UnlockSemaphoreInfo(matrix_info->semaphore);\n#endif\n return (i);\n}\n\nMagickExport MagickBooleanType \nGetMatrixElement(const MatrixInfo * matrix_info,\n const ssize_t x, const ssize_t y, void *value)\n{\n MagickOffsetType\n count,\n i;\n\n assert(matrix_info != (const MatrixInfo *)NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n i = (MagickOffsetType) EdgeY(y, matrix_info->rows) * matrix_info->columns +\n EdgeX(x, matrix_info->columns);\n if (matrix_info->type != DiskCache)\n {\n (void)memcpy(value, (unsigned char *)matrix_info->elements + i *\n matrix_info->stride, matrix_info->stride);\n return (MagickTrue);\n }\n count = ReadMatrixElements(matrix_info, i * matrix_info->stride,\n matrix_info->stride, (unsigned char *)value);\n if (count != (MagickOffsetType) matrix_info->stride)\n return (MagickFalse);\n return (MagickTrue);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % G e t M a t r i x R o w s\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % GetMatrixRows() returns the number of rows in the matrix. % %\n * The format of the GetMatrixRows method is: % % size_t\n * GetMatrixRows(const MatrixInfo *matrix_info) % % A description of each\n * parameter follows: % % o matrix_info: the matrix. %\n */\nMagickExport size_t GetMatrixRows(const MatrixInfo * matrix_info)\n{\n assert(matrix_info != (const MatrixInfo *)NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n return (matrix_info->rows);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % + L e a s t S q u a r e s A d d T e r m s\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % LeastSquaresAddTerms() adds one set of terms and associate\n * results to the % given matrix and vectors for solving using least-squares\n * function fitting. % % The format of the AcquireMagickMatrix method is: %\n * % void LeastSquaresAddTerms(double **matrix,double **vectors, %\n * const double *terms,const double *results,const size_t rank, %\n * const size_t number_vectors); % % A description of each parameter\n * follows: % % o matrix: the square matrix to add given terms/results to.\n * % % o vectors: the result vectors to add terms/results to. % % o\n * terms: the pre-calculated terms (without the unknown coefficent %\n * weights) that forms the equation being added. % % o results: the\n * result(s) that should be generated from the given terms %\n * weighted by the yet-to-be-solved coefficents. % % o rank: the rank or\n * size of the dimensions of the square matrix. % Also the length\n * of vectors, and number of terms being added. % % o number_vectors:\n * Number of result vectors, and number or results being % added. Also\n * represents the number of separable systems of equations % that is\n * being solved. % % Example of use... % % 2 dimensional Affine\n * Equations (which are separable) % c0*x + c2*y + c4*1 => u %\n * c1*x + c3*y + c5*1 => v % % double **matrix =\n * AcquireMagickMatrix(3UL,3UL); % double **vectors =\n * AcquireMagickMatrix(2UL,3UL); % double terms[3], results[2]; % ...\n * % for each given x,y -> u,v % terms[0] = x; % terms[1] =\n * y; % terms[2] = 1; % results[0] = u; % results[1] =\n * v; % LeastSquaresAddTerms(matrix,vectors,terms,results,3UL,2UL); %\n * ... % if ( GaussJordanElimination(matrix,vectors,3UL,2UL) ) { %\n * c0 = vectors[0][0]; % c2 = vectors[0][1]; % c4 =\n * vectors[0][2]; % c1 = vectors[1][0]; % c3 = vectors[1][1]; %\n * c5 = vectors[1][2]; % } % else % printf(\"Matrix\n * unsolvable\\n); % RelinquishMagickMatrix(matrix,3UL); %\n * RelinquishMagickMatrix(vectors,2UL); %\n */\nMagickPrivate void \nLeastSquaresAddTerms(double **matrix, double **vectors,\n const double *terms, const double *results, const size_t rank,\n const size_t number_vectors)\n{\n register ssize_t\n i, j;\n\n for (j = 0; j < (ssize_t) rank; j++)\n {\n for (i = 0; i < (ssize_t) rank; i++)\n matrix[i][j] += terms[i] * terms[j];\n for (i = 0; i < (ssize_t) number_vectors; i++)\n vectors[i][j] += results[i] * terms[j];\n }\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % M a t r i x T o I m a g e\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % MatrixToImage() returns a matrix as an image. The matrix\n * elements must be % of type double otherwise nonsense is returned. % %\n * The format of the MatrixToImage method is: % % Image\n * *MatrixToImage(const MatrixInfo *matrix_info, % ExceptionInfo\n * *exception) % % A description of each parameter follows: % % o\n * matrix_info: the matrix. % % o exception: return any errors or warnings\n * in this structure. %\n */\nMagickExport Image * MatrixToImage(const MatrixInfo * matrix_info,\n ExceptionInfo * exception)\n{\n CacheView\n * image_view;\n\n double\n max_value, min_value, scale_factor, value;\n\n Image\n * image;\n\n MagickBooleanType\n status;\n\n ssize_t\n y;\n\n assert(matrix_info != (const MatrixInfo *)NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n assert(exception != (ExceptionInfo *) NULL);\n assert(exception->signature == MagickCoreSignature);\n if (matrix_info->stride < sizeof(double))\n return ((Image *) NULL);\n /*\n * Determine range of matrix.\n */\n (void)GetMatrixElement(matrix_info, 0, 0, &value);\n min_value = value;\n max_value = value;\n for (y = 0; y < (ssize_t) matrix_info->rows; y++)\n {\n register ssize_t\n x;\n\n for (x = 0; x < (ssize_t) matrix_info->columns; x++)\n {\n if (GetMatrixElement(matrix_info, x, y, &value) == MagickFalse)\n continue;\n if (value < min_value)\n min_value = value;\n else if (value > max_value)\n max_value = value;\n }\n }\n if ((min_value == 0.0) && (max_value == 0.0))\n scale_factor = 0;\n else if (min_value == max_value)\n {\n scale_factor = (double)QuantumRange / min_value;\n min_value = 0;\n } else\n scale_factor = (double)QuantumRange / (max_value - min_value);\n /*\n * Convert matrix to image.\n */\n image = AcquireImage((ImageInfo *) NULL, exception);\n image->columns = matrix_info->columns;\n image->rows = matrix_info->rows;\n image->colorspace = GRAYColorspace;\n status = MagickTrue;\n image_view = AcquireAuthenticCacheView(image, exception);\n#if defined(MAGICKCORE_OPENMP_SUPPORT)\n#pragma omp parallel for schedule(static,4) shared(status) \\\n magick_threads(image,image,image->rows,1)\n#endif\n for (y = 0; y < (ssize_t) image->rows; y++)\n {\n double\n value;\n\n register Quantum\n * q;\n\n register ssize_t\n x;\n\n if (status == MagickFalse)\n continue;\n q = QueueCacheViewAuthenticPixels(image_view, 0, y, image->columns, 1, exception);\n if (q == (Quantum *) NULL)\n {\n status = MagickFalse;\n continue;\n }\n for (x = 0; x < (ssize_t) image->columns; x++)\n {\n if (GetMatrixElement(matrix_info, x, y, &value) == MagickFalse)\n continue;\n value = scale_factor * (value - min_value);\n *q = ClampToQuantum(value);\n q += GetPixelChannels(image);\n }\n if (SyncCacheViewAuthenticPixels(image_view, exception) == MagickFalse)\n status = MagickFalse;\n }\n image_view = DestroyCacheView(image_view);\n if (status == MagickFalse)\n image = DestroyImage(image);\n return (image);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % N u l l M a t r i x\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % NullMatrix() sets all elements of the matrix to zero. % % The\n * format of the ResetMagickMemory method is: % % MagickBooleanType\n * *NullMatrix(MatrixInfo *matrix_info) % % A description of each parameter\n * follows: % % o matrix_info: the matrix. %\n */\nMagickExport MagickBooleanType NullMatrix(MatrixInfo * matrix_info)\n{\n register ssize_t\n x;\n\n ssize_t\n count,\n y;\n\n unsigned char\n value;\n\n assert(matrix_info != (const MatrixInfo *)NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n if (matrix_info->type != DiskCache)\n {\n (void)ResetMagickMemory(matrix_info->elements, 0, (size_t)\n matrix_info->length);\n return (MagickTrue);\n }\n value = 0;\n (void)lseek(matrix_info->file, 0, SEEK_SET);\n for (y = 0; y < (ssize_t) matrix_info->rows; y++)\n {\n for (x = 0; x < (ssize_t) matrix_info->length; x++)\n {\n count = write(matrix_info->file, &value, sizeof(value));\n if (count != (ssize_t) sizeof(value))\n break;\n }\n if (x < (ssize_t) matrix_info->length)\n break;\n }\n return (y < (ssize_t) matrix_info->rows ? MagickFalse : MagickTrue);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % R e l i n q u i s h M a g i c k M a t r i x\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % RelinquishMagickMatrix() frees the previously acquired matrix\n * (array of % pointers to arrays of doubles). % % The format of the\n * RelinquishMagickMatrix method is: % % double\n * **RelinquishMagickMatrix(double **matrix, % const size_t\n * number_rows) % % A description of each parameter follows: % % o\n * matrix: the matrix to relinquish % % o number_rows: the first dimension\n * of the acquired matrix (number of % pointers) %\n */\nMagickExport double **\nRelinquishMagickMatrix(double **matrix,\n const size_t number_rows)\n{\n register ssize_t\n i;\n\n if (matrix == (double **)NULL)\n return (matrix);\n for (i = 0; i < (ssize_t) number_rows; i++)\n matrix[i] = (double *)RelinquishMagickMemory(matrix[i]);\n matrix = (double **)RelinquishMagickMemory(matrix);\n return (matrix);\n}\n\n\n/*\n * \n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%% %\n * % %\n * % %\n * % % S e t M a t r i x E l e m e n t\n * % %\n * % %\n * % %\n * %\n * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n * %%%% % % SetMatrixElement() sets the specifed element in the matrix. % %\n * The format of the SetMatrixElement method is: % % MagickBooleanType\n * SetMatrixElement(const MatrixInfo *matrix_info, % const ssize_t\n * x,const ssize_t y,void *value) % % A description of each parameter\n * follows: % % o matrix_info: the matrix columns. % % o x: the matrix\n * x-offset. % % o y: the matrix y-offset. % % o value: set the matrix\n * element to this value. %\n */\n\nMagickExport MagickBooleanType SetMatrixElement(const MatrixInfo * matrix_info,\n const ssize_t x, const ssize_t y, const void *value)\n{\n MagickOffsetType\n count,\n i;\n\n assert(matrix_info != (const MatrixInfo *)NULL);\n assert(matrix_info->signature == MagickCoreSignature);\n i = (MagickOffsetType) y *matrix_info->columns + x;\n if ((i < 0) ||\n ((MagickSizeType) (i * matrix_info->stride) >= matrix_info->length))\n return (MagickFalse);\n if (matrix_info->type != DiskCache)\n {\n (void)memcpy((unsigned char *)matrix_info->elements + i *\n matrix_info->stride, value, matrix_info->stride);\n return (MagickTrue);\n }\n count = WriteMatrixElements(matrix_info, i * matrix_info->stride,\n matrix_info->stride, (unsigned char *)value);\n if (count != (MagickOffsetType) matrix_info->stride)\n return (MagickFalse);\n return (MagickTrue);\n}\n"}}},{"rowIdx":98,"cells":{"source":{"kind":"string","value":"generator_spgemm_csr_asparse.c"},"original_c":{"kind":"string","value":"/******************************************************************************\n** Copyright (c) 2015-2019, Intel Corporation **\n** All rights reserved. **\n** **\n** Redistribution and use in source and binary forms, with or without **\n** modification, are permitted provided that the following conditions **\n** are met: **\n** 1. Redistributions of source code must retain the above copyright **\n** notice, this list of conditions and the following disclaimer. **\n** 2. Redistributions in binary form must reproduce the above copyright **\n** notice, this list of conditions and the following disclaimer in the **\n** documentation and/or other materials provided with the distribution. **\n** 3. Neither the name of the copyright holder nor the names of its **\n** contributors may be used to endorse or promote products derived **\n** from this software without specific prior written permission. **\n** **\n** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS **\n** \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT **\n** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR **\n** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT **\n** HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, **\n** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED **\n** TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR **\n** PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF **\n** LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING **\n** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS **\n** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. **\n******************************************************************************/\n/* Alexander Heinecke (Intel Corp.)\n******************************************************************************/\n#include \"generator_spgemm_csr_asparse.h\"\n#include \"generator_common.h\"\n#include \"libxsmm_main.h\"\n\n#if defined(LIBXSMM_OFFLOAD_TARGET)\n# pragma offload_attribute(push,target(LIBXSMM_OFFLOAD_TARGET))\n#endif\n#include <stdlib.h>\n#include <string.h>\n#include <stdio.h>\n#if defined(LIBXSMM_OFFLOAD_TARGET)\n# pragma offload_attribute(pop)\n#endif\n\nLIBXSMM_API_INTERN\nvoid libxsmm_generator_spgemm_csr_asparse( libxsmm_generated_code* io_generated_code,\n const libxsmm_gemm_descriptor* i_xgemm_desc,\n const char* i_arch,\n const unsigned int* i_row_idx,\n const unsigned int* i_column_idx,\n const double* i_values ) {\n unsigned int l_m;\n unsigned int l_z;\n unsigned int l_row_elements;\n unsigned int l_flop_count = 0;\n\n char l_new_code[512];\n int l_max_code_length = 511;\n int l_code_length = 0;\n\n LIBXSMM_UNUSED(i_values);\n\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" unsigned int l_n = 0;\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n\n /* reset C if beta is zero */\n if (0 != (LIBXSMM_GEMM_FLAG_BETA_0 & i_xgemm_desc->flags)) { /* Beta=0 */\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" unsigned int l_m = 0;\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" for ( l_m = 0; l_m < %u; l_m++) {\\n\", (unsigned int)i_xgemm_desc->m);\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n if ( i_xgemm_desc->m > 1 ) {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma simd\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma vector aligned\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n }\n if ( LIBXSMM_GEMM_PRECISION_F64 == LIBXSMM_GETENUM_INP( i_xgemm_desc->datatype ) ) {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" for ( l_n = 0; l_n < %u; l_n++) { C[(l_m*%u)+l_n] = 0.0; }\\n\", (unsigned int)i_xgemm_desc->ldc, (unsigned int)i_xgemm_desc->ldc);\n } else {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" for ( l_n = 0; l_n < %u; l_n++) { C[(l_m*%u)+l_n] = 0.0f; }\\n\", (unsigned int)i_xgemm_desc->ldc, (unsigned int)i_xgemm_desc->ldc);\n }\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" }\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n }\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \"\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n\n /* determine the correct simd pragma for each architecture */\n if ( ( strcmp( i_arch, \"noarch\" ) == 0 ) ||\n ( strcmp( i_arch, \"wsm\" ) == 0 ) ||\n ( strcmp( i_arch, \"snb\" ) == 0 ) ||\n ( strcmp( i_arch, \"hsw\" ) == 0 ) ) {\n if ( i_xgemm_desc->n > 7 ) {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma simd vectorlength(8)\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n } else if ( i_xgemm_desc->n > 3 ) {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma simd vectorlength(4)\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n } else if ( i_xgemm_desc->n > 1 ) {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma simd vectorlength(2)\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n } else {}\n\n\n } else if ( ( strcmp( i_arch, \"knl\" ) == 0 ) ||\n ( strcmp( i_arch, \"knm\" ) == 0 ) ||\n ( strcmp( i_arch, \"skx\" ) == 0 ) ||\n ( strcmp( i_arch, \"clx\" ) == 0 ) ||\n ( strcmp( i_arch, \"cpx\" ) == 0 ) ) {\n if ( (i_xgemm_desc->n > 1) ) {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma simd vectorlength(16)\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n }\n } else {\n LIBXSMM_HANDLE_ERROR( io_generated_code, LIBXSMM_ERR_ARCH );\n return;\n }\n\n if ( (i_xgemm_desc->n > 1) &&\n ((LIBXSMM_GEMM_FLAG_ALIGN_A & i_xgemm_desc->flags) != 0) &&\n ((LIBXSMM_GEMM_FLAG_ALIGN_C & i_xgemm_desc->flags) != 0) ) {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma vector aligned\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n }\n\n /* generate the actuel kernel */\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" for ( l_n = 0; l_n < %u; l_n++) {\\n\", (unsigned int)i_xgemm_desc->n);\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n\n for ( l_m = 0; l_m < (unsigned int)i_xgemm_desc->m; l_m++ ) {\n l_row_elements = i_row_idx[l_m+1] - i_row_idx[l_m];\n for ( l_z = 0; l_z < l_row_elements; l_z++ ) {\n /* check k such that we just use columns which actually need to be multiplied */\n if ( i_column_idx[i_row_idx[l_m] + l_z] < (unsigned int)i_xgemm_desc->k ) {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" C[%u+l_n] += A[%u] * B[%u+l_n];\\n\", l_m * i_xgemm_desc->ldc, i_row_idx[l_m] + l_z, i_column_idx[i_row_idx[l_m] + l_z]*i_xgemm_desc->ldb );\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n l_flop_count += 2;\n }\n }\n }\n\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" }\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n\n /* add flop counter */\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \"\\n#ifndef NDEBUG\\n#ifdef _OPENMP\\n#pragma omp atomic\\n#endif\\nlibxsmm_num_total_flops += %u;\\n#endif\\n\", l_flop_count * (unsigned int)i_xgemm_desc->m);\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n}\n\n"},"no_omp_formatted":{"kind":"string","value":"\n/* Alexander Heinecke (Intel Corp.)\n******************************************************************************/\n#include \"generator_spgemm_csr_asparse.h\"\n#include \"generator_common.h\"\n#include \"libxsmm_main.h\"\n\n#if defined(LIBXSMM_OFFLOAD_TARGET)\n# pragma offload_attribute(push,target(LIBXSMM_OFFLOAD_TARGET))\n#endif\n#include <stdlib.h>\n#include <string.h>\n#include <stdio.h>\n#if defined(LIBXSMM_OFFLOAD_TARGET)\n# pragma offload_attribute(pop)\n#endif\n\nLIBXSMM_API_INTERN\nvoid libxsmm_generator_spgemm_csr_asparse( libxsmm_generated_code* io_generated_code,\n const libxsmm_gemm_descriptor* i_xgemm_desc,\n const char* i_arch,\n const unsigned int* i_row_idx,\n const unsigned int* i_column_idx,\n const double* i_values ) {\n unsigned int l_m;\n unsigned int l_z;\n unsigned int l_row_elements;\n unsigned int l_flop_count = 0;\n\n char l_new_code[512];\n int l_max_code_length = 511;\n int l_code_length = 0;\n\n LIBXSMM_UNUSED(i_values);\n\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" unsigned int l_n = 0;\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n\n /* reset C if beta is zero */\n if (0 != (LIBXSMM_GEMM_FLAG_BETA_0 & i_xgemm_desc->flags)) { /* Beta=0 */\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" unsigned int l_m = 0;\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" for ( l_m = 0; l_m < %u; l_m++) {\\n\", (unsigned int)i_xgemm_desc->m);\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n if ( i_xgemm_desc->m > 1 ) {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma simd\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma vector aligned\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n }\n if ( LIBXSMM_GEMM_PRECISION_F64 == LIBXSMM_GETENUM_INP( i_xgemm_desc->datatype ) ) {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" for ( l_n = 0; l_n < %u; l_n++) { C[(l_m*%u)+l_n] = 0.0; }\\n\", (unsigned int)i_xgemm_desc->ldc, (unsigned int)i_xgemm_desc->ldc);\n } else {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" for ( l_n = 0; l_n < %u; l_n++) { C[(l_m*%u)+l_n] = 0.0f; }\\n\", (unsigned int)i_xgemm_desc->ldc, (unsigned int)i_xgemm_desc->ldc);\n }\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" }\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n }\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \"\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n\n /* determine the correct simd pragma for each architecture */\n if ( ( strcmp( i_arch, \"noarch\" ) == 0 ) ||\n ( strcmp( i_arch, \"wsm\" ) == 0 ) ||\n ( strcmp( i_arch, \"snb\" ) == 0 ) ||\n ( strcmp( i_arch, \"hsw\" ) == 0 ) ) {\n if ( i_xgemm_desc->n > 7 ) {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma simd vectorlength(8)\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n } else if ( i_xgemm_desc->n > 3 ) {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma simd vectorlength(4)\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n } else if ( i_xgemm_desc->n > 1 ) {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma simd vectorlength(2)\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n } else {}\n\n\n } else if ( ( strcmp( i_arch, \"knl\" ) == 0 ) ||\n ( strcmp( i_arch, \"knm\" ) == 0 ) ||\n ( strcmp( i_arch, \"skx\" ) == 0 ) ||\n ( strcmp( i_arch, \"clx\" ) == 0 ) ||\n ( strcmp( i_arch, \"cpx\" ) == 0 ) ) {\n if ( (i_xgemm_desc->n > 1) ) {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma simd vectorlength(16)\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n }\n } else {\n LIBXSMM_HANDLE_ERROR( io_generated_code, LIBXSMM_ERR_ARCH );\n return;\n }\n\n if ( (i_xgemm_desc->n > 1) &&\n ((LIBXSMM_GEMM_FLAG_ALIGN_A & i_xgemm_desc->flags) != 0) &&\n ((LIBXSMM_GEMM_FLAG_ALIGN_C & i_xgemm_desc->flags) != 0) ) {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma vector aligned\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n }\n\n /* generate the actuel kernel */\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" for ( l_n = 0; l_n < %u; l_n++) {\\n\", (unsigned int)i_xgemm_desc->n);\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n\n for ( l_m = 0; l_m < (unsigned int)i_xgemm_desc->m; l_m++ ) {\n l_row_elements = i_row_idx[l_m+1] - i_row_idx[l_m];\n for ( l_z = 0; l_z < l_row_elements; l_z++ ) {\n /* check k such that we just use columns which actually need to be multiplied */\n if ( i_column_idx[i_row_idx[l_m] + l_z] < (unsigned int)i_xgemm_desc->k ) {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" C[%u+l_n] += A[%u] * B[%u+l_n];\\n\", l_m * i_xgemm_desc->ldc, i_row_idx[l_m] + l_z, i_column_idx[i_row_idx[l_m] + l_z]*i_xgemm_desc->ldb );\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n l_flop_count += 2;\n }\n }\n }\n\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" }\\n\");\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n\n /* add flop counter */\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \"\\n#ifndef NDEBUG\\n#ifdef _OPENMP\\n\n libxsmm_append_code_as_string( io_generated_code, l_new_code, l_code_length );\n}\n\n"},"omp_formatted":{"kind":"string","value":"\n/*\n * Alexander Heinecke (Intel Corp.) ****************************************************************************\n */\n#include \"generator_spgemm_csr_asparse.h\"\n#include \"generator_common.h\"\n#include \"libxsmm_main.h\"\n\n#if defined(LIBXSMM_OFFLOAD_TARGET)\n#pragma offload_attribute(push,target(LIBXSMM_OFFLOAD_TARGET))\n#endif\n#include <stdlib.h>\n#include <string.h>\n#include <stdio.h>\n#if defined(LIBXSMM_OFFLOAD_TARGET)\n#pragma offload_attribute(pop)\n#endif\n\nLIBXSMM_API_INTERN\nvoid \nlibxsmm_generator_spgemm_csr_asparse(libxsmm_generated_code * io_generated_code,\n const libxsmm_gemm_descriptor * i_xgemm_desc,\n const char *i_arch,\n const unsigned int *i_row_idx,\n const unsigned int *i_column_idx,\n const double *i_values)\n{\n unsigned int l_m;\n unsigned int l_z;\n unsigned int l_row_elements;\n unsigned int l_flop_count = 0;\n\n char l_new_code[512];\n int l_max_code_length = 511;\n int l_code_length = 0;\n\n LIBXSMM_UNUSED(i_values);\n\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" unsigned int l_n = 0;\\n\");\n libxsmm_append_code_as_string(io_generated_code, l_new_code, l_code_length);\n\n /* reset C if beta is zero */\n if (0 != (LIBXSMM_GEMM_FLAG_BETA_0 & i_xgemm_desc->flags))\n { /* Beta=0 */\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" unsigned int l_m = 0;\\n\");\n libxsmm_append_code_as_string(io_generated_code, l_new_code, l_code_length);\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" for ( l_m = 0; l_m < %u; l_m++) {\\n\", (unsigned int)i_xgemm_desc->m);\n libxsmm_append_code_as_string(io_generated_code, l_new_code, l_code_length);\n if (i_xgemm_desc->m > 1)\n {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma simd\\n\");\n libxsmm_append_code_as_string(io_generated_code, l_new_code, l_code_length);\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma vector aligned\\n\");\n libxsmm_append_code_as_string(io_generated_code, l_new_code, l_code_length);\n }\n if (LIBXSMM_GEMM_PRECISION_F64 == LIBXSMM_GETENUM_INP(i_xgemm_desc->datatype))\n {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" for ( l_n = 0; l_n < %u; l_n++) { C[(l_m*%u)+l_n] = 0.0; }\\n\", (unsigned int)i_xgemm_desc->ldc, (unsigned int)i_xgemm_desc->ldc);\n } else\n {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" for ( l_n = 0; l_n < %u; l_n++) { C[(l_m*%u)+l_n] = 0.0f; }\\n\", (unsigned int)i_xgemm_desc->ldc, (unsigned int)i_xgemm_desc->ldc);\n }\n libxsmm_append_code_as_string(io_generated_code, l_new_code, l_code_length);\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" }\\n\");\n libxsmm_append_code_as_string(io_generated_code, l_new_code, l_code_length);\n }\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \"\\n\");\n libxsmm_append_code_as_string(io_generated_code, l_new_code, l_code_length);\n\n /* determine the correct simd pragma for each architecture */\n if ((strcmp(i_arch, \"noarch\") == 0) ||\n (strcmp(i_arch, \"wsm\") == 0) ||\n (strcmp(i_arch, \"snb\") == 0) ||\n (strcmp(i_arch, \"hsw\") == 0))\n {\n if (i_xgemm_desc->n > 7)\n {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma simd vectorlength(8)\\n\");\n libxsmm_append_code_as_string(io_generated_code, l_new_code, l_code_length);\n } else if (i_xgemm_desc->n > 3)\n {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma simd vectorlength(4)\\n\");\n libxsmm_append_code_as_string(io_generated_code, l_new_code, l_code_length);\n } else if (i_xgemm_desc->n > 1)\n {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma simd vectorlength(2)\\n\");\n libxsmm_append_code_as_string(io_generated_code, l_new_code, l_code_length);\n } else\n {\n }\n\n\n } else if ((strcmp(i_arch, \"knl\") == 0) ||\n (strcmp(i_arch, \"knm\") == 0) ||\n (strcmp(i_arch, \"skx\") == 0) ||\n (strcmp(i_arch, \"clx\") == 0) ||\n (strcmp(i_arch, \"cpx\") == 0))\n {\n if ((i_xgemm_desc->n > 1))\n {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma simd vectorlength(16)\\n\");\n libxsmm_append_code_as_string(io_generated_code, l_new_code, l_code_length);\n }\n } else\n {\n LIBXSMM_HANDLE_ERROR(io_generated_code, LIBXSMM_ERR_ARCH);\n return;\n }\n\n if ((i_xgemm_desc->n > 1) &&\n ((LIBXSMM_GEMM_FLAG_ALIGN_A & i_xgemm_desc->flags) != 0) &&\n ((LIBXSMM_GEMM_FLAG_ALIGN_C & i_xgemm_desc->flags) != 0))\n {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" #pragma vector aligned\\n\");\n libxsmm_append_code_as_string(io_generated_code, l_new_code, l_code_length);\n }\n /* generate the actuel kernel */\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" for ( l_n = 0; l_n < %u; l_n++) {\\n\", (unsigned int)i_xgemm_desc->n);\n libxsmm_append_code_as_string(io_generated_code, l_new_code, l_code_length);\n\n for (l_m = 0; l_m < (unsigned int)i_xgemm_desc->m; l_m++)\n {\n l_row_elements = i_row_idx[l_m + 1] - i_row_idx[l_m];\n for (l_z = 0; l_z < l_row_elements; l_z++)\n {\n /*\n * check k such that we just use columns which actually need to\n * be multiplied\n */\n if (i_column_idx[i_row_idx[l_m] + l_z] < (unsigned int)i_xgemm_desc->k)\n {\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" C[%u+l_n] += A[%u] * B[%u+l_n];\\n\", l_m * i_xgemm_desc->ldc, i_row_idx[l_m] + l_z, i_column_idx[i_row_idx[l_m] + l_z] * i_xgemm_desc->ldb);\n libxsmm_append_code_as_string(io_generated_code, l_new_code, l_code_length);\n l_flop_count += 2;\n }\n }\n }\n\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \" }\\n\");\n libxsmm_append_code_as_string(io_generated_code, l_new_code, l_code_length);\n\n /* add flop counter */\n l_code_length = LIBXSMM_SNPRINTF(l_new_code, l_max_code_length, \"\\n#ifndef NDEBUG\\n#ifdef _OPENMP\\n#pragma omp atomic\\n#endif\\nlibxsmm_num_total_flops += %u;\\n#endif\\n\", l_flop_count * (unsigned int)i_xgemm_desc->m);\n libxsmm_append_code_as_string(io_generated_code, l_new_code, l_code_length);\n}\n"}}},{"rowIdx":99,"cells":{"source":{"kind":"string","value":"rhs.c"},"original_c":{"kind":"string","value":"//-------------------------------------------------------------------------//\n// //\n// This benchmark is an OpenMP C version of the NPB SP code. This OpenMP //\n// C version is developed by the Center for Manycore Programming at Seoul //\n// National University and derived from the OpenMP Fortran versions in //\n// \"NPB3.3-OMP\" developed by NAS. //\n// //\n// Permission to use, copy, distribute and modify this software for any //\n// purpose with or without fee is hereby granted. This software is //\n// provided \"as is\" without express or implied warranty. //\n// //\n// Information on NPB 3.3, including the technical report, the original //\n// specifications, source code, results and information on how to submit //\n// new results, is available at: //\n// //\n// http://www.nas.nasa.gov/Software/NPB/ //\n// //\n// Send comments or suggestions for this OpenMP C version to //\n// cmp@aces.snu.ac.kr //\n// //\n// Center for Manycore Programming //\n// School of Computer Science and Engineering //\n// Seoul National University //\n// Seoul 151-744, Korea //\n// //\n// E-mail: cmp@aces.snu.ac.kr //\n// //\n//-------------------------------------------------------------------------//\n\n//-------------------------------------------------------------------------//\n// Authors: Sangmin Seo, Jungwon Kim, Jun Lee, Jeongho Nah, Gangwon Jo, //\n// and Jaejin Lee //\n//-------------------------------------------------------------------------//\n\n#include <math.h>\n#include \"header.h\"\n\nvoid compute_rhs()\n{\n int i, j, k, m;\n double aux, rho_inv, uijk, up1, um1, vijk, vp1, vm1, wijk, wp1, wm1;\n /* //kai\n int k1,k2,k3,k4,k5,k6,k7,k8,k9,k10, k11;\n consistent_data(&k1, \"int\", 1);\n consistent_data(&k2, \"int\", 1);\n consistent_data(&k3, \"int\", 1);\n consistent_data(&k4, \"int\", 1);\n consistent_data(&k5, \"int\", 1);\n consistent_data(&k6, \"int\", 1);\n consistent_data(&k7, \"int\", 1);\n consistent_data(&k8, \"int\", 1);\n consistent_data(&k9, \"int\", 1);\n consistent_data(&k10, \"int\", 1);\n consistent_data(&k11, \"int\", 1);\n*/\n if (timeron) timer_start(t_rhs);\n #pragma omp parallel default(shared) private(i,j,k,m,rho_inv,aux,uijk, \\\n up1,um1,vijk,vp1,vm1,wijk,wp1,wm1)\n {\n //---------------------------------------------------------------------\n // compute the reciprocal of density, and the kinetic energy,\n // and the speed of sound.\n //---------------------------------------------------------------------\n #pragma omp for schedule(static) nowait\n for (k = k1+1; k <= grid_points[2]-1; k++) {\n for (j = 0; j <= grid_points[1]-1; j++) {\n for (i = 0; i <= grid_points[0]-1; i++) {\n rho_inv = 1.0/u[k][j][i][0];\n rho_i[k][j][i] = rho_inv;\n us[k][j][i] = u[k][j][i][1] * rho_inv;\n vs[k][j][i] = u[k][j][i][2] * rho_inv;\n ws[k][j][i] = u[k][j][i][3] * rho_inv;\n square[k][j][i] = 0.5* (\n u[k][j][i][1]*u[k][j][i][1] +\n u[k][j][i][2]*u[k][j][i][2] +\n u[k][j][i][3]*u[k][j][i][3] ) * rho_inv;\n qs[k][j][i] = square[k][j][i] * rho_inv;\n //-------------------------------------------------------------------\n // (don't need speed and ainx until the lhs computation)\n //-------------------------------------------------------------------\n aux = c1c2*rho_inv* (u[k][j][i][4] - square[k][j][i]);\n speed[k][j][i] = sqrt(aux);\n }\n }\n\t//kai\n\tk1 = 0;\n }\n\n //---------------------------------------------------------------------\n // copy the exact forcing term to the right hand side; because\n // this forcing term is known, we can store it on the whole grid\n // including the boundary\n //---------------------------------------------------------------------\n #pragma omp for schedule(static)\n for (k = k2+1; k <= nz2+1; k++) {\n for (j = 0; j <= ny2+1; j++) {\n for (i = 0; i <= nx2+1; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = forcing[k][j][i][m];\n }\n }\n }\n\t//kai\n\tk2 = 0;\n }\n\n //---------------------------------------------------------------------\n // compute xi-direction fluxes\n //---------------------------------------------------------------------\n #pragma omp master\n if (timeron) timer_start(t_rhsx);\n #pragma omp for schedule(static) nowait\n for (k = k3+1; k <= nz2; k++) {\n for (j = 1; j <= ny2; j++) {\n for (i = 1; i <= nx2; i++) {\n uijk = us[k][j][i];\n up1 = us[k][j][i+1];\n um1 = us[k][j][i-1];\n\n rhs[k][j][i][0] = rhs[k][j][i][0] + dx1tx1 *\n (u[k][j][i+1][0] - 2.0*u[k][j][i][0] + u[k][j][i-1][0]) -\n tx2 * (u[k][j][i+1][1] - u[k][j][i-1][1]);\n\n rhs[k][j][i][1] = rhs[k][j][i][1] + dx2tx1 *\n (u[k][j][i+1][1] - 2.0*u[k][j][i][1] + u[k][j][i-1][1]) +\n xxcon2*con43 * (up1 - 2.0*uijk + um1) -\n tx2 * (u[k][j][i+1][1]*up1 - u[k][j][i-1][1]*um1 +\n (u[k][j][i+1][4] - square[k][j][i+1] -\n u[k][j][i-1][4] + square[k][j][i-1]) * c2);\n\n rhs[k][j][i][2] = rhs[k][j][i][2] + dx3tx1 *\n (u[k][j][i+1][2] - 2.0*u[k][j][i][2] + u[k][j][i-1][2]) +\n xxcon2 * (vs[k][j][i+1] - 2.0*vs[k][j][i] + vs[k][j][i-1]) -\n tx2 * (u[k][j][i+1][2]*up1 - u[k][j][i-1][2]*um1);\n\n rhs[k][j][i][3] = rhs[k][j][i][3] + dx4tx1 *\n (u[k][j][i+1][3] - 2.0*u[k][j][i][3] + u[k][j][i-1][3]) +\n xxcon2 * (ws[k][j][i+1] - 2.0*ws[k][j][i] + ws[k][j][i-1]) -\n tx2 * (u[k][j][i+1][3]*up1 - u[k][j][i-1][3]*um1);\n\n rhs[k][j][i][4] = rhs[k][j][i][4] + dx5tx1 *\n (u[k][j][i+1][4] - 2.0*u[k][j][i][4] + u[k][j][i-1][4]) +\n xxcon3 * (qs[k][j][i+1] - 2.0*qs[k][j][i] + qs[k][j][i-1]) +\n xxcon4 * (up1*up1 - 2.0*uijk*uijk + um1*um1) +\n xxcon5 * (u[k][j][i+1][4]*rho_i[k][j][i+1] -\n 2.0*u[k][j][i][4]*rho_i[k][j][i] +\n u[k][j][i-1][4]*rho_i[k][j][i-1]) -\n tx2 * ( (c1*u[k][j][i+1][4] - c2*square[k][j][i+1])*up1 -\n (c1*u[k][j][i-1][4] - c2*square[k][j][i-1])*um1 );\n }\n }\n\n //---------------------------------------------------------------------\n // add fourth order xi-direction dissipation\n //---------------------------------------------------------------------\n for (j = 1; j <= ny2; j++) {\n i = 1;\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m]- dssp *\n (5.0*u[k][j][i][m] - 4.0*u[k][j][i+1][m] + u[k][j][i+2][m]);\n }\n\n i = 2;\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n (-4.0*u[k][j][i-1][m] + 6.0*u[k][j][i][m] -\n 4.0*u[k][j][i+1][m] + u[k][j][i+2][m]);\n }\n }\n\n for (j = 1; j <= ny2; j++) {\n for (i = 3; i <= nx2-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j][i-2][m] - 4.0*u[k][j][i-1][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k][j][i+1][m] +\n u[k][j][i+2][m] );\n }\n }\n }\n\n for (j = 1; j <= ny2; j++) {\n i = nx2-1;\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j][i-2][m] - 4.0*u[k][j][i-1][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k][j][i+1][m] );\n }\n\n i = nx2;\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j][i-2][m] - 4.0*u[k][j][i-1][m] + 5.0*u[k][j][i][m] );\n }\n }\n\t//kai\n\tk3 = 0;\n }\n #pragma omp master\n {\n if (timeron) timer_stop(t_rhsx);\n\n //---------------------------------------------------------------------\n // compute eta-direction fluxes\n //---------------------------------------------------------------------\n if (timeron) timer_start(t_rhsy);\n }\n #pragma omp for schedule(static)\n for (k = k4+1; k <= nz2; k++) {\n for (j = 1; j <= ny2; j++) {\n for (i = 1; i <= nx2; i++) {\n vijk = vs[k][j][i];\n vp1 = vs[k][j+1][i];\n vm1 = vs[k][j-1][i];\n\n rhs[k][j][i][0] = rhs[k][j][i][0] + dy1ty1 *\n (u[k][j+1][i][0] - 2.0*u[k][j][i][0] + u[k][j-1][i][0]) -\n ty2 * (u[k][j+1][i][2] - u[k][j-1][i][2]);\n\n rhs[k][j][i][1] = rhs[k][j][i][1] + dy2ty1 *\n (u[k][j+1][i][1] - 2.0*u[k][j][i][1] + u[k][j-1][i][1]) +\n yycon2 * (us[k][j+1][i] - 2.0*us[k][j][i] + us[k][j-1][i]) -\n ty2 * (u[k][j+1][i][1]*vp1 - u[k][j-1][i][1]*vm1);\n\n rhs[k][j][i][2] = rhs[k][j][i][2] + dy3ty1 *\n (u[k][j+1][i][2] - 2.0*u[k][j][i][2] + u[k][j-1][i][2]) +\n yycon2*con43 * (vp1 - 2.0*vijk + vm1) -\n ty2 * (u[k][j+1][i][2]*vp1 - u[k][j-1][i][2]*vm1 +\n (u[k][j+1][i][4] - square[k][j+1][i] -\n u[k][j-1][i][4] + square[k][j-1][i]) * c2);\n\n rhs[k][j][i][3] = rhs[k][j][i][3] + dy4ty1 *\n (u[k][j+1][i][3] - 2.0*u[k][j][i][3] + u[k][j-1][i][3]) +\n yycon2 * (ws[k][j+1][i] - 2.0*ws[k][j][i] + ws[k][j-1][i]) -\n ty2 * (u[k][j+1][i][3]*vp1 - u[k][j-1][i][3]*vm1);\n\n rhs[k][j][i][4] = rhs[k][j][i][4] + dy5ty1 *\n (u[k][j+1][i][4] - 2.0*u[k][j][i][4] + u[k][j-1][i][4]) +\n yycon3 * (qs[k][j+1][i] - 2.0*qs[k][j][i] + qs[k][j-1][i]) +\n yycon4 * (vp1*vp1 - 2.0*vijk*vijk + vm1*vm1) +\n yycon5 * (u[k][j+1][i][4]*rho_i[k][j+1][i] -\n 2.0*u[k][j][i][4]*rho_i[k][j][i] +\n u[k][j-1][i][4]*rho_i[k][j-1][i]) -\n ty2 * ((c1*u[k][j+1][i][4] - c2*square[k][j+1][i]) * vp1 -\n (c1*u[k][j-1][i][4] - c2*square[k][j-1][i]) * vm1);\n }\n }\n\n //---------------------------------------------------------------------\n // add fourth order eta-direction dissipation\n //---------------------------------------------------------------------\n j = 1;\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m]- dssp *\n ( 5.0*u[k][j][i][m] - 4.0*u[k][j+1][i][m] + u[k][j+2][i][m]);\n }\n }\n\n j = 2;\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n (-4.0*u[k][j-1][i][m] + 6.0*u[k][j][i][m] -\n 4.0*u[k][j+1][i][m] + u[k][j+2][i][m]);\n }\n }\n\n for (j = 3; j <= ny2-2; j++) {\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j-2][i][m] - 4.0*u[k][j-1][i][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k][j+1][i][m] +\n u[k][j+2][i][m] );\n }\n }\n }\n\n j = ny2-1;\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j-2][i][m] - 4.0*u[k][j-1][i][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k][j+1][i][m] );\n }\n }\n\n j = ny2;\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j-2][i][m] - 4.0*u[k][j-1][i][m] + 5.0*u[k][j][i][m] );\n }\n }\n\t//kai\n\tk4 = 0;\n }\n #pragma omp master\n {\n if (timeron) timer_stop(t_rhsy);\n\n //---------------------------------------------------------------------\n // compute zeta-direction fluxes\n //---------------------------------------------------------------------\n if (timeron) timer_start(t_rhsz);\n }\n #pragma omp for schedule(static)\n for (k = k5+1; k <= grid_points[2]-2; k++) {\n for (j = 1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n wijk = ws[k][j][i];\n wp1 = ws[k+1][j][i];\n wm1 = ws[k-1][j][i];\n\n rhs[k][j][i][0] = rhs[k][j][i][0] + dz1tz1 *\n (u[k+1][j][i][0] - 2.0*u[k][j][i][0] + u[k-1][j][i][0]) -\n tz2 * (u[k+1][j][i][3] - u[k-1][j][i][3]);\n\n rhs[k][j][i][1] = rhs[k][j][i][1] + dz2tz1 *\n (u[k+1][j][i][1] - 2.0*u[k][j][i][1] + u[k-1][j][i][1]) +\n zzcon2 * (us[k+1][j][i] - 2.0*us[k][j][i] + us[k-1][j][i]) -\n tz2 * (u[k+1][j][i][1]*wp1 - u[k-1][j][i][1]*wm1);\n\n rhs[k][j][i][2] = rhs[k][j][i][2] + dz3tz1 *\n (u[k+1][j][i][2] - 2.0*u[k][j][i][2] + u[k-1][j][i][2]) +\n zzcon2 * (vs[k+1][j][i] - 2.0*vs[k][j][i] + vs[k-1][j][i]) -\n tz2 * (u[k+1][j][i][2]*wp1 - u[k-1][j][i][2]*wm1);\n\n rhs[k][j][i][3] = rhs[k][j][i][3] + dz4tz1 *\n (u[k+1][j][i][3] - 2.0*u[k][j][i][3] + u[k-1][j][i][3]) +\n zzcon2*con43 * (wp1 - 2.0*wijk + wm1) -\n tz2 * (u[k+1][j][i][3]*wp1 - u[k-1][j][i][3]*wm1 +\n (u[k+1][j][i][4] - square[k+1][j][i] -\n u[k-1][j][i][4] + square[k-1][j][i]) * c2);\n\n rhs[k][j][i][4] = rhs[k][j][i][4] + dz5tz1 *\n (u[k+1][j][i][4] - 2.0*u[k][j][i][4] + u[k-1][j][i][4]) +\n zzcon3 * (qs[k+1][j][i] - 2.0*qs[k][j][i] + qs[k-1][j][i]) +\n zzcon4 * (wp1*wp1 - 2.0*wijk*wijk + wm1*wm1) +\n zzcon5 * (u[k+1][j][i][4]*rho_i[k+1][j][i] -\n 2.0*u[k][j][i][4]*rho_i[k][j][i] +\n u[k-1][j][i][4]*rho_i[k-1][j][i]) -\n tz2 * ((c1*u[k+1][j][i][4] - c2*square[k+1][j][i])*wp1 -\n (c1*u[k-1][j][i][4] - c2*square[k-1][j][i])*wm1);\n }\n }\n\t//kai\n\tk5 = 0;\n }\n\n //---------------------------------------------------------------------\n // add fourth order zeta-direction dissipation\n //---------------------------------------------------------------------\n k = 1;\n #pragma omp for schedule(static) nowait\n for (j = k6+1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m]- dssp *\n (5.0*u[k][j][i][m] - 4.0*u[k+1][j][i][m] + u[k+2][j][i][m]);\n }\n }\n\t//kai\n\tk6 = 0;\n }\n\n k = 2;\n #pragma omp for schedule(static) nowait\n for (j = k7+1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n (-4.0*u[k-1][j][i][m] + 6.0*u[k][j][i][m] -\n 4.0*u[k+1][j][i][m] + u[k+2][j][i][m]);\n }\n }\n\t//kai\n\tk7 = 0;\n }\n\n #pragma omp for schedule(static) nowait\n for (k = k8+1; k <= grid_points[2]-4; k++) {\n for (j = 1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k-2][j][i][m] - 4.0*u[k-1][j][i][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k+1][j][i][m] +\n u[k+2][j][i][m] );\n }\n }\n }\n\t//kai\n\tk8 = 2;\n }\n\n k = grid_points[2]-3;\n #pragma omp for schedule(static) nowait\n for (j = k9+1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k-2][j][i][m] - 4.0*u[k-1][j][i][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k+1][j][i][m] );\n }\n }\n\t//kai\n\tk9 = 0;\n }\n\n k = grid_points[2]-2;\n #pragma omp for schedule(static)\n for (j = k10+1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k-2][j][i][m] - 4.0*u[k-1][j][i][m] + 5.0*u[k][j][i][m] );\n }\n }\n\t//kai\n\tk10 = 0;\n }\n #pragma omp master\n if (timeron) timer_stop(t_rhsz);\n\n #pragma omp for schedule(static) nowait\n for (k = k11+1; k <= nz2; k++) {\n for (j = 1; j <= ny2; j++) {\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] * dt;\n }\n }\n }\n\t//kai\n\tk11 = 0;\n }\n } //end parallel\n if (timeron) timer_stop(t_rhs);\n}\n"},"no_omp_formatted":{"kind":"string","value":"//-------------------------------------------------------------------------//\n// //\n// This benchmark is an OpenMP C version of the NPB SP code. This OpenMP //\n// C version is developed by the Center for Manycore Programming at Seoul //\n// National University and derived from the OpenMP Fortran versions in //\n// \"NPB3.3-OMP\" developed by NAS. //\n// //\n// Permission to use, copy, distribute and modify this software for any //\n// purpose with or without fee is hereby granted. This software is //\n// provided \"as is\" without express or implied warranty. //\n// //\n// Information on NPB 3.3, including the technical report, the original //\n// specifications, source code, results and information on how to submit //\n// new results, is available at: //\n// //\n// http://www.nas.nasa.gov/Software/NPB/ //\n// //\n// Send comments or suggestions for this OpenMP C version to //\n// cmp@aces.snu.ac.kr //\n// //\n// Center for Manycore Programming //\n// School of Computer Science and Engineering //\n// Seoul National University //\n// Seoul 151-744, Korea //\n// //\n// E-mail: cmp@aces.snu.ac.kr //\n// //\n//-------------------------------------------------------------------------//\n\n//-------------------------------------------------------------------------//\n// Authors: Sangmin Seo, Jungwon Kim, Jun Lee, Jeongho Nah, Gangwon Jo, //\n// and Jaejin Lee //\n//-------------------------------------------------------------------------//\n\n#include <math.h>\n#include \"header.h\"\n\nvoid compute_rhs()\n{\n int i, j, k, m;\n double aux, rho_inv, uijk, up1, um1, vijk, vp1, vm1, wijk, wp1, wm1;\n /* //kai\n int k1,k2,k3,k4,k5,k6,k7,k8,k9,k10, k11;\n consistent_data(&k1, \"int\", 1);\n consistent_data(&k2, \"int\", 1);\n consistent_data(&k3, \"int\", 1);\n consistent_data(&k4, \"int\", 1);\n consistent_data(&k5, \"int\", 1);\n consistent_data(&k6, \"int\", 1);\n consistent_data(&k7, \"int\", 1);\n consistent_data(&k8, \"int\", 1);\n consistent_data(&k9, \"int\", 1);\n consistent_data(&k10, \"int\", 1);\n consistent_data(&k11, \"int\", 1);\n*/\n if (timeron) timer_start(t_rhs);\n up1,um1,vijk,vp1,vm1,wijk,wp1,wm1)\n {\n //---------------------------------------------------------------------\n // compute the reciprocal of density, and the kinetic energy,\n // and the speed of sound.\n //---------------------------------------------------------------------\n for (k = k1+1; k <= grid_points[2]-1; k++) {\n for (j = 0; j <= grid_points[1]-1; j++) {\n for (i = 0; i <= grid_points[0]-1; i++) {\n rho_inv = 1.0/u[k][j][i][0];\n rho_i[k][j][i] = rho_inv;\n us[k][j][i] = u[k][j][i][1] * rho_inv;\n vs[k][j][i] = u[k][j][i][2] * rho_inv;\n ws[k][j][i] = u[k][j][i][3] * rho_inv;\n square[k][j][i] = 0.5* (\n u[k][j][i][1]*u[k][j][i][1] +\n u[k][j][i][2]*u[k][j][i][2] +\n u[k][j][i][3]*u[k][j][i][3] ) * rho_inv;\n qs[k][j][i] = square[k][j][i] * rho_inv;\n //-------------------------------------------------------------------\n // (don't need speed and ainx until the lhs computation)\n //-------------------------------------------------------------------\n aux = c1c2*rho_inv* (u[k][j][i][4] - square[k][j][i]);\n speed[k][j][i] = sqrt(aux);\n }\n }\n\t//kai\n\tk1 = 0;\n }\n\n //---------------------------------------------------------------------\n // copy the exact forcing term to the right hand side; because\n // this forcing term is known, we can store it on the whole grid\n // including the boundary\n //---------------------------------------------------------------------\n for (k = k2+1; k <= nz2+1; k++) {\n for (j = 0; j <= ny2+1; j++) {\n for (i = 0; i <= nx2+1; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = forcing[k][j][i][m];\n }\n }\n }\n\t//kai\n\tk2 = 0;\n }\n\n //---------------------------------------------------------------------\n // compute xi-direction fluxes\n //---------------------------------------------------------------------\n if (timeron) timer_start(t_rhsx);\n for (k = k3+1; k <= nz2; k++) {\n for (j = 1; j <= ny2; j++) {\n for (i = 1; i <= nx2; i++) {\n uijk = us[k][j][i];\n up1 = us[k][j][i+1];\n um1 = us[k][j][i-1];\n\n rhs[k][j][i][0] = rhs[k][j][i][0] + dx1tx1 *\n (u[k][j][i+1][0] - 2.0*u[k][j][i][0] + u[k][j][i-1][0]) -\n tx2 * (u[k][j][i+1][1] - u[k][j][i-1][1]);\n\n rhs[k][j][i][1] = rhs[k][j][i][1] + dx2tx1 *\n (u[k][j][i+1][1] - 2.0*u[k][j][i][1] + u[k][j][i-1][1]) +\n xxcon2*con43 * (up1 - 2.0*uijk + um1) -\n tx2 * (u[k][j][i+1][1]*up1 - u[k][j][i-1][1]*um1 +\n (u[k][j][i+1][4] - square[k][j][i+1] -\n u[k][j][i-1][4] + square[k][j][i-1]) * c2);\n\n rhs[k][j][i][2] = rhs[k][j][i][2] + dx3tx1 *\n (u[k][j][i+1][2] - 2.0*u[k][j][i][2] + u[k][j][i-1][2]) +\n xxcon2 * (vs[k][j][i+1] - 2.0*vs[k][j][i] + vs[k][j][i-1]) -\n tx2 * (u[k][j][i+1][2]*up1 - u[k][j][i-1][2]*um1);\n\n rhs[k][j][i][3] = rhs[k][j][i][3] + dx4tx1 *\n (u[k][j][i+1][3] - 2.0*u[k][j][i][3] + u[k][j][i-1][3]) +\n xxcon2 * (ws[k][j][i+1] - 2.0*ws[k][j][i] + ws[k][j][i-1]) -\n tx2 * (u[k][j][i+1][3]*up1 - u[k][j][i-1][3]*um1);\n\n rhs[k][j][i][4] = rhs[k][j][i][4] + dx5tx1 *\n (u[k][j][i+1][4] - 2.0*u[k][j][i][4] + u[k][j][i-1][4]) +\n xxcon3 * (qs[k][j][i+1] - 2.0*qs[k][j][i] + qs[k][j][i-1]) +\n xxcon4 * (up1*up1 - 2.0*uijk*uijk + um1*um1) +\n xxcon5 * (u[k][j][i+1][4]*rho_i[k][j][i+1] -\n 2.0*u[k][j][i][4]*rho_i[k][j][i] +\n u[k][j][i-1][4]*rho_i[k][j][i-1]) -\n tx2 * ( (c1*u[k][j][i+1][4] - c2*square[k][j][i+1])*up1 -\n (c1*u[k][j][i-1][4] - c2*square[k][j][i-1])*um1 );\n }\n }\n\n //---------------------------------------------------------------------\n // add fourth order xi-direction dissipation\n //---------------------------------------------------------------------\n for (j = 1; j <= ny2; j++) {\n i = 1;\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m]- dssp *\n (5.0*u[k][j][i][m] - 4.0*u[k][j][i+1][m] + u[k][j][i+2][m]);\n }\n\n i = 2;\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n (-4.0*u[k][j][i-1][m] + 6.0*u[k][j][i][m] -\n 4.0*u[k][j][i+1][m] + u[k][j][i+2][m]);\n }\n }\n\n for (j = 1; j <= ny2; j++) {\n for (i = 3; i <= nx2-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j][i-2][m] - 4.0*u[k][j][i-1][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k][j][i+1][m] +\n u[k][j][i+2][m] );\n }\n }\n }\n\n for (j = 1; j <= ny2; j++) {\n i = nx2-1;\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j][i-2][m] - 4.0*u[k][j][i-1][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k][j][i+1][m] );\n }\n\n i = nx2;\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j][i-2][m] - 4.0*u[k][j][i-1][m] + 5.0*u[k][j][i][m] );\n }\n }\n\t//kai\n\tk3 = 0;\n }\n if (timeron) timer_stop(t_rhsx);\n\n //---------------------------------------------------------------------\n // compute eta-direction fluxes\n //---------------------------------------------------------------------\n if (timeron) timer_start(t_rhsy);\n \n for (k = k4+1; k <= nz2; k++) {\n for (j = 1; j <= ny2; j++) {\n for (i = 1; i <= nx2; i++) {\n vijk = vs[k][j][i];\n vp1 = vs[k][j+1][i];\n vm1 = vs[k][j-1][i];\n\n rhs[k][j][i][0] = rhs[k][j][i][0] + dy1ty1 *\n (u[k][j+1][i][0] - 2.0*u[k][j][i][0] + u[k][j-1][i][0]) -\n ty2 * (u[k][j+1][i][2] - u[k][j-1][i][2]);\n\n rhs[k][j][i][1] = rhs[k][j][i][1] + dy2ty1 *\n (u[k][j+1][i][1] - 2.0*u[k][j][i][1] + u[k][j-1][i][1]) +\n yycon2 * (us[k][j+1][i] - 2.0*us[k][j][i] + us[k][j-1][i]) -\n ty2 * (u[k][j+1][i][1]*vp1 - u[k][j-1][i][1]*vm1);\n\n rhs[k][j][i][2] = rhs[k][j][i][2] + dy3ty1 *\n (u[k][j+1][i][2] - 2.0*u[k][j][i][2] + u[k][j-1][i][2]) +\n yycon2*con43 * (vp1 - 2.0*vijk + vm1) -\n ty2 * (u[k][j+1][i][2]*vp1 - u[k][j-1][i][2]*vm1 +\n (u[k][j+1][i][4] - square[k][j+1][i] -\n u[k][j-1][i][4] + square[k][j-1][i]) * c2);\n\n rhs[k][j][i][3] = rhs[k][j][i][3] + dy4ty1 *\n (u[k][j+1][i][3] - 2.0*u[k][j][i][3] + u[k][j-1][i][3]) +\n yycon2 * (ws[k][j+1][i] - 2.0*ws[k][j][i] + ws[k][j-1][i]) -\n ty2 * (u[k][j+1][i][3]*vp1 - u[k][j-1][i][3]*vm1);\n\n rhs[k][j][i][4] = rhs[k][j][i][4] + dy5ty1 *\n (u[k][j+1][i][4] - 2.0*u[k][j][i][4] + u[k][j-1][i][4]) +\n yycon3 * (qs[k][j+1][i] - 2.0*qs[k][j][i] + qs[k][j-1][i]) +\n yycon4 * (vp1*vp1 - 2.0*vijk*vijk + vm1*vm1) +\n yycon5 * (u[k][j+1][i][4]*rho_i[k][j+1][i] -\n 2.0*u[k][j][i][4]*rho_i[k][j][i] +\n u[k][j-1][i][4]*rho_i[k][j-1][i]) -\n ty2 * ((c1*u[k][j+1][i][4] - c2*square[k][j+1][i]) * vp1 -\n (c1*u[k][j-1][i][4] - c2*square[k][j-1][i]) * vm1);\n }\n }\n\n //---------------------------------------------------------------------\n // add fourth order eta-direction dissipation\n //---------------------------------------------------------------------\n j = 1;\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m]- dssp *\n ( 5.0*u[k][j][i][m] - 4.0*u[k][j+1][i][m] + u[k][j+2][i][m]);\n }\n }\n\n j = 2;\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n (-4.0*u[k][j-1][i][m] + 6.0*u[k][j][i][m] -\n 4.0*u[k][j+1][i][m] + u[k][j+2][i][m]);\n }\n }\n\n for (j = 3; j <= ny2-2; j++) {\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j-2][i][m] - 4.0*u[k][j-1][i][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k][j+1][i][m] +\n u[k][j+2][i][m] );\n }\n }\n }\n\n j = ny2-1;\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j-2][i][m] - 4.0*u[k][j-1][i][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k][j+1][i][m] );\n }\n }\n\n j = ny2;\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j-2][i][m] - 4.0*u[k][j-1][i][m] + 5.0*u[k][j][i][m] );\n }\n }\n\t//kai\n\tk4 = 0;\n }\n if (timeron) timer_stop(t_rhsy);\n\n //---------------------------------------------------------------------\n // compute zeta-direction fluxes\n //---------------------------------------------------------------------\n if (timeron) timer_start(t_rhsz);\n \n for (k = k5+1; k <= grid_points[2]-2; k++) {\n for (j = 1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n wijk = ws[k][j][i];\n wp1 = ws[k+1][j][i];\n wm1 = ws[k-1][j][i];\n\n rhs[k][j][i][0] = rhs[k][j][i][0] + dz1tz1 *\n (u[k+1][j][i][0] - 2.0*u[k][j][i][0] + u[k-1][j][i][0]) -\n tz2 * (u[k+1][j][i][3] - u[k-1][j][i][3]);\n\n rhs[k][j][i][1] = rhs[k][j][i][1] + dz2tz1 *\n (u[k+1][j][i][1] - 2.0*u[k][j][i][1] + u[k-1][j][i][1]) +\n zzcon2 * (us[k+1][j][i] - 2.0*us[k][j][i] + us[k-1][j][i]) -\n tz2 * (u[k+1][j][i][1]*wp1 - u[k-1][j][i][1]*wm1);\n\n rhs[k][j][i][2] = rhs[k][j][i][2] + dz3tz1 *\n (u[k+1][j][i][2] - 2.0*u[k][j][i][2] + u[k-1][j][i][2]) +\n zzcon2 * (vs[k+1][j][i] - 2.0*vs[k][j][i] + vs[k-1][j][i]) -\n tz2 * (u[k+1][j][i][2]*wp1 - u[k-1][j][i][2]*wm1);\n\n rhs[k][j][i][3] = rhs[k][j][i][3] + dz4tz1 *\n (u[k+1][j][i][3] - 2.0*u[k][j][i][3] + u[k-1][j][i][3]) +\n zzcon2*con43 * (wp1 - 2.0*wijk + wm1) -\n tz2 * (u[k+1][j][i][3]*wp1 - u[k-1][j][i][3]*wm1 +\n (u[k+1][j][i][4] - square[k+1][j][i] -\n u[k-1][j][i][4] + square[k-1][j][i]) * c2);\n\n rhs[k][j][i][4] = rhs[k][j][i][4] + dz5tz1 *\n (u[k+1][j][i][4] - 2.0*u[k][j][i][4] + u[k-1][j][i][4]) +\n zzcon3 * (qs[k+1][j][i] - 2.0*qs[k][j][i] + qs[k-1][j][i]) +\n zzcon4 * (wp1*wp1 - 2.0*wijk*wijk + wm1*wm1) +\n zzcon5 * (u[k+1][j][i][4]*rho_i[k+1][j][i] -\n 2.0*u[k][j][i][4]*rho_i[k][j][i] +\n u[k-1][j][i][4]*rho_i[k-1][j][i]) -\n tz2 * ((c1*u[k+1][j][i][4] - c2*square[k+1][j][i])*wp1 -\n (c1*u[k-1][j][i][4] - c2*square[k-1][j][i])*wm1);\n }\n }\n\t//kai\n\tk5 = 0;\n }\n\n //---------------------------------------------------------------------\n // add fourth order zeta-direction dissipation\n //---------------------------------------------------------------------\n k = 1;\n for (j = k6+1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m]- dssp *\n (5.0*u[k][j][i][m] - 4.0*u[k+1][j][i][m] + u[k+2][j][i][m]);\n }\n }\n\t//kai\n\tk6 = 0;\n }\n\n k = 2;\n for (j = k7+1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n (-4.0*u[k-1][j][i][m] + 6.0*u[k][j][i][m] -\n 4.0*u[k+1][j][i][m] + u[k+2][j][i][m]);\n }\n }\n\t//kai\n\tk7 = 0;\n }\n for (k = k8+1; k <= grid_points[2]-4; k++) {\n for (j = 1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k-2][j][i][m] - 4.0*u[k-1][j][i][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k+1][j][i][m] +\n u[k+2][j][i][m] );\n }\n }\n }\n\t//kai\n\tk8 = 2;\n }\n\n k = grid_points[2]-3;\n for (j = k9+1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k-2][j][i][m] - 4.0*u[k-1][j][i][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k+1][j][i][m] );\n }\n }\n\t//kai\n\tk9 = 0;\n }\n\n k = grid_points[2]-2;\n for (j = k10+1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k-2][j][i][m] - 4.0*u[k-1][j][i][m] + 5.0*u[k][j][i][m] );\n }\n }\n\t//kai\n\tk10 = 0;\n }\n if (timeron) timer_stop(t_rhsz);\n for (k = k11+1; k <= nz2; k++) {\n for (j = 1; j <= ny2; j++) {\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] * dt;\n }\n }\n }\n\t//kai\n\tk11 = 0;\n }\n } //end parallel\n if (timeron) timer_stop(t_rhs);\n}\n"},"omp_formatted":{"kind":"string","value":"//-------------------------------------------------------------------------//\n// //\n// This benchmark is an OpenMP C version of the NPB SP code. This OpenMP //\n// C version is developed by the Center for Manycore Programming at Seoul //\n// National University and derived from the OpenMP Fortran versions in //\n// \"NPB3.3-OMP\" developed by NAS. //\n// //\n// Permission to use, copy, distribute and modify this software for any //\n// purpose with or without fee is hereby granted. This software is //\n// provided \"as is\" without express or implied warranty. //\n// //\n// Information on NPB 3.3, including the technical report, the original //\n// specifications, source code, results and information on how to submit //\n// new results, is available at: //\n// //\n// http://www.nas.nasa.gov/Software/NPB/ //\n// //\n// Send comments or suggestions for this OpenMP C version to //\n// cmp@aces.snu.ac.kr //\n// //\n// Center for Manycore Programming //\n// School of Computer Science and Engineering //\n// Seoul National University //\n// Seoul 151-744, Korea //\n// //\n// E-mail: cmp@aces.snu.ac.kr //\n// //\n//-------------------------------------------------------------------------//\n\n//-------------------------------------------------------------------------//\n// Authors: Sangmin Seo, Jungwon Kim, Jun Lee, Jeongho Nah, Gangwon Jo, //\n// and Jaejin Lee //\n//-------------------------------------------------------------------------//\n\n#include <math.h>\n#include \"header.h\"\n\nvoid compute_rhs()\n{\n int i, j, k, m;\n double aux, rho_inv, uijk, up1, um1, vijk, vp1, vm1, wijk, wp1, wm1;\n /* //kai\n int k1,k2,k3,k4,k5,k6,k7,k8,k9,k10, k11;\n consistent_data(&k1, \"int\", 1);\n consistent_data(&k2, \"int\", 1);\n consistent_data(&k3, \"int\", 1);\n consistent_data(&k4, \"int\", 1);\n consistent_data(&k5, \"int\", 1);\n consistent_data(&k6, \"int\", 1);\n consistent_data(&k7, \"int\", 1);\n consistent_data(&k8, \"int\", 1);\n consistent_data(&k9, \"int\", 1);\n consistent_data(&k10, \"int\", 1);\n consistent_data(&k11, \"int\", 1);\n*/\n if (timeron) timer_start(t_rhs);\n #pragma omp parallel default(shared) private(i,j,k,m,rho_inv,aux,uijk, \\\n up1,um1,vijk,vp1,vm1,wijk,wp1,wm1)\n {\n //---------------------------------------------------------------------\n // compute the reciprocal of density, and the kinetic energy,\n // and the speed of sound.\n //---------------------------------------------------------------------\n #pragma omp for schedule(static) nowait\n for (k = k1+1; k <= grid_points[2]-1; k++) {\n for (j = 0; j <= grid_points[1]-1; j++) {\n for (i = 0; i <= grid_points[0]-1; i++) {\n rho_inv = 1.0/u[k][j][i][0];\n rho_i[k][j][i] = rho_inv;\n us[k][j][i] = u[k][j][i][1] * rho_inv;\n vs[k][j][i] = u[k][j][i][2] * rho_inv;\n ws[k][j][i] = u[k][j][i][3] * rho_inv;\n square[k][j][i] = 0.5* (\n u[k][j][i][1]*u[k][j][i][1] +\n u[k][j][i][2]*u[k][j][i][2] +\n u[k][j][i][3]*u[k][j][i][3] ) * rho_inv;\n qs[k][j][i] = square[k][j][i] * rho_inv;\n //-------------------------------------------------------------------\n // (don't need speed and ainx until the lhs computation)\n //-------------------------------------------------------------------\n aux = c1c2*rho_inv* (u[k][j][i][4] - square[k][j][i]);\n speed[k][j][i] = sqrt(aux);\n }\n }\n\t//kai\n\tk1 = 0;\n }\n\n //---------------------------------------------------------------------\n // copy the exact forcing term to the right hand side; because\n // this forcing term is known, we can store it on the whole grid\n // including the boundary\n //---------------------------------------------------------------------\n #pragma omp for schedule(static)\n for (k = k2+1; k <= nz2+1; k++) {\n for (j = 0; j <= ny2+1; j++) {\n for (i = 0; i <= nx2+1; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = forcing[k][j][i][m];\n }\n }\n }\n\t//kai\n\tk2 = 0;\n }\n\n //---------------------------------------------------------------------\n // compute xi-direction fluxes\n //---------------------------------------------------------------------\n #pragma omp master\n if (timeron) timer_start(t_rhsx);\n #pragma omp for schedule(static) nowait\n for (k = k3+1; k <= nz2; k++) {\n for (j = 1; j <= ny2; j++) {\n for (i = 1; i <= nx2; i++) {\n uijk = us[k][j][i];\n up1 = us[k][j][i+1];\n um1 = us[k][j][i-1];\n\n rhs[k][j][i][0] = rhs[k][j][i][0] + dx1tx1 *\n (u[k][j][i+1][0] - 2.0*u[k][j][i][0] + u[k][j][i-1][0]) -\n tx2 * (u[k][j][i+1][1] - u[k][j][i-1][1]);\n\n rhs[k][j][i][1] = rhs[k][j][i][1] + dx2tx1 *\n (u[k][j][i+1][1] - 2.0*u[k][j][i][1] + u[k][j][i-1][1]) +\n xxcon2*con43 * (up1 - 2.0*uijk + um1) -\n tx2 * (u[k][j][i+1][1]*up1 - u[k][j][i-1][1]*um1 +\n (u[k][j][i+1][4] - square[k][j][i+1] -\n u[k][j][i-1][4] + square[k][j][i-1]) * c2);\n\n rhs[k][j][i][2] = rhs[k][j][i][2] + dx3tx1 *\n (u[k][j][i+1][2] - 2.0*u[k][j][i][2] + u[k][j][i-1][2]) +\n xxcon2 * (vs[k][j][i+1] - 2.0*vs[k][j][i] + vs[k][j][i-1]) -\n tx2 * (u[k][j][i+1][2]*up1 - u[k][j][i-1][2]*um1);\n\n rhs[k][j][i][3] = rhs[k][j][i][3] + dx4tx1 *\n (u[k][j][i+1][3] - 2.0*u[k][j][i][3] + u[k][j][i-1][3]) +\n xxcon2 * (ws[k][j][i+1] - 2.0*ws[k][j][i] + ws[k][j][i-1]) -\n tx2 * (u[k][j][i+1][3]*up1 - u[k][j][i-1][3]*um1);\n\n rhs[k][j][i][4] = rhs[k][j][i][4] + dx5tx1 *\n (u[k][j][i+1][4] - 2.0*u[k][j][i][4] + u[k][j][i-1][4]) +\n xxcon3 * (qs[k][j][i+1] - 2.0*qs[k][j][i] + qs[k][j][i-1]) +\n xxcon4 * (up1*up1 - 2.0*uijk*uijk + um1*um1) +\n xxcon5 * (u[k][j][i+1][4]*rho_i[k][j][i+1] -\n 2.0*u[k][j][i][4]*rho_i[k][j][i] +\n u[k][j][i-1][4]*rho_i[k][j][i-1]) -\n tx2 * ( (c1*u[k][j][i+1][4] - c2*square[k][j][i+1])*up1 -\n (c1*u[k][j][i-1][4] - c2*square[k][j][i-1])*um1 );\n }\n }\n\n //---------------------------------------------------------------------\n // add fourth order xi-direction dissipation\n //---------------------------------------------------------------------\n for (j = 1; j <= ny2; j++) {\n i = 1;\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m]- dssp *\n (5.0*u[k][j][i][m] - 4.0*u[k][j][i+1][m] + u[k][j][i+2][m]);\n }\n\n i = 2;\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n (-4.0*u[k][j][i-1][m] + 6.0*u[k][j][i][m] -\n 4.0*u[k][j][i+1][m] + u[k][j][i+2][m]);\n }\n }\n\n for (j = 1; j <= ny2; j++) {\n for (i = 3; i <= nx2-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j][i-2][m] - 4.0*u[k][j][i-1][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k][j][i+1][m] +\n u[k][j][i+2][m] );\n }\n }\n }\n\n for (j = 1; j <= ny2; j++) {\n i = nx2-1;\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j][i-2][m] - 4.0*u[k][j][i-1][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k][j][i+1][m] );\n }\n\n i = nx2;\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j][i-2][m] - 4.0*u[k][j][i-1][m] + 5.0*u[k][j][i][m] );\n }\n }\n\t//kai\n\tk3 = 0;\n }\n #pragma omp master\n {\n if (timeron) timer_stop(t_rhsx);\n\n //---------------------------------------------------------------------\n // compute eta-direction fluxes\n //---------------------------------------------------------------------\n if (timeron) timer_start(t_rhsy);\n }\n #pragma omp for schedule(static)\n for (k = k4+1; k <= nz2; k++) {\n for (j = 1; j <= ny2; j++) {\n for (i = 1; i <= nx2; i++) {\n vijk = vs[k][j][i];\n vp1 = vs[k][j+1][i];\n vm1 = vs[k][j-1][i];\n\n rhs[k][j][i][0] = rhs[k][j][i][0] + dy1ty1 *\n (u[k][j+1][i][0] - 2.0*u[k][j][i][0] + u[k][j-1][i][0]) -\n ty2 * (u[k][j+1][i][2] - u[k][j-1][i][2]);\n\n rhs[k][j][i][1] = rhs[k][j][i][1] + dy2ty1 *\n (u[k][j+1][i][1] - 2.0*u[k][j][i][1] + u[k][j-1][i][1]) +\n yycon2 * (us[k][j+1][i] - 2.0*us[k][j][i] + us[k][j-1][i]) -\n ty2 * (u[k][j+1][i][1]*vp1 - u[k][j-1][i][1]*vm1);\n\n rhs[k][j][i][2] = rhs[k][j][i][2] + dy3ty1 *\n (u[k][j+1][i][2] - 2.0*u[k][j][i][2] + u[k][j-1][i][2]) +\n yycon2*con43 * (vp1 - 2.0*vijk + vm1) -\n ty2 * (u[k][j+1][i][2]*vp1 - u[k][j-1][i][2]*vm1 +\n (u[k][j+1][i][4] - square[k][j+1][i] -\n u[k][j-1][i][4] + square[k][j-1][i]) * c2);\n\n rhs[k][j][i][3] = rhs[k][j][i][3] + dy4ty1 *\n (u[k][j+1][i][3] - 2.0*u[k][j][i][3] + u[k][j-1][i][3]) +\n yycon2 * (ws[k][j+1][i] - 2.0*ws[k][j][i] + ws[k][j-1][i]) -\n ty2 * (u[k][j+1][i][3]*vp1 - u[k][j-1][i][3]*vm1);\n\n rhs[k][j][i][4] = rhs[k][j][i][4] + dy5ty1 *\n (u[k][j+1][i][4] - 2.0*u[k][j][i][4] + u[k][j-1][i][4]) +\n yycon3 * (qs[k][j+1][i] - 2.0*qs[k][j][i] + qs[k][j-1][i]) +\n yycon4 * (vp1*vp1 - 2.0*vijk*vijk + vm1*vm1) +\n yycon5 * (u[k][j+1][i][4]*rho_i[k][j+1][i] -\n 2.0*u[k][j][i][4]*rho_i[k][j][i] +\n u[k][j-1][i][4]*rho_i[k][j-1][i]) -\n ty2 * ((c1*u[k][j+1][i][4] - c2*square[k][j+1][i]) * vp1 -\n (c1*u[k][j-1][i][4] - c2*square[k][j-1][i]) * vm1);\n }\n }\n\n //---------------------------------------------------------------------\n // add fourth order eta-direction dissipation\n //---------------------------------------------------------------------\n j = 1;\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m]- dssp *\n ( 5.0*u[k][j][i][m] - 4.0*u[k][j+1][i][m] + u[k][j+2][i][m]);\n }\n }\n\n j = 2;\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n (-4.0*u[k][j-1][i][m] + 6.0*u[k][j][i][m] -\n 4.0*u[k][j+1][i][m] + u[k][j+2][i][m]);\n }\n }\n\n for (j = 3; j <= ny2-2; j++) {\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j-2][i][m] - 4.0*u[k][j-1][i][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k][j+1][i][m] +\n u[k][j+2][i][m] );\n }\n }\n }\n\n j = ny2-1;\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j-2][i][m] - 4.0*u[k][j-1][i][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k][j+1][i][m] );\n }\n }\n\n j = ny2;\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k][j-2][i][m] - 4.0*u[k][j-1][i][m] + 5.0*u[k][j][i][m] );\n }\n }\n\t//kai\n\tk4 = 0;\n }\n #pragma omp master\n {\n if (timeron) timer_stop(t_rhsy);\n\n //---------------------------------------------------------------------\n // compute zeta-direction fluxes\n //---------------------------------------------------------------------\n if (timeron) timer_start(t_rhsz);\n }\n #pragma omp for schedule(static)\n for (k = k5+1; k <= grid_points[2]-2; k++) {\n for (j = 1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n wijk = ws[k][j][i];\n wp1 = ws[k+1][j][i];\n wm1 = ws[k-1][j][i];\n\n rhs[k][j][i][0] = rhs[k][j][i][0] + dz1tz1 *\n (u[k+1][j][i][0] - 2.0*u[k][j][i][0] + u[k-1][j][i][0]) -\n tz2 * (u[k+1][j][i][3] - u[k-1][j][i][3]);\n\n rhs[k][j][i][1] = rhs[k][j][i][1] + dz2tz1 *\n (u[k+1][j][i][1] - 2.0*u[k][j][i][1] + u[k-1][j][i][1]) +\n zzcon2 * (us[k+1][j][i] - 2.0*us[k][j][i] + us[k-1][j][i]) -\n tz2 * (u[k+1][j][i][1]*wp1 - u[k-1][j][i][1]*wm1);\n\n rhs[k][j][i][2] = rhs[k][j][i][2] + dz3tz1 *\n (u[k+1][j][i][2] - 2.0*u[k][j][i][2] + u[k-1][j][i][2]) +\n zzcon2 * (vs[k+1][j][i] - 2.0*vs[k][j][i] + vs[k-1][j][i]) -\n tz2 * (u[k+1][j][i][2]*wp1 - u[k-1][j][i][2]*wm1);\n\n rhs[k][j][i][3] = rhs[k][j][i][3] + dz4tz1 *\n (u[k+1][j][i][3] - 2.0*u[k][j][i][3] + u[k-1][j][i][3]) +\n zzcon2*con43 * (wp1 - 2.0*wijk + wm1) -\n tz2 * (u[k+1][j][i][3]*wp1 - u[k-1][j][i][3]*wm1 +\n (u[k+1][j][i][4] - square[k+1][j][i] -\n u[k-1][j][i][4] + square[k-1][j][i]) * c2);\n\n rhs[k][j][i][4] = rhs[k][j][i][4] + dz5tz1 *\n (u[k+1][j][i][4] - 2.0*u[k][j][i][4] + u[k-1][j][i][4]) +\n zzcon3 * (qs[k+1][j][i] - 2.0*qs[k][j][i] + qs[k-1][j][i]) +\n zzcon4 * (wp1*wp1 - 2.0*wijk*wijk + wm1*wm1) +\n zzcon5 * (u[k+1][j][i][4]*rho_i[k+1][j][i] -\n 2.0*u[k][j][i][4]*rho_i[k][j][i] +\n u[k-1][j][i][4]*rho_i[k-1][j][i]) -\n tz2 * ((c1*u[k+1][j][i][4] - c2*square[k+1][j][i])*wp1 -\n (c1*u[k-1][j][i][4] - c2*square[k-1][j][i])*wm1);\n }\n }\n\t//kai\n\tk5 = 0;\n }\n\n //---------------------------------------------------------------------\n // add fourth order zeta-direction dissipation\n //---------------------------------------------------------------------\n k = 1;\n #pragma omp for schedule(static) nowait\n for (j = k6+1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m]- dssp *\n (5.0*u[k][j][i][m] - 4.0*u[k+1][j][i][m] + u[k+2][j][i][m]);\n }\n }\n\t//kai\n\tk6 = 0;\n }\n\n k = 2;\n #pragma omp for schedule(static) nowait\n for (j = k7+1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n (-4.0*u[k-1][j][i][m] + 6.0*u[k][j][i][m] -\n 4.0*u[k+1][j][i][m] + u[k+2][j][i][m]);\n }\n }\n\t//kai\n\tk7 = 0;\n }\n\n #pragma omp for schedule(static) nowait\n for (k = k8+1; k <= grid_points[2]-4; k++) {\n for (j = 1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k-2][j][i][m] - 4.0*u[k-1][j][i][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k+1][j][i][m] +\n u[k+2][j][i][m] );\n }\n }\n }\n\t//kai\n\tk8 = 2;\n }\n\n k = grid_points[2]-3;\n #pragma omp for schedule(static) nowait\n for (j = k9+1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k-2][j][i][m] - 4.0*u[k-1][j][i][m] +\n 6.0*u[k][j][i][m] - 4.0*u[k+1][j][i][m] );\n }\n }\n\t//kai\n\tk9 = 0;\n }\n\n k = grid_points[2]-2;\n #pragma omp for schedule(static)\n for (j = k10+1; j <= grid_points[1]-2; j++) {\n for (i = 1; i <= grid_points[0]-2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] - dssp *\n ( u[k-2][j][i][m] - 4.0*u[k-1][j][i][m] + 5.0*u[k][j][i][m] );\n }\n }\n\t//kai\n\tk10 = 0;\n }\n #pragma omp master\n if (timeron) timer_stop(t_rhsz);\n\n #pragma omp for schedule(static) nowait\n for (k = k11+1; k <= nz2; k++) {\n for (j = 1; j <= ny2; j++) {\n for (i = 1; i <= nx2; i++) {\n for (m = 0; m < 5; m++) {\n rhs[k][j][i][m] = rhs[k][j][i][m] * dt;\n }\n }\n }\n\t//kai\n\tk11 = 0;\n }\n } //end parallel\n if (timeron) timer_stop(t_rhs);\n}\n"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":0,"numItemsPerPage":100,"numTotalItems":77486,"offset":0,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NjY2NzE4OSwic3ViIjoiL2RhdGFzZXRzL2NlbGluZWxlZS90aGVzdGFja19vbXBfcGFpcmVkIiwiZXhwIjoxNzc2NjcwNzg5LCJpc3MiOiJodHRwczovL2h1Z2dpbmdmYWNlLmNvIn0.WZnEhuT0AQ7uloRtiQlX-kfLWsTNaLpOUfrJzNGtAXQ2G_khttfCBWa8w8feJOi1smb0beEmgjHuSz2sN5m0BQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":77486,"numBytesParquet":1996482693},{"config":"default","split":"test","numRows":9686,"numBytesParquet":259870837},{"config":"default","split":"valid","numRows":9686,"numBytesParquet":246337165}]},"discussionsStats":{"closed":0,"open":1,"total":1},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
source stringlengths 3 92 | original_c stringlengths 26 2.25M | no_omp_formatted stringlengths 0 2.25M | omp_formatted stringlengths 0 2.25M |
|---|---|---|---|
elemwise_binary_op.h | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you ... |
/*!
* \file elemwise_binary_op.h
* \brief Function definition of elementwise binary operators
*/
#ifndef MXNET_OPERATOR_TENSOR_ELEMWISE_BINARY_OP_H_
#define MXNET_OPERATOR_TENSOR_ELEMWISE_BINARY_OP_H_
#include <mxnet/operator_util.h>
#include <mxnet/op_attr_types.h>
#include <vector>
#include <string>
#include <u... |
/*!
* \file elemwise_binary_op.h
* \brief Function definition of elementwise binary operators
*/
#ifndef MXNET_OPERATOR_TENSOR_ELEMWISE_BINARY_OP_H_
#define MXNET_OPERATOR_TENSOR_ELEMWISE_BINARY_OP_H_
#include <mxnet/operator_util.h>
#include <mxnet/op_attr_types.h>
#include <vector>
#include <string>
#include <u... |
pf_fold.c | /*
* partiton function for single RNA secondary structures
*
* Simplified interfaces and backward compatibility
* wrappers
*
* Ivo L Hofacker + Ronny Lorenz
* Vienna RNA package
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
/*####... | /*
* partiton function for single RNA secondary structures
*
* Simplified interfaces and backward compatibility wrappers
*
* Ivo L Hofacker + Ronny Lorenz Vienna RNA package
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
/* ########################################### */
/* # deprecated functions below ... | /*
* partiton function for single RNA secondary structures
*
* Simplified interfaces and backward compatibility wrappers
*
* Ivo L Hofacker + Ronny Lorenz Vienna RNA package
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
/* ########################################### */
/* # deprecated functions below ... |
GB_binop__rdiv_int8.c |
//------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SPDX... |
//------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SPDX... |
//------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SPDX... |
tree-vectorizer.h | /* Vectorizer
Copyright (C) 2003-2019 Free Software Foundation, Inc.
Contributed by Dorit Naishlos <dorit@il.ibm.com>
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either ve... |
#ifndef GCC_TREE_VECTORIZER_H
#define GCC_TREE_VECTORIZER_H
typedef struct _stmt_vec_info *stmt_vec_info;
#include "tree-data-ref.h"
#include "tree-hash-traits.h"
#include "target.h"
/* Used for naming of new temporaries. */
enum vect_var_kind
{
vect_simple_var,
vect_pointer_var,
vect_scalar_var,
... |
#ifndef GCC_TREE_VECTORIZER_H
#define GCC_TREE_VECTORIZER_H
typedef struct _stmt_vec_info *stmt_vec_info;
#include "tree-data-ref.h"
#include "tree-hash-traits.h"
#include "target.h"
/* Used for naming of new temporaries. */
enum vect_var_kind
{
vect_simple_var,
vect_pointer_var,
vect_scalar_var,
... |
ztrsm.c | #include "blas.h"
#include "error.h"
#include <stdio.h>
#include "handle.h"
#include "config.h"
#include "ztrsm.fatbin.c"
static inline size_t min(size_t a, size_t b) { return (a < b) ? a : b; }
static inline size_t max(size_t a, size_t b) { return (a > b) ? a : b; }
static inline CUresult cuMemcpyHtoD2DAsync(CUdevic... | #include "blas.h"
#include "error.h"
#include <stdio.h>
#include "handle.h"
#include "config.h"
#include "ztrsm.fatbin.c"
static inline size_t
min(size_t a, size_t b)
{
return (a < b) ? a : b;
}
static inline size_t
max(size_t a, size_t b)
{
return (a > b) ? a : b;
}
static inline CUresult
cuMemcpyHtoD2DAs... | #include "blas.h"
#include "error.h"
#include <stdio.h>
#include "handle.h"
#include "config.h"
#include "ztrsm.fatbin.c"
static inline size_t
min(size_t a, size_t b)
{
return (a < b) ? a : b;
}
static inline size_t
max(size_t a, size_t b)
{
return (a > b) ? a : b;
}
static inline CUresult
cuMemcpyHtoD2DAs... |
binStruct.h | #ifndef binStruct_h
#define binStruct_h
#include "../../baseFunctions/fpBaseNode.h"
#include "../../baseFunctions/MWC.h"
#include "obsIndexAndClassVec.h"
#include "zipClassAndValue.h"
#include "processingNodeBin.h"
#include <vector>
#include <assert.h>
namespace fp{
template <typename T, typename Q>
class binStruc... | #ifndef binStruct_h
#define binStruct_h
#include "../../baseFunctions/fpBaseNode.h"
#include "../../baseFunctions/MWC.h"
#include "obsIndexAndClassVec.h"
#include "zipClassAndValue.h"
#include "processingNodeBin.h"
#include <vector>
#include <assert.h>
namespace fp{
template <typename T, typename Q>
class binStruc... | #ifndef binStruct_h
#define binStruct_h
#include "../../baseFunctions/fpBaseNode.h"
#include "../../baseFunctions/MWC.h"
#include "obsIndexAndClassVec.h"
#include "zipClassAndValue.h"
#include "processingNodeBin.h"
#include <vector>
#include <assert.h>
namespace fp{
template <typename T, typename Q>
class binStruc... |
particle_levelset_utilities.h | /*
==============================================================================
KratosTestApplication
A library based on:
Kratos
A General Purpose Software for Multi-Physics Finite Element Analysis
Version 1.0 (Released on march 05, 2007).
Copyright 2010
Pooyan Dadvand, Riccardo Rossi
pooyan@cimne.upc.edu
rrossi@cim... |
//
// Project Name: Kratos
// Last Modified by: $Author: rrossi $
// Date: $Date: 2007-03-06 10:30:31 $
// Revision: $Revision: 1.2 $
//
//
#if !defined(KRATOS_PARTICLE_LEVELSET_UTILITIES_INCLUDED )
#define KRATOS_PARTICLE_LEVELSET_UTILITIES_INCLUDED
// System include... |
//
// Project Name: Kratos
// Last Modified by: $Author: rrossi $
// Date: $Date: 2007-03-06 10:30:31 $
// Revision: $Revision: 1.2 $
//
//
#if !defined(KRATOS_PARTICLE_LEVELSET_UTILITIES_INCLUDED )
#define KRATOS_PARTICLE_LEVELSET_UTILITIES_INCLUDED
// System include... |
hypre_merge_sort.c | /******************************************************************************
* Copyright 1998-2019 Lawrence Livermore National Security, LLC and other
* HYPRE Project Developers. See the top-level COPYRIGHT file for details.
*
* SPDX-License-Identifier: (Apache-2.0 OR MIT)
**************************************... |
#include "_hypre_utilities.h"
#include "hypre_hopscotch_hash.h"
#include "../seq_mv/HYPRE_seq_mv.h"
//#define DBG_MERGE_SORT
#ifdef DBG_MERGE_SORT
#include <algorithm>
#include <unordered_map>
#endif
#define SWAP(T, a, b) do { T tmp = a; a = b; b = tmp; } while (0)
/* union of two sorted (in ascending order) array ... |
#include "_hypre_utilities.h"
#include "hypre_hopscotch_hash.h"
#include "../seq_mv/HYPRE_seq_mv.h"
//#define DBG_MERGE_SORT
#ifdef DBG_MERGE_SORT
#include <algorithm>
#include <unordered_map>
#endif
#define SWAP(T, a, b) do { T tmp = a; a = b; b = tmp; } while (0)
/* union of two sorted (in ascending order) array ... |
par_mgr.c | /******************************************************************************
* Copyright 1998-2019 Lawrence Livermore National Security, LLC and other
* HYPRE Project Developers. See the top-level COPYRIGHT file for details.
*
* SPDX-License-Identifier: (Apache-2.0 OR MIT)
**************************************... |
/******************************************************************************
*
* Two-grid system solver
*
*****************************************************************************/
#include "_hypre_parcsr_ls.h"
#include "par_amg.h"
#include "par_mgr.h"
#ifdef HYPRE_USING_DSUPERLU
#include "dsuperlu.h"
#e... |
/******************************************************************************
*
* Two-grid system solver
*
*****************************************************************************/
#include "_hypre_parcsr_ls.h"
#include "par_amg.h"
#include "par_mgr.h"
#ifdef HYPRE_USING_DSUPERLU
#include "dsuperlu.h"
#e... |
GB_binop__isge_int32.c | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... |
omp_pause_resource.c | // RUN: %libomp-compile-and-run
#include <stdio.h>
#include "omp_testsuite.h"
int test_omp_pause_resource() {
int fails, nthreads, my_dev;
fails = 0;
nthreads = 0;
my_dev = omp_get_initial_device();
#pragma omp parallel
#pragma omp single
nthreads = omp_get_num_threads();
if (omp_pause_resource(omp_paus... | // RUN:%libomp - compile - and - run
#include <stdio.h>
#include "omp_testsuite.h"
int
test_omp_pause_resource()
{
int fails, nthreads, my_dev;
fails = 0;
nthreads = 0;
my_dev = omp_get_initial_device();
nthreads = omp_get_num_threads();
if (omp_pause_resource(omp_pause_soft, my_dev))
... | // RUN:%libomp - compile - and - run
#include <stdio.h>
#include "omp_testsuite.h"
int
test_omp_pause_resource()
{
int fails, nthreads, my_dev;
fails = 0;
nthreads = 0;
my_dev = omp_get_initial_device();
#pragma omp parallel
#pragma omp single
nthreads = omp_get_num_threads();
if (omp_pause... |
fibo_openmp.c | #include <stdio.h>
#include <math.h>
/***** Begin *****/
long long fiboArry[100];
unsigned long long fibo(int n){
return 1/sqrt(5) * (pow((1+sqrt(5))/2, n) - pow((1-sqrt(5))/2, n));
}
int main()
{
int i;
int n;
// long long temp1 = 1;
// long long temp2 = 1;
// long long next_fibo;
scanf("%... | #include <stdio.h>
#include <math.h>
/***** Begin *****/
long long fiboArry[100];
unsigned long long
fibo(int n)
{
return 1 / sqrt(5) * (pow((1 + sqrt(5)) / 2, n) - pow((1 - sqrt(5)) / 2, n));
}
int
main()
{
int i;
int n;
//long long temp1 = 1;
//long long temp2 = 1;
//long long next_fibo;
... | #include <stdio.h>
#include <math.h>
/***** Begin *****/
long long fiboArry[100];
unsigned long long
fibo(int n)
{
return 1 / sqrt(5) * (pow((1 + sqrt(5)) / 2, n) - pow((1 - sqrt(5)) / 2, n));
}
int
main()
{
int i;
int n;
//long long temp1 = 1;
//long long temp2 = 1;
//long long next_fibo;
... |
io_and_allocation.h | #ifndef IO_AND_ALLOCATION
#define IO_AND_ALLOCATION
#include <iostream>
#include <string>
#include <sstream>
#include <fstream>
#include <vector>
#include <bitset>
#include <ctime>
#include <algorithm>
#include <numeric>
#include <random>
#include <cmath> // log2
//#include <omp.h>
#include "config.h"
#include "help... | #ifndef IO_AND_ALLOCATION
#define IO_AND_ALLOCATION
#include <iostream>
#include <string>
#include <sstream>
#include <fstream>
#include <vector>
#include <bitset>
#include <ctime>
#include <algorithm>
#include <numeric>
#include <random>
#include <cmath> // log2
//
#include <omp.h>
#include "config.h"
#include "hel... | #ifndef IO_AND_ALLOCATION
#define IO_AND_ALLOCATION
#include <iostream>
#include <string>
#include <sstream>
#include <fstream>
#include <vector>
#include <bitset>
#include <ctime>
#include <algorithm>
#include <numeric>
#include <random>
#include <cmath> // log2
//
#include <omp.h>
#include "config.h"
#include "hel... |
decorate.c | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% ... |
/*
* Include declarations.
*/
#include "MagickCore/studio.h"
#include "MagickCore/cache-view.h"
#include "MagickCore/color-private.h"
#include "MagickCore/colorspace-private.h"
#include "MagickCore/composite.h"
#include "MagickCore/decorate.h"
#include "MagickCore/exception.h"
#include "MagickCore/exception-privat... |
/*
* Include declarations.
*/
#include "MagickCore/studio.h"
#include "MagickCore/cache-view.h"
#include "MagickCore/color-private.h"
#include "MagickCore/colorspace-private.h"
#include "MagickCore/composite.h"
#include "MagickCore/decorate.h"
#include "MagickCore/exception.h"
#include "MagickCore/exception-privat... |
3d25pt_var.lbpar.c | #include <omp.h>
#include <math.h>
#define ceild(n,d) ceil(((double)(n))/((double)(d)))
#define floord(n,d) floor(((double)(n))/((double)(d)))
#define max(x,y) ((x) > (y)? (x) : (y))
#define min(x,y) ((x) < (y)? (x) : (y))
/*
* Order-1, 3D 25 point stencil with axis-symmetric ariable coefficients
* Adapted fr... | #include <omp.h>
#include <math.h>
#define ceild(n,d) ceil(((double)(n))/((double)(d)))
#define floord(n,d) floor(((double)(n))/((double)(d)))
#define max(x,y) ((x) > (y)? (x) : (y))
#define min(x,y) ((x) < (y)? (x) : (y))
/*
* Order-1, 3D 25 point stencil with axis-symmetric ariable coefficients
* Adapted fr... | #include <omp.h>
#include <math.h>
#define ceild(n,d) ceil(((double)(n))/((double)(d)))
#define floord(n,d) floor(((double)(n))/((double)(d)))
#define max(x,y) ((x) > (y)? (x) : (y))
#define min(x,y) ((x) < (y)? (x) : (y))
/*
* Order-1, 3D 25 point stencil with axis-symmetric ariable coefficients
* Adapted fr... |
OpenMPClause.h | //===- OpenMPClause.h - Classes for OpenMP clauses --------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===-------------------------------------------------------... | //===- OpenMPClause.h - Classes for OpenMP clauses --------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===-------------------------------------------------------... | //===- OpenMPClause.h - Classes for OpenMP clauses --------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===-------------------------------------------------------... |
GB_unaryop__identity_int8_int32.c | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2020, All Rights Reserved.
// http... | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2020, All Rights Reserved.
// http... | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2020, All Rights Reserved.
// http... |
omp_dr.h | /*
* OpenMP + dag_recorder
*/
/*
this file provides macros with which users can
easily turn on/off dag recorder for your OpenMP
task parallel programs.
provided macros are:
(i) pragma_omp_task(option, statement)
(ii) pragma_omp_taskc(option, callable)
(iii) pragma_omp_taskwait
they are r... | /*
* OpenMP + dag_recorder
*/
/*
* this file provides macros with which users can easily turn on/off dag
* recorder for your OpenMP task parallel programs.
*
* provided macros are:
*
* (i) pragma_omp_task(option, statement) (ii) pragma_omp_taskc(option,
* callable) (iii) pragma_omp_taskwait
*
* they are ... | /*
* OpenMP + dag_recorder
*/
/*
* this file provides macros with which users can easily turn on/off dag
* recorder for your OpenMP task parallel programs.
*
* provided macros are:
*
* (i) pragma_omp_task(option, statement) (ii) pragma_omp_taskc(option,
* callable) (iii) pragma_omp_taskwait
*
* they are ... |
statistical_analysis.c | #include<stdio.h>
#include<omp.h>
#include<math.h>
#define INT_MAX 9999999
#define INT_MIN -999999
int main() {
int n;
scanf("%d", &n);
int marks[n];
for(int i=0; i<n; i++)
{
scanf("%d", (marks+i));
}
int max = INT_MIN;
int min = INT_MAX;
int sum = 0;
#pragma omp parallel for shared(marks) reduction (+:sum... | #include<stdio.h>
#include<omp.h>
#include<math.h>
#define INT_MAX 9999999
#define INT_MIN -999999
int
main()
{
int n;
scanf("%d", &n);
int marks[n];
for (int i = 0; i < n; i++)
{
scanf("%d", (marks + i));
}
int max = INT_MIN;
int min = INT_MAX;
int sum = 0;
for (int i ... | #include<stdio.h>
#include<omp.h>
#include<math.h>
#define INT_MAX 9999999
#define INT_MIN -999999
int
main()
{
int n;
scanf("%d", &n);
int marks[n];
for (int i = 0; i < n; i++)
{
scanf("%d", (marks + i));
}
int max = INT_MIN;
int min = INT_MAX;
int sum = 0;
#pragma omp par... |
decorate.c | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% ... |
/*
* Include declarations.
*/
#include "magick/studio.h"
#include "magick/cache-view.h"
#include "magick/channel.h"
#include "magick/color-private.h"
#include "magick/colorspace-private.h"
#include "magick/composite.h"
#include "magick/decorate.h"
#include "magick/exception.h"
#include "magick/exception-private.h"... |
/*
* Include declarations.
*/
#include "magick/studio.h"
#include "magick/cache-view.h"
#include "magick/channel.h"
#include "magick/color-private.h"
#include "magick/colorspace-private.h"
#include "magick/composite.h"
#include "magick/decorate.h"
#include "magick/exception.h"
#include "magick/exception-private.h"... |
GB_unop__identity_uint64_fc64.c | //------------------------------------------------------------------------------
// GB_unop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-Li... | //------------------------------------------------------------------------------
// GB_unop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-Li... | //------------------------------------------------------------------------------
// GB_unop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-Li... |
GB_binop__times_int8.c | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... |
debug_so8_acoustic.c | #define _POSIX_C_SOURCE 200809L
#include "stdlib.h"
#include "math.h"
#include "sys/time.h"
#include "xmmintrin.h"
#include "pmmintrin.h"
#include <stdio.h>
#include "omp.h"
#define min(a, b) (((a) < (b)) ? (a) : (b))
#define max(a, b) (((a) > (b)) ? (a) : (b))
struct dataobj
{
void *restrict data;
int *size;
in... | #define _POSIX_C_SOURCE 200809L
#include "stdlib.h"
#include "math.h"
#include "sys/time.h"
#include "xmmintrin.h"
#include "pmmintrin.h"
#include <stdio.h>
#include "omp.h"
#define min(a, b) (((a) < (b)) ? (a) : (b))
#define max(a, b) (((a) > (b)) ? (a) : (b))
struct dataobj
{
void *restrict data;
int *size;
... | #define _POSIX_C_SOURCE 200809L
#include "stdlib.h"
#include "math.h"
#include "sys/time.h"
#include "xmmintrin.h"
#include "pmmintrin.h"
#include <stdio.h>
#include "omp.h"
#define min(a, b) (((a) < (b)) ? (a) : (b))
#define max(a, b) (((a) > (b)) ? (a) : (b))
struct dataobj
{
void *restrict data;
int *size;
... |
dsdd.c | /*! @copyright (c) 2017 King Abdullah University of Science and
* Technology (KAUST). All rights reserved.
*
* STARS-H is a software package, provided by King Abdullah
* University of Science and Technology (KAUST)
*
* @file src/backends/openmp/blrm/dsdd.c
* @version 1.3.0
* @au... |
#include "common.h"
#include "starsh.h"
int
starsh_blrm__dsdd_omp(STARSH_blrm ** matrix, STARSH_blrf * format,
int maxrank, double tol, int onfly)
//!Approximate each tile by divide - and - conquer SVD(GESDD function).
/*
* ! @param[out] matrix: Address of pointer to @ref STARSH_blrm object.
... |
#include "common.h"
#include "starsh.h"
int
starsh_blrm__dsdd_omp(STARSH_blrm ** matrix, STARSH_blrf * format,
int maxrank, double tol, int onfly)
//!Approximate each tile by divide - and - conquer SVD(GESDD function).
/*
* ! @param[out] matrix: Address of pointer to @ref STARSH_blrm object.
... |
Searching.202007281116.only_gather_top_m.profile.h | //
// Created by Zhen Peng on 7/28/2020.
//
#ifndef BATCH_SEARCHING_SEARCHING_H
#define BATCH_SEARCHING_SEARCHING_H
#include <vector>
#include <boost/dynamic_bitset.hpp>
//#include <boost/sort/sort.hpp>
#include <iostream>
#include <fstream>
#include <unordered_map>
#include <immintrin.h>
#include <cstring>
#include ... | //
// Created by Zhen Peng on 7/28/2020.
//
#ifndef BATCH_SEARCHING_SEARCHING_H
#define BATCH_SEARCHING_SEARCHING_H
#include <vector>
#include <boost/dynamic_bitset.hpp>
//#include <boost/sort/sort.hpp>
#include <iostream>
#include <fstream>
#include <unordered_map>
#include <immintrin.h>
#include <cstring>
#include ... | //
// Created by Zhen Peng on 7/28/2020.
//
#ifndef BATCH_SEARCHING_SEARCHING_H
#define BATCH_SEARCHING_SEARCHING_H
#include <vector>
#include <boost/dynamic_bitset.hpp>
//#include <boost/sort/sort.hpp>
#include <iostream>
#include <fstream>
#include <unordered_map>
#include <immintrin.h>
#include <cstring>
#include ... |
SSBOStreamer.h | /*
* SSBOStreamer.h
*
* Copyright (C) 2018 by VISUS (Universitaet Stuttgart)
* Alle Rechte vorbehalten.
*/
#ifndef MEGAMOLCORE_SSBOSTREAMER_H_INCLUDED
#define MEGAMOLCORE_SSBOSTREAMER_H_INCLUDED
#if (defined(_MSC_VER) && (_MSC_VER > 1000))
#pragma once
#endif /* (defined(_MSC_VER) && (_MSC_VER > 1000)) */
#include "v... |
#ifndef MEGAMOLCORE_SSBOSTREAMER_H_INCLUDED
#define MEGAMOLCORE_SSBOSTREAMER_H_INCLUDED
#if (defined(_MSC_VER) && (_MSC_VER > 1000))
#pragma once
#endif /* (defined(_MSC_VER) && (_MSC_VER > 1000)) */
#include "vislib/graphics/gl/IncludeAllGL.h"
#include "vislib/graphics/gl/GLSLShader.h"
#inc... |
#ifndef MEGAMOLCORE_SSBOSTREAMER_H_INCLUDED
#define MEGAMOLCORE_SSBOSTREAMER_H_INCLUDED
#if (defined(_MSC_VER) && (_MSC_VER > 1000))
#pragma once
#endif /* (defined(_MSC_VER) && (_MSC_VER > 1000)) */
#include "vislib/graphics/gl/IncludeAllGL.h"
#include "vislib/graphics/gl/GLSLShader.h"
#inc... |
9717.c | /* POLYBENCH/GPU-OPENMP
*
* This file is a part of the Polybench/GPU-OpenMP suite
*
* Contact:
* William Killian <killian@udel.edu>
*
* Copyright 2013, The University of Delaware
*/
#define EXTRALARGE_DATASET
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <math.h>
/* Include polybench co... |
#define EXTRALARGE_DATASET
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <math.h>
/* Include polybench common header. */
#include <polybench.h>
/* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */
#include "correlation.h"
/* Array initialization. ... |
#define EXTRALARGE_DATASET
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <math.h>
/* Include polybench common header. */
#include <polybench.h>
/* Include benchmark-specific header. */
/* Default data type is double, default size is 4000. */
#include "correlation.h"
/* Array initialization. ... |
GB_binop__rminus_int32.c | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... |
loop_multiple_variables_omp.c | #include <stdio.h>
#include <stdlib.h>
#include <omp.h>
int main()
{
int* a = (int*)malloc(sizeof(int)*4);
int* b = (int*)malloc(sizeof(int)*4);
a[0] = 0;
a[1] = 1;
a[2] = 2;
a[3] = 3;
#pragma omp parallel for
{
for(int i = 0; i < 4; i++)
{
b[i] = a[i];
... | #include <stdio.h>
#include <stdlib.h>
#include <omp.h>
int
main()
{
int *a = (int *)malloc(sizeof(int) * 4);
int *b = (int *)malloc(sizeof(int) * 4);
a[0] = 0;
a[1] = 1;
a[2] = 2;
a[3] = 3;
for (int i = 0; i < 4; i++)
{
b[i] = a[i];
}
printf("[%d,%d,%d,%d]\n", b[0],... | #include <stdio.h>
#include <stdlib.h>
#include <omp.h>
int
main()
{
int *a = (int *)malloc(sizeof(int) * 4);
int *b = (int *)malloc(sizeof(int) * 4);
a[0] = 0;
a[1] = 1;
a[2] = 2;
a[3] = 3;
#pragma omp parallel for
{
for (int i = 0; i < 4; i++)
{
b[i] = a[i];... |
cross_correlate_2d.c | // MIT License
//
// Copyright (c) 2021 Florian
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, mer... | // MIT License
//
// Copyright (c) 2021 Florian
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, mer... | // MIT License
//
// Copyright (c) 2021 Florian
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, mer... |
GB_unaryop__lnot_uint16_int8.c | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2019, All Rights Reserved.
// http... | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2019, All Rights Reserved.
// http... | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2019, All Rights Reserved.
// http... |
scratch.c | #include <omp.h>
#include <stdio.h>
#include <stdlib.h>
static void fun() {
int tid;
tid = omp_get_thread_num();
printf("Hi from thread %d\n", tid);
}
int main (int argc, char *argv[]) {
#pragma omp parallel
{
fun();
} /* All threads join master thread, barrier and disband */
retu... | #include <omp.h>
#include <stdio.h>
#include <stdlib.h>
static void
fun()
{
int tid;
tid = omp_get_thread_num();
printf("Hi from thread %d\n", tid);
}
int
main(int argc, char *argv[])
{
fun();
/* All threads join master thread, barrier and disband */
return 0;
}
| #include <omp.h>
#include <stdio.h>
#include <stdlib.h>
static void
fun()
{
int tid;
tid = omp_get_thread_num();
printf("Hi from thread %d\n", tid);
}
int
main(int argc, char *argv[])
{
#pragma omp parallel
{
fun();
} /* All threads join master thread, barri... |
Tutorial.h | //=================================================================================================
/*!
// \file blaze/Tutorial.h
// \brief Tutorial of the Blaze library
//
// Copyright (C) 2012-2018 Klaus Iglberger - All Rights Reserved
//
// This file is part of the Blaze library. You can redistribute it and/or m... | //=================================================================================================
/*
* ! // \file blaze/Tutorial.h // \brief Tutorial of the Blaze library //
* // Copyright (C) 2012-2018 Klaus Iglberger - All Rights Reserved // //
* This file is part of the Blaze library. You can redistribute it... | //=================================================================================================
/*
* ! // \file blaze/Tutorial.h // \brief Tutorial of the Blaze library //
* // Copyright (C) 2012-2018 Klaus Iglberger - All Rights Reserved // //
* This file is part of the Blaze library. You can redistribute it... |
par_csr_matvec.c | /*BHEADER**********************************************************************
* Copyright (c) 2008, Lawrence Livermore National Security, LLC.
* Produced at the Lawrence Livermore National Laboratory.
* This file is part of HYPRE. See file COPYRIGHT for details.
*
* HYPRE is free software; you can redistribute... |
/******************************************************************************
*
* Matvec functions for hypre_CSRMatrix class.
*
*****************************************************************************/
#include "_hypre_parcsr_mv.h"
#include <assert.h>
/*#ifdef HYPRE_USING_GPU
extern "C"
{
void PackOnDevic... |
/******************************************************************************
*
* Matvec functions for hypre_CSRMatrix class.
*
*****************************************************************************/
#include "_hypre_parcsr_mv.h"
#include <assert.h>
/*#ifdef HYPRE_USING_GPU
extern "C"
{
void PackOnDevic... |
irbuilder_unroll_partial_factor_for.c | // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs
// RUN: %clang_cc1 -fopenmp-enable-irbuilder -verify -fopenmp -fopenmp-version=51 -x c -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s
// expected-no-diagnostics
#ifnd... | // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs
// RUN: %clang_cc1 -fopenmp-enable-irbuilder -verify -fopenmp -fopenmp-version=51 -x c -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s
// expected-no-diagnostics
#ifnd... | // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs
// RUN: %clang_cc1 -fopenmp-enable-irbuilder -verify -fopenmp -fopenmp-version=51 -x c -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s
// expected-no-diagnostics
#ifnd... |
GB_unaryop__identity_fp32_uint16.c | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2020, All Rights Reserved.
// http... | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2020, All Rights Reserved.
// http... | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2020, All Rights Reserved.
// http... |
GB_bitmap_assign_C_template.c | //------------------------------------------------------------------------------
// GB_bitmap_assign_C_template: iterate over a bitmap matrix C
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-Licens... | //------------------------------------------------------------------------------
// GB_bitmap_assign_C_template: iterate over a bitmap matrix C
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-Licens... | //------------------------------------------------------------------------------
// GB_bitmap_assign_C_template: iterate over a bitmap matrix C
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-Licens... |
m2.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <omp.h>
typedef struct {
long long int re;
long long int im;
} com;
typedef struct {
com x;
com y;
} PO;
typedef struct
{
unsigned int p;
unsigned int e2;
unsigned int e3;
unsigned int xQ20;
unsigned int xQ21;... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <omp.h>
typedef struct {
long long int re;
long long int im;
} com;
typedef struct {
com x;
com y;
} PO;
typedef struct
{
unsigned int p;
unsigned int e2;
unsigned int e3;
unsigned int xQ20;
unsigned int xQ21;... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <omp.h>
typedef struct {
long long int re;
long long int im;
} com;
typedef struct {
com x;
com y;
} PO;
typedef struct
{
unsigned int p;
unsigned int e2;
unsigned int e3;
unsigned int xQ20;
unsigned int xQ21;... |
test.c |
#include <stdio.h>
#include <float.h>
#include <stdlib.h>
#include <math.h>
#include <omp.h>
#pragma omp requires unified_shared_memory
#include "../utilities/check.h"
#include "../utilities/utilities.h"
#define TRIALS (1)
#define N (957*3)
#define ZERO(X) ZERO_ARRAY(N, X)
#define INIT() { \
INIT_LOOP(N, { \
... |
#include <stdio.h>
#include <float.h>
#include <stdlib.h>
#include <math.h>
#include <omp.h>
#include "../utilities/check.h"
#include "../utilities/utilities.h"
#define TRIALS (1)
#define N (957*3)
#define ZERO(X) ZERO_ARRAY(N, X)
#define INIT() { \
INIT_LOOP(N, { \
Ad[i] = 1 << 16; \
Bd[i] = i << 16; \
Cd... |
#include <stdio.h>
#include <float.h>
#include <stdlib.h>
#include <math.h>
#include <omp.h>
#pragma omp requires unified_shared_memory
#include "../utilities/check.h"
#include "../utilities/utilities.h"
#define TRIALS (1)
#define N (957*3)
#define ZERO(X) ZERO_ARRAY(N, X)
#define INIT() { \
INIT_LOOP(N, { \
... |
extract_image_patches.h | /* Copyright 2018 The Blueoil Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... |
#ifndef DLK_FUNC_EXTRACT_IMAGE_PATCHES
#define DLK_FUNC_EXTRACT_IMAGE_PATCHES
#include <algorithm>
#include "global.h"
#include "tensor_view.h"
#include "time_measurement.h"
#include "pack_input_to_qwords.h"
#include <limits.h>
#ifdef USE_NEON
#include <arm_neon.h>
#endif
template < typename T >
void
func_Extract... |
#ifndef DLK_FUNC_EXTRACT_IMAGE_PATCHES
#define DLK_FUNC_EXTRACT_IMAGE_PATCHES
#include <algorithm>
#include "global.h"
#include "tensor_view.h"
#include "time_measurement.h"
#include "pack_input_to_qwords.h"
#include <limits.h>
#ifdef USE_NEON
#include <arm_neon.h>
#endif
template < typename T >
void
func_Extract... |
vectors.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "timer.h"
int g_matrix_n, g_matrix_m, g_num_threads;
typedef struct matrix_t {
int** values;
int* row_size;
} matrix_t;
void print_matrix(matrix_t*);
/* Sum each row of the provided matrix, using the row_size to determine how many items ar... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "timer.h"
int g_matrix_n, g_matrix_m, g_num_threads;
typedef struct matrix_t
{
int **values;
int *row_size;
} matrix_t;
void print_matrix(matrix_t *);
/*
* Sum each row of the provided matrix, using the row_size to determine how
* many... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "timer.h"
int g_matrix_n, g_matrix_m, g_num_threads;
typedef struct matrix_t
{
int **values;
int *row_size;
} matrix_t;
void print_matrix(matrix_t *);
/*
* Sum each row of the provided matrix, using the row_size to determine how
* many... |
merge_when_user_omp_pragma.c |
int main() {
int A[10][10];
int i,j;
// This pragma use to lead to an invalid omp code because we don't detect that an omp pragma already exist
#pragma omp parallel for
for(i=0; i<10; i++) {
for(j=0; j<10; j++) {
A[i][j] =0;
}
}
}
|
int main() {
int A[10][10];
int i,j;
// This pragma use to lead to an invalid omp code because we don't detect that an omp pragma already exist
for(i=0; i<10; i++) {
for(j=0; j<10; j++) {
A[i][j] =0;
}
}
}
|
int main() {
int A[10][10];
int i,j;
// This pragma use to lead to an invalid omp code because we don't detect that an omp pragma already exist
#pragma omp parallel for
for(i=0; i<10; i++) {
for(j=0; j<10; j++) {
A[i][j] =0;
}
}
}
|
GB_binop__rdiv_uint64.c |
//------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX... |
//------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX... |
//------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX... |
main_omp.c | //
// main_serial.cc
// Non-parallelized version of Mandelbrot set calculation
// Created by Joshua Wallace on 2/12/15.
//
#include <stdio.h>
#include <stdlib.h>
#include <complex.h>
#include <omp.h>
/*The following function computes z_{n+1} given z_n and the real and
imaginary component of c*/
double complex ne... | //
// main_serial.cc
// Non-parallelized version of Mandelbrot set calculation
// Created by Joshua Wallace on 2/12/15.
//
#include <stdio.h>
#include <stdlib.h>
#include <complex.h>
#include <omp.h>
/*The following function computes z_{n+1} given z_n and the real and
imaginary component of c*/
double complex ne... | //
// main_serial.cc
// Non-parallelized version of Mandelbrot set calculation
// Created by Joshua Wallace on 2/12/15.
//
#include <stdio.h>
#include <stdlib.h>
#include <complex.h>
#include <omp.h>
/*The following function computes z_{n+1} given z_n and the real and
imaginary component of c*/
double complex ne... |
ejercicio7.c | /*Para compilar usar (-lrt: real time library): gcc -O2 Sumavectores.c -o SumaVectores -lrt
Para ejecutar use: SumaVectores longitud
*/
#include <stdlib.h>
#include <stdio.h>
#include <omp.h>
#include <time.h>
#define PRINTF_ALL
//Sólo puede estar definida una de las tres constantes VECTOR_ (sólo uno de los ...
//tre... | /*Para compilar usar (-lrt: real time library): gcc -O2 Sumavectores.c -o SumaVectores -lrt
Para ejecutar use: SumaVectores longitud
*/
#include <stdlib.h>
#include <stdio.h>
#include <omp.h>
#include <time.h>
#define PRINTF_ALL
//Sólo puede estar definida una de las tres constantes VECTOR_ (sólo uno de los ...
//tre... | /*Para compilar usar (-lrt: real time library): gcc -O2 Sumavectores.c -o SumaVectores -lrt
Para ejecutar use: SumaVectores longitud
*/
#include <stdlib.h>
#include <stdio.h>
#include <omp.h>
#include <time.h>
#define PRINTF_ALL
//Sólo puede estar definida una de las tres constantes VECTOR_ (sólo uno de los ...
//tre... |
BaseFunc.h |
bool
IsPolarized(double &Polarization)
{
if (Polarization==-1.){return false;}
else {return true;}
}
void
PolarizationTerm(uint ThetaLength,
double * ThetaPtr,
double * CosTerm,
double * SinTerm,
bool & Polarized)
{
if (P... |
bool
IsPolarized(double &Polarization)
{
if (Polarization == -1.)
{
return false;
} else
{
return true;
}
}
void
PolarizationTerm(uint ThetaLength,
double *ThetaPtr,
double *CosTerm,
double *SinTerm,
bool & Pol... |
bool
IsPolarized(double &Polarization)
{
if (Polarization == -1.)
{
return false;
} else
{
return true;
}
}
void
PolarizationTerm(uint ThetaLength,
double *ThetaPtr,
double *CosTerm,
double *SinTerm,
bool & Pol... |
guess.c | #include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <omp.h>
#define _DISP 0
void disp(int * num1){
#ifndef _DISP
printf( "num: %d %d %d %d\n",num1[0],num1[1],num1[2],num1[3]);
#endif
}
inline void num2p(int seqn, int * nump){
//数字转为数组,并用指针传出
int i;
for(i=0; i<4; i++)
nump[i]=0;
i=3;
while(seqn){... | #include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <omp.h>
#define _DISP 0
void disp(int * num1){
#ifndef _DISP
printf( "num: %d %d %d %d\n",num1[0],num1[1],num1[2],num1[3]);
#endif
}
inline void num2p(int seqn, int * nump){
//数字转为数组,并用指针传出
int i;
for(i=0; i<4; i++)
nump[i]=0;
i=3;
while(seqn){... | #include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <omp.h>
#define _DISP 0
void disp(int * num1){
#ifndef _DISP
printf( "num: %d %d %d %d\n",num1[0],num1[1],num1[2],num1[3]);
#endif
}
inline void num2p(int seqn, int * nump){
//数字转为数组,并用指针传出
int i;
for(i=0; i<4; i++)
nump[i]=0;
i=3;
while(seqn){... |
no_loop_1.c | #include <stdio.h>
#include <omp.h>
#pragma omp declare target
int foo(int i) { return i+1; }
#pragma omp end declare target
int main()
{
int N = 100000;
int a[N];
int b[N];
int i;
for (i=0; i<N; i++)
b[i]=i;
for (i=0; i<N; i++)
a[i]=0;
int j;
#pragma omp target teams distribute parallel fo... | #include <stdio.h>
#include <omp.h>
int
foo(int i)
{
return i + 1;
}
int
main()
{
int N = 100000;
int a[N];
int b[N];
int i;
for (i = 0; i < N; i++)
b[i] = i;
for (i = 0; i < N; i++)
a[i] = 0;
int j;
for (j = 0; j < N; j++)
a[j] = b[j];
for (int k... | #include <stdio.h>
#include <omp.h>
#pragma omp declare target
int
foo(int i)
{
return i + 1;
}
#pragma omp end declare target
int
main()
{
int N = 100000;
int a[N];
int b[N];
int i;
for (i = 0; i < N; i++)
b[i] = i;
for (i = 0; i < N; i++)
a[i] = 0;
int j;
#pra... |
GB_unop__identity_uint8_int16.c | //------------------------------------------------------------------------------
// GB_unop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SPDX-Li... | //------------------------------------------------------------------------------
// GB_unop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SPDX-Li... | //------------------------------------------------------------------------------
// GB_unop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
// SPDX-Li... |
fastmarching_tree.h | //last change: by PHC, 2013-02-13. adjust memory allocation to make it more robust
/*****************************************************************
* file : fastmarching_tree.h, Hang Xiao, Jan 18, 2012
*
* fastmarching_tree
* fastmarching_tracing
*
* ***********************************************************... | // last change:by PHC, 2013 - 02 - 13. adjust memory allocation to make it more robust
/*****************************************************************
* file : fastmarching_tree.h, Hang Xiao, Jan 18, 2012
*
* fastmarching_tree
* fastmarching_tracing
*
* *******************************************************... | // last change:by PHC, 2013 - 02 - 13. adjust memory allocation to make it more robust
/*****************************************************************
* file : fastmarching_tree.h, Hang Xiao, Jan 18, 2012
*
* fastmarching_tree
* fastmarching_tracing
*
* *******************************************************... |
bspline_create.c | /////////////////////////////////////////////////////////////////////////////
// einspline: a library for creating and evaluating B-splines //
// Copyright (C) 2007 Kenneth P. Esler, Jr. //
// //
// This... | /////////////////////////////////////////////////////////////////////////////
// einspline: a library for creating and evaluating B-splines //
// Copyright (C) 2007 Kenneth P. Esler, Jr. //
// //
// This... | /////////////////////////////////////////////////////////////////////////////
// einspline: a library for creating and evaluating B-splines //
// Copyright (C) 2007 Kenneth P. Esler, Jr. //
// //
// This... |
simpar-omp.c | /**
* @file simpar.c
* @authors: Filipe Marques, Luís Fonseca
* @date 29 Abr 2019
* @brief Header Parallellized implementation of simpar.h containing the particle simulation functions's source and main.
*/
#include "simpar.h"
#include "omp.h"
cell_t ** dummy;
void usg_err()
{
printf("\t[-] usage : ./simpar ... | /**
* @file simpar.c
* @authors: Filipe Marques, Luís Fonseca
* @date 29 Abr 2019
* @brief Header Parallellized implementation of simpar.h containing the particle simulation functions's source and main.
*/
#include "simpar.h"
#include "omp.h"
cell_t **dummy;
void
usg_err()
{
printf("\t[-] usage : ./simpar ... | /**
* @file simpar.c
* @authors: Filipe Marques, Luís Fonseca
* @date 29 Abr 2019
* @brief Header Parallellized implementation of simpar.h containing the particle simulation functions's source and main.
*/
#include "simpar.h"
#include "omp.h"
cell_t **dummy;
void
usg_err()
{
printf("\t[-] usage : ./simpar ... |
CPUMatrixTensorImpl.h | // Move some files out of CPUMatrixImpl.h to prevent compiler crash on out-of-heap
#include "CPUMatrix.h"
#include "TensorOps.h"
namespace Microsoft { namespace MSR { namespace CNTK {
// =======================================================================
// TensorView support
// =================================... | // Move some files out of CPUMatrixImpl.h to prevent compiler crash on out-of-heap
#include "CPUMatrix.h"
#include "TensorOps.h"
namespace Microsoft { namespace MSR { namespace CNTK {
// =======================================================================
// TensorView support
// =================================... | // Move some files out of CPUMatrixImpl.h to prevent compiler crash on out-of-heap
#include "CPUMatrix.h"
#include "TensorOps.h"
namespace Microsoft { namespace MSR { namespace CNTK {
// =======================================================================
// TensorView support
// =================================... |
GB_binop__ldexp_fp32.c | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-... |
comm.h | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you ... |
/**
* Copyright (c) 2015 by Contributors
*/
#ifndef MXNET_KVSTORE_COMM_H_
#define MXNET_KVSTORE_COMM_H_
#include <dmlc/omp.h>
#include <string>
#include <algorithm>
#include <utility>
#include <limits>
#include <vector>
#include <tuple>
#include <thread>
#include "mxnet/ndarray.h"
#include "gradient_compression.h"
... |
/**
* Copyright (c) 2015 by Contributors
*/
#ifndef MXNET_KVSTORE_COMM_H_
#define MXNET_KVSTORE_COMM_H_
#include <dmlc/omp.h>
#include <string>
#include <algorithm>
#include <utility>
#include <limits>
#include <vector>
#include <tuple>
#include <thread>
#include "mxnet/ndarray.h"
#include "gradient_compression.h"
... |
shared-clause.c | #include <stdio.h>
#ifdef _OPENMP
#include <omp.h>
#endif
int main()
{
int i, n = 7;
int a[n];
for (i=0; i<n; i++)
a[i] = i+1;
#pragma omp parallel for shared(a) default(none)
for (i=0; i<n; i++) a[i] += i;
printf("Después de parallel for:\n");
for (i=0; i<n; i++)
printf("a[%d... | #include <stdio.h>
int
main()
{
int i, n = 7;
int a[n];
for (i = 0; i < n; i++)
a[i] = i + 1;
for (i = 0; i < n; i++)
a[i] += i;
printf("Después de parallel for:\n");
for (i = 0; i < n; i++)
printf("a[%d] = %d\n", i, a[i]);
}
| #include <stdio.h>
#ifdef _OPENMP
#include <omp.h>
#endif
int
main()
{
int i, n = 7;
int a[n];
for (i = 0; i < n; i++)
a[i] = i + 1;
#pragma omp parallel for shared(a) default(none)
for (i = 0; i < n; i++)
a[i] += i;
printf("Después de parallel for:\n");
for (i = 0; i < n; ... |
q2.c | #include <math.h>
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#include "common.h"
const i32 REPEAT_COUNT = 512;
const i32 ARRAY_SIZE = 8192;
const i32 RECURSION_SIZE_LIMIT = 32;
const i32 FILE_ARRAY_SIZE = 100000;
i32* get_random_array(i32 size) {
i32* arr = malloc(sizeof(i32) * size);
for (i32 i ... | #include <math.h>
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#include "common.h"
const i32 REPEAT_COUNT = 512;
const i32 ARRAY_SIZE = 8192;
const i32 RECURSION_SIZE_LIMIT = 32;
const i32 FILE_ARRAY_SIZE = 100000;
i32* get_random_array(i32 size) {
i32* arr = malloc(sizeof(i32) * size);
for (i32 i ... | #include <math.h>
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#include "common.h"
const i32 REPEAT_COUNT = 512;
const i32 ARRAY_SIZE = 8192;
const i32 RECURSION_SIZE_LIMIT = 32;
const i32 FILE_ARRAY_SIZE = 100000;
i32* get_random_array(i32 size) {
i32* arr = malloc(sizeof(i32) * size);
for (i32 i ... |
channel.c | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% ... |
/*
* Include declarations.
*/
#include "magick/studio.h"
#include "magick/cache-private.h"
#include "magick/channel.h"
#include "magick/color-private.h"
#include "magick/colorspace-private.h"
#include "magick/composite-private.h"
#include "magick/exception-private.h"
#include "magick/enhance.h"
#include "magick/im... |
/*
* Include declarations.
*/
#include "magick/studio.h"
#include "magick/cache-private.h"
#include "magick/channel.h"
#include "magick/color-private.h"
#include "magick/colorspace-private.h"
#include "magick/composite-private.h"
#include "magick/exception-private.h"
#include "magick/enhance.h"
#include "magick/im... |
j3d27pt.c | #define BENCH_DIM 3
#define BENCH_FPP 54
#define BENCH_RAD 1
#include "common.h"
double kernel_stencil(SB_TYPE *A1, int compsize, int timestep, bool scop)
{
double start_time = sb_time(), end_time = 0.0;
int dimsize = compsize + BENCH_RAD * 2;
SB_TYPE (*A)[dimsize][dimsize][dimsize]
= (SB_TYPE (*)[dimsize][... | #define BENCH_DIM 3
#define BENCH_FPP 54
#define BENCH_RAD 1
#include "common.h"
double
kernel_stencil(SB_TYPE * A1, int compsize, int timestep, bool scop)
{
double start_time = sb_time(), end_time = 0.0;
int dimsize = compsize + BENCH_RAD * 2;
SB_TYPE(*A)[dimsize][dimsize][dimsize]
= (SB_TYPE(*)... | #define BENCH_DIM 3
#define BENCH_FPP 54
#define BENCH_RAD 1
#include "common.h"
double
kernel_stencil(SB_TYPE * A1, int compsize, int timestep, bool scop)
{
double start_time = sb_time(), end_time = 0.0;
int dimsize = compsize + BENCH_RAD * 2;
SB_TYPE(*A)[dimsize][dimsize][dimsize]
= (SB_TYPE(*)... |
draw.c | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% ... |
/*
* Include declarations.
*/
#include "MagickCore/studio.h"
#include "MagickCore/annotate.h"
#include "MagickCore/artifact.h"
#include "MagickCore/blob.h"
#include "MagickCore/cache.h"
#include "MagickCore/cache-private.h"
#include "MagickCore/cache-view.h"
#include "MagickCore/channel.h"
#include "MagickCore/col... |
/*
* Include declarations.
*/
#include "MagickCore/studio.h"
#include "MagickCore/annotate.h"
#include "MagickCore/artifact.h"
#include "MagickCore/blob.h"
#include "MagickCore/cache.h"
#include "MagickCore/cache-private.h"
#include "MagickCore/cache-view.h"
#include "MagickCore/channel.h"
#include "MagickCore/col... |
openmp_utils.h | // | / |
// ' / __| _` | __| _ \ __|
// . \ | ( | | ( |\__ \.
// _|\_\_| \__,_|\__|\___/ ____/
// Multi-Physics
//
// License: BSD License
// Kratos default license: kratos/license.txt
//
// Main authors: Riccardo Rossi
//
#ifndef KRATOS_OPENMP_UTILS_H... | // | / |
// ' / __| _` | __| _ \ __|
// . \ | ( | | ( |\__ \.
// _|\_\_| \__,_|\__|\___/ ____/
// Multi-Physics
//
// License: BSD License
// Kratos default license: kratos/license.txt
//
// Main authors: Riccardo Rossi
//
#ifndef KRATOS_OPENMP_UTILS_H... | // | / |
// ' / __| _` | __| _ \ __|
// . \ | ( | | ( |\__ \.
// _|\_\_| \__,_|\__|\___/ ____/
// Multi-Physics
//
// License: BSD License
// Kratos default license: kratos/license.txt
//
// Main authors: Riccardo Rossi
//
#ifndef KRATOS_OPENMP_UTILS_H... |
residualbased_predictorcorrector_velocity_bossak_scheme_turbulent.h | // | / |
// ' / __| _` | __| _ \ __|
// . \ | ( | | ( |\__ `
// _|\_\_| \__,_|\__|\___/ ____/
// Multi-Physics
//
// License: BSD License
// Kratos default license: kratos/license.txt
//
// Main authors: Jordi Cotela
//
#if !defined... | // | / |
// ' / __| _` | __| _ \ __|
// . \ | ( | | ( |\__ `
// _|\_\_| \__,_|\__|\___/ ____/
// Multi-Physics
//
// License: BSD License
// Kratos default license: kratos/license.txt
//
// Main authors: Jordi Cotela
//
#if !defined... | // | / |
// ' / __| _` | __| _ \ __|
// . \ | ( | | ( |\__ `
// _|\_\_| \__,_|\__|\___/ ____/
// Multi-Physics
//
// License: BSD License
// Kratos default license: kratos/license.txt
//
// Main authors: Jordi Cotela
//
#if !defined... |
46a_so12_itt.c | #define _POSIX_C_SOURCE 200809L
#include "stdlib.h"
#include "math.h"
#include "sys/time.h"
#include "ittnotify.h"
#include "xmmintrin.h"
#include "pmmintrin.h"
#include <stdio.h>
#include "omp.h"
#define min(a, b) (((a) < (b)) ? (a) : (b))
#define max(a, b) (((a) > (b)) ? (a) : (b))
struct dataobj
{
void *restrict ... | #define _POSIX_C_SOURCE 200809L
#include "stdlib.h"
#include "math.h"
#include "sys/time.h"
#include "ittnotify.h"
#include "xmmintrin.h"
#include "pmmintrin.h"
#include <stdio.h>
#include "omp.h"
#define min(a, b) (((a) < (b)) ? (a) : (b))
#define max(a, b) (((a) > (b)) ? (a) : (b))
struct dataobj
{
void *restric... | #define _POSIX_C_SOURCE 200809L
#include "stdlib.h"
#include "math.h"
#include "sys/time.h"
#include "ittnotify.h"
#include "xmmintrin.h"
#include "pmmintrin.h"
#include <stdio.h>
#include "omp.h"
#define min(a, b) (((a) < (b)) ? (a) : (b))
#define max(a, b) (((a) > (b)) ? (a) : (b))
struct dataobj
{
void *restric... |
streamingbc.c | #include <omp.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include <unistd.h>
#include "stinger.h"
#include "streamingbc.h"
#include "streamingbc_aux.h"
#include "timer.h"
bcForest * streamingBCCreateForestExact(int64_t NV)
{
return Creat... | #include <omp.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include <unistd.h>
#include "stinger.h"
#include "streamingbc.h"
#include "streamingbc_aux.h"
#include "timer.h"
bcForest *
streamingBCCreateForestExact(int64_t NV)
{
return Creat... | #include <omp.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include <unistd.h>
#include "stinger.h"
#include "streamingbc.h"
#include "streamingbc_aux.h"
#include "timer.h"
bcForest *
streamingBCCreateForestExact(int64_t NV)
{
return Creat... |
GB_binop__isne_uint32.c | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2020, All Rights Reserved.
// http:... | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2020, All Rights Reserved.
// http:... | //------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2020, All Rights Reserved.
// http:... |
core_cgeqrt.c | /**
*
* @file
*
* PLASMA is a software package provided by:
* University of Tennessee, US,
* University of Manchester, UK.
*
* @generated from /home/luszczek/workspace/plasma/bitbucket/plasma/core_blas/core_zgeqrt.c, normal z -> c, Fri Sep 28 17:38:20 2018
*
**/
#include <plasma_core_blas.h>
#include "pla... | /**
*
* @file
*
* PLASMA is a software package provided by:
* University of Tennessee, US,
* University of Manchester, UK.
*
* @generated from /home/luszczek/workspace/plasma/bitbucket/plasma/core_blas/core_zgeqrt.c, normal z -> c, Fri Sep 28 17:38:20 2018
*
**/
#include <plasma_core_blas.h>
#include "pla... | /**
*
* @file
*
* PLASMA is a software package provided by:
* University of Tennessee, US,
* University of Manchester, UK.
*
* @generated from /home/luszczek/workspace/plasma/bitbucket/plasma/core_blas/core_zgeqrt.c, normal z -> c, Fri Sep 28 17:38:20 2018
*
**/
#include <plasma_core_blas.h>
#include "pla... |
GB_unaryop__minv_uint16_int32.c | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2019, All Rights Reserved.
// http... | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2019, All Rights Reserved.
// http... | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2019, All Rights Reserved.
// http... |
krb5pa-sha1_fmt_plug.c | /*
* Kerberos 5 "PA ENC TIMESTAMP" by magnum (modified by Dhiru)
*
* Pcap file -> input file:
* 1. tshark -r capture.pcapng -T pdml > ~/capture.pdml
* 2. krbng2john.py ~/capture.pdml > krb5.in
* 3. Run john on krb5.in
*
* http://www.ietf.org/rfc/rfc4757.txt
* http://www.securiteam.com/windowsntfocus/5BP0H0A6K... |
#if FMT_EXTERNS_H
extern struct fmt_main fmt_krb5pa;
#elif FMT_REGISTERS_H
john_register_one(&fmt_krb5pa);
#else
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include "arch.h"
#include "misc.h"
#include "formats.h"
#include "options.h"
#include "common.h"
#include "unicode.h"
#includ... |
#if FMT_EXTERNS_H
extern struct fmt_main fmt_krb5pa;
#elif FMT_REGISTERS_H
john_register_one(&fmt_krb5pa);
#else
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#ifdef _OPENMP
static int omp_t = 1;
#include <omp.h>
#ifndef OMP_SCALE
#define OMP_SCALE 64
#endif
#endif
#incl... |
3d7pt.c | /*
* Order-1, 3D 7 point stencil
* Adapted from PLUTO and Pochoir test bench
*
* Tareq Malas
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#ifdef LIKWID_PERFMON
#include <likwid.h>
#endif
#include "print_utils.h"
#define TESTS 2
#define MAX(a,b) ((a) > (b) ? a : b)
#define MIN(a,b) ((a) < (b) ... | /*
* Order-1, 3D 7 point stencil
* Adapted from PLUTO and Pochoir test bench
*
* Tareq Malas
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#ifdef LIKWID_PERFMON
#include <likwid.h>
#endif
#include "print_utils.h"
#define TESTS 2
#define MAX(a,b) ((a) > (b) ? a : b)
#define MIN(a,b) ((a) < (b) ... | /*
* Order-1, 3D 7 point stencil
* Adapted from PLUTO and Pochoir test bench
*
* Tareq Malas
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#ifdef LIKWID_PERFMON
#include <likwid.h>
#endif
#include "print_utils.h"
#define TESTS 2
#define MAX(a,b) ((a) > (b) ? a : b)
#define MIN(a,b) ((a) < (b) ... |
DenseMatrix.h | /*
* DenseMatrix.h
*
* Created on: Nov 25, 2015
* Author: Michael Wegner (michael.wegner@student.kit.edu)
*/
#ifndef NETWORKIT_CPP_ALGEBRAIC_DENSEMATRIX_H_
#define NETWORKIT_CPP_ALGEBRAIC_DENSEMATRIX_H_
#include "../Globals.h"
#include "Vector.h"
#include <cassert>
#include <vector>
namespace NetworKit {... | /*
* DenseMatrix.h
*
* Created on: Nov 25, 2015 Author: Michael Wegner
* (michael.wegner@student.kit.edu)
*/
#ifndef NETWORKIT_CPP_ALGEBRAIC_DENSEMATRIX_H_
#define NETWORKIT_CPP_ALGEBRAIC_DENSEMATRIX_H_
#include "../Globals.h"
#include "Vector.h"
#include <cassert>
#include <vector>
namespace NetworKit
{
... | /*
* DenseMatrix.h
*
* Created on: Nov 25, 2015 Author: Michael Wegner
* (michael.wegner@student.kit.edu)
*/
#ifndef NETWORKIT_CPP_ALGEBRAIC_DENSEMATRIX_H_
#define NETWORKIT_CPP_ALGEBRAIC_DENSEMATRIX_H_
#include "../Globals.h"
#include "Vector.h"
#include <cassert>
#include <vector>
namespace NetworKit
{
... |
comms.h | /*
//@HEADER
// *****************************************************************************
//
// HPCGraph: Graph Computation on High Performance Computing Systems
// Copyright (2016) Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government r... |
#ifndef _COMMS_H_
#define _COMMS_H_
#include <mpi.h>
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <assert.h>
#include "dist_graph.h"
#include "util.h"
extern int procid, nprocs;
extern bool verbose, debug, debug2, verify, output;
#define MAX_SEND_SIZE 268435456
#define THRE... |
#ifndef _COMMS_H_
#define _COMMS_H_
#include <mpi.h>
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <assert.h>
#include "dist_graph.h"
#include "util.h"
extern int procid, nprocs;
extern bool verbose, debug, debug2, verify, output;
#define MAX_SEND_SIZE 268435456
#define THRE... |
Merge.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define SWAP(a,b) {tt=(a); (a)=(b); (b)=tt;}
void Merge(int *a1,int n1, int *a2,int n2, int *r)
{
int i1,i2,i;
for (i1=0, i2=0, i=0;i1<n1&&i2<n2;)
if (a1[i1]<a2[i2])r[i++]=a1[i1++];
else r[i++]=a2[i2++];
while(i1<n1) r[i++]=a1[i1++];
w... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define SWAP(a,b) {tt=(a); (a)=(b); (b)=tt;}
void
Merge(int *a1, int n1, int *a2, int n2, int *r)
{
int i1, i2, i;
for (i1 = 0, i2 = 0, i = 0; i1 < n1 && i2 < n2;)
if (a1[i1] < a2[i2])
r[i++] = a1[i1++];
e... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define SWAP(a,b) {tt=(a); (a)=(b); (b)=tt;}
void
Merge(int *a1, int n1, int *a2, int n2, int *r)
{
int i1, i2, i;
for (i1 = 0, i2 = 0, i = 0; i1 < n1 && i2 < n2;)
if (a1[i1] < a2[i2])
r[i++] = a1[i1++];
e... |
3d7pt.lbpar.c | #include <omp.h>
#include <math.h>
#define ceild(n,d) ceil(((double)(n))/((double)(d)))
#define floord(n,d) floor(((double)(n))/((double)(d)))
#define max(x,y) ((x) > (y)? (x) : (y))
#define min(x,y) ((x) < (y)? (x) : (y))
/*
* Order-1, 3D 7 point stencil
* Adapted from PLUTO and Pochoir test bench
*
* Tare... | #include <omp.h>
#include <math.h>
#define ceild(n,d) ceil(((double)(n))/((double)(d)))
#define floord(n,d) floor(((double)(n))/((double)(d)))
#define max(x,y) ((x) > (y)? (x) : (y))
#define min(x,y) ((x) < (y)? (x) : (y))
/*
* Order-1, 3D 7 point stencil
* Adapted from PLUTO and Pochoir test bench
*
* Tare... | #include <omp.h>
#include <math.h>
#define ceild(n,d) ceil(((double)(n))/((double)(d)))
#define floord(n,d) floor(((double)(n))/((double)(d)))
#define max(x,y) ((x) > (y)? (x) : (y))
#define min(x,y) ((x) < (y)? (x) : (y))
/*
* Order-1, 3D 7 point stencil
* Adapted from PLUTO and Pochoir test bench
*
* Tare... |
struct_innerprod.c | /*BHEADER**********************************************************************
* Copyright (c) 2008, Lawrence Livermore National Security, LLC.
* Produced at the Lawrence Livermore National Laboratory.
* This file is part of HYPRE. See file COPYRIGHT for details.
*
* HYPRE is free software; you can redistribute... |
/******************************************************************************
*
* Structured inner product routine
*
*****************************************************************************/
#include "_hypre_struct_mv.h"
/*--------------------------------------------------------------------------
* hypr... |
/******************************************************************************
*
* Structured inner product routine
*
*****************************************************************************/
#include "_hypre_struct_mv.h"
/*--------------------------------------------------------------------------
* hypr... |
irbuilder_unroll_partial_factor_for.c | // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs
// RUN: %clang_cc1 -fopenmp-enable-irbuilder -verify -fopenmp -fopenmp-version=51 -x c -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s
// expected-no-diagnostics
#ifnd... | // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs
// RUN: %clang_cc1 -fopenmp-enable-irbuilder -verify -fopenmp -fopenmp-version=51 -x c -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s
// expected-no-diagnostics
#ifnd... | // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature --include-generated-funcs
// RUN: %clang_cc1 -fopenmp-enable-irbuilder -verify -fopenmp -fopenmp-version=51 -x c -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s
// expected-no-diagnostics
#ifnd... |
hermv_c_coo_u_lo.c | #include <string.h>
#include "alphasparse/opt.h"
#ifdef _OPENMP
#include <omp.h>
#endif
#include "alphasparse/kernel.h"
#include "alphasparse/util.h"
#include <stdio.h>
alphasparse_status_t
ONAME(const ALPHA_Number alpha,
const ALPHA_SPMAT_COO *A,
const ALPHA_Number *x,
const ALPHA_Number beta,
ALPHA_Nu... | #include <string.h>
#include "alphasparse/opt.h"
#include "alphasparse/kernel.h"
#include "alphasparse/util.h"
#include <stdio.h>
alphasparse_status_t
ONAME(const ALPHA_Number alpha,
const ALPHA_SPMAT_COO *A,
const ALPHA_Number *x,
const ALPHA_Number beta,
ALPHA_Number *y)
{
const ALPHA_INT m = A->rows;... | #include <string.h>
#include "alphasparse/opt.h"
#ifdef _OPENMP
#include <omp.h>
#endif
#include "alphasparse/kernel.h"
#include "alphasparse/util.h"
#include <stdio.h>
alphasparse_status_t
ONAME(const ALPHA_Number alpha,
const ALPHA_SPMAT_COO *A,
const ALPHA_Number *x,
const ALPHA_Number beta,
ALPHA_Nu... |
Example_simple_lock.1.c | /*
* @@name: simple_lock.1c
* @@type: C
* @@compilable: yes
* @@linkable: yes
* @@expect: success
*/
#include <stdio.h>
#include <omp.h>
void skip(int i) {}
void work(int i) {}
int main()
{
omp_lock_t lck;
int id;
omp_init_lock(&lck);
#pragma omp parallel shared(lck) private(id)
{
id = omp_get_thread_num... | /*
* @@name: simple_lock.1c @@type: C @@compilable: yes @@linkable: yes
* @@expect: success
*/
#include <stdio.h>
#include <omp.h>
void
skip(int i)
{
}
void
work(int i)
{
}
int
main()
{
omp_lock_t lck;
int id;
omp_init_lock(&lck);
id = omp_get_thread_num();
omp_set_lock(&lck);
/* only one... | /*
* @@name: simple_lock.1c @@type: C @@compilable: yes @@linkable: yes
* @@expect: success
*/
#include <stdio.h>
#include <omp.h>
void
skip(int i)
{
}
void
work(int i)
{
}
int
main()
{
omp_lock_t lck;
int id;
omp_init_lock(&lck);
#pragma omp parallel shared(lck) private(id)
{
id = omp_ge... |
pi-omp1.c | /*
* BSD 2-Clause License
*
* Copyright (c) 2020, Alessandro Capotondi
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyri... |
/**
* @file exercise7.c
* @author Alessandro Capotondi
* @date 27 Mar 2020
* @brief Exercise 8
*
* Pi calculation
* @see https://dolly.fim.unimore.it/2019/course/view.php?id=152
*/
#include <stdio.h>
#include <omp.h>
#include "utils.h"
/**
* @brief EX 8- Pi Calculation
*
* This program computes pi as
*... |
/**
* @file exercise7.c
* @author Alessandro Capotondi
* @date 27 Mar 2020
* @brief Exercise 8
*
* Pi calculation
* @see https://dolly.fim.unimore.it/2019/course/view.php?id=152
*/
#include <stdio.h>
#include <omp.h>
#include "utils.h"
/**
* @brief EX 8- Pi Calculation
*
* This program computes pi as
*... |
GB_binop__lt_uint16.c |
//------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX... |
//------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX... |
//------------------------------------------------------------------------------
// GB_binop: hard-coded functions for each built-in binary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX... |
hybrid-hello.c | #include <stdio.h>
#include <mpi.h>
#include <omp.h>
int main(int argc, char *argv[])
{
int my_id, omp_rank;
int provided, required=MPI_THREAD_FUNNELED;
MPI_Init_thread(&argc, &argv, required, &provided);
MPI_Comm_rank(MPI_COMM_WORLD, &my_id);
#pragma omp parallel private(omp_rank)
{
omp_... | #include <stdio.h>
#include <mpi.h>
#include <omp.h>
int
main(int argc, char *argv[])
{
int my_id, omp_rank;
int provided, required = MPI_THREAD_FUNNELED;
MPI_Init_thread(&argc, &argv, required, &provided);
MPI_Comm_rank(MPI_COMM_WORLD, &my_id);
omp_rank = omp_get_thread_num();
printf("I'm th... | #include <stdio.h>
#include <mpi.h>
#include <omp.h>
int
main(int argc, char *argv[])
{
int my_id, omp_rank;
int provided, required = MPI_THREAD_FUNNELED;
MPI_Init_thread(&argc, &argv, required, &provided);
MPI_Comm_rank(MPI_COMM_WORLD, &my_id);
#pragma omp parallel private(omp_rank)
{
o... |
stream.c | /*-----------------------------------------------------------------------*/
/* Program: Stream */
/* Revision: $Id: stream.c,v 5.9 2009/04/11 16:35:00 mccalpin Exp $ */
/* Original code developed by John D. McCalpin */
/* Programmers: John ... |
/*-----------------------------------------------------------------------*/
/* License: */
/* 1. You are free to use this program and/or to redistribute */
/* this program. */
/* 2. You are free t... |
/*-----------------------------------------------------------------------*/
/* License: */
/* 1. You are free to use this program and/or to redistribute */
/* this program. */
/* 2. You are free t... |
ft.c | /*--------------------------------------------------------------------
NAS Parallel Benchmarks 2.3 OpenMP C versions - FT
This benchmark is an OpenMP C version of the NPB FT code.
The OpenMP C versions are developed by RWCP and derived from the serial
Fortran versions in "NPB 2.3-serial" developed by NAS.
... | /*--------------------------------------------------------------------
NAS Parallel Benchmarks 2.3 OpenMP C versions - FT
This benchmark is an OpenMP C version of the NPB FT code.
The OpenMP C versions are developed by RWCP and derived from the serial
Fortran versions in "NPB 2.3-serial" developed by NAS.
... | /*--------------------------------------------------------------------
NAS Parallel Benchmarks 2.3 OpenMP C versions - FT
This benchmark is an OpenMP C version of the NPB FT code.
The OpenMP C versions are developed by RWCP and derived from the serial
Fortran versions in "NPB 2.3-serial" developed by NAS.
... |
pwsafe_fmt_plug.c | /* Password Safe and Password Gorilla cracker patch for JtR. Hacked together
* during May of 2012 by Dhiru Kholia <dhiru.kholia at gmail.com>.
*
* Optimization patch during January of 2013 by Brian Wallace <brian.wallace9809 at gmail.com>.
*
* This software is Copyright (c) 2012-2013
* Dhiru Kholia <dhiru.kholia ... |
#if FMT_EXTERNS_H
extern struct fmt_main fmt_pwsafe;
#elif FMT_REGISTERS_H
john_register_one(&fmt_pwsafe);
#else
#include <string.h>
#include <assert.h>
#include <errno.h>
#include "arch.h"
//
#undef SIMD_COEF_32
#include "sha2.h"
#include "misc.h"
#include "common.h"
#include "formats.h"
#include "params.h"
#i... |
#if FMT_EXTERNS_H
extern struct fmt_main fmt_pwsafe;
#elif FMT_REGISTERS_H
john_register_one(&fmt_pwsafe);
#else
#include <string.h>
#include <assert.h>
#include <errno.h>
#include "arch.h"
//
#undef SIMD_COEF_32
#include "sha2.h"
#include "misc.h"
#include "common.h"
#include "formats.h"
#include "params.h"
#i... |
calcium_sparks_old.c | #include <math.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include "mpi.h"
#include "hdf5.h"
#include <sys/stat.h>
//#define DEBUG_TEST
#define DB_PF 0
#define MAX_LINE_LENGTH 80
//#define __PAPI__
#ifdef __PAPI__
#include <papi.h>
#endif
typedef int(*COND... | #include <math.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include "mpi.h"
#include "hdf5.h"
#include <sys/stat.h>
//#define DEBUG_TEST
#define DB_PF 0
#define MAX_LINE_LENGTH 80
//#define __PAPI__
#ifdef __PAPI__
#include <papi.h>
#endif
typedef int(*COND... | #include <math.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include "mpi.h"
#include "hdf5.h"
#include <sys/stat.h>
//#define DEBUG_TEST
#define DB_PF 0
#define MAX_LINE_LENGTH 80
//#define __PAPI__
#ifdef __PAPI__
#include <papi.h>
#endif
typedef int(*COND... |
serial_teams.c | // RUN: %libomp-compile-and-run | %sort-threads | FileCheck %s
// REQUIRES: ompt
// UNSUPPORTED: gcc
#include "callback.h"
int main() {
#pragma omp target teams num_teams(2) thread_limit(1)
#pragma omp parallel num_threads(1)
{ printf("In teams parallel\n"); }
return 0;
}
// CHECK: 0: NULL_POINTER=[[NULL:.*$]]
/... | // RUN:%libomp - compile - and - run | %sort - threads | FileCheck % s
// REQUIRES:ompt
// UNSUPPORTED:gcc
#include "callback.h"
int main()
{
printf("In teams parallel\n");
return 0;
}
//CHECK: 0: NULL_POINTER =[[NULL:.* $]]
// CHECK - NOT: 0:parallel_data initially not null
// CHECK - NOT: 0:task_data initi... | // RUN:%libomp - compile - and - run | %sort - threads | FileCheck % s
// REQUIRES:ompt
// UNSUPPORTED:gcc
#include "callback.h"
int
main()
{
#pragma omp target teams num_teams(2) thread_limit(1)
#pragma omp parallel num_threads(1)
{
printf("In teams parallel\n");
}
return 0;
}
//CHECK: 0: NULL_P... |
Sema.h | //===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===//
//
// 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
//
//===---------------------------... | //===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===//
//
// 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
//
//===---------------------------... | //===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===//
//
// 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
//
//===---------------------------... |
GB_unop__ainv_uint64_uint64.c | //------------------------------------------------------------------------------
// GB_unop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-Li... | //------------------------------------------------------------------------------
// GB_unop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-Li... | //------------------------------------------------------------------------------
// GB_unop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
// SPDX-Li... |
macro-2.c | // { dg-do compile }
#define p parallel
#define s(x) shared(x##1, x##2)
#define d(x) default(x)
void bar(int, int, int, int);
void foo(void)
{
int a1, a2, b1, b2;
#pragma omp p s(a) s(b) d(none)
bar(a1, a2, b1, b2);
}
| // { dg-do compile }
#define p parallel
#define s(x) shared(x##1, x##2)
#define d(x) default(x)
void bar(int, int, int, int);
void foo(void)
{
int a1, a2, b1, b2;
bar(a1, a2, b1, b2);
}
| // { dg-do compile }
#define p parallel
#define s(x) shared(x##1, x##2)
#define d(x) default(x)
void bar(int, int, int, int);
void foo(void)
{
int a1, a2, b1, b2;
#pragma omp p s(a) s(b) d(none)
bar(a1, a2, b1, b2);
}
|
ccl_utils.c | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <gsl/gsl_errno.h>
#include "ccl.h"
/* ------- ROUTINE: ccl_linear spacing ------
INPUTS: [xmin,xmax] of the interval to be divided in N bins
OUTPUT: bin edges in range [xmin,xmax]
*/
double * ccl_linear_spacing(double xmin, double xmax, int N)
{
do... | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <gsl/gsl_errno.h>
#include "ccl.h"
/* ------- ROUTINE: ccl_linear spacing ------
INPUTS: [xmin,xmax] of the interval to be divided in N bins
OUTPUT: bin edges in range [xmin,xmax]
*/
double * ccl_linear_spacing(double xmin, double xmax, int N)
{
do... | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <gsl/gsl_errno.h>
#include "ccl.h"
/* ------- ROUTINE: ccl_linear spacing ------
INPUTS: [xmin,xmax] of the interval to be divided in N bins
OUTPUT: bin edges in range [xmin,xmax]
*/
double * ccl_linear_spacing(double xmin, double xmax, int N)
{
do... |
generator.h | // Copyright (c) 2015, The Regents of the University of California (Regents)
// See LICENSE.txt for license details
#ifndef GENERATOR_H_
#define GENERATOR_H_
#include <algorithm>
#include <cinttypes>
#include <random>
#include "graph.h"
#include "pvector.h"
#include "util.h"
/*
GAP Benchmark Suite
Class: Generato... | // Copyright(c) 2015, The Regents of the University of California(Regents)
// See LICENSE.txt for license
details
#ifndef GENERATOR_H_
#define GENERATOR_H_
#include <algorithm>
#include <cinttypes>
#include <random>
#include "graph.h"
#include "pvector.h"
#include "util.h"
/*
* GAP Benchmark Suite Cla... | // Copyright(c) 2015, The Regents of the University of California(Regents)
// See LICENSE.txt for license
details
#ifndef GENERATOR_H_
#define GENERATOR_H_
#include <algorithm>
#include <cinttypes>
#include <random>
#include "graph.h"
#include "pvector.h"
#include "util.h"
/*
* GAP Benchmark Suite Cla... |
thread_scale.c | /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
/*
* See COPYRIGHT in top-level directory.
*/
#define _GNU_SOURCE
#include <stdio.h>
#include <omp.h>
#include <sched.h>
#include <unistd.h>
#include <pthread.h>
#include "zmtest_abslock.h"
#define TEST_NITER (1<<22)
#define WARMUP_ITER 128
#define CA... |
#define _GNU_SOURCE
#include <stdio.h>
#include <omp.h>
#include <sched.h>
#include <unistd.h>
#include <pthread.h>
#include "zmtest_abslock.h"
#define TEST_NITER (1<<22)
#define WARMUP_ITER 128
#define CACHELINE_SZ 64
#define ARRAY_LEN 10
char cache_lines[CACHELINE_SZ * ARRAY_LEN] = {0};
#if ARRAY_LEN == 10
int i... |
#define _GNU_SOURCE
#include <stdio.h>
#include <omp.h>
#include <sched.h>
#include <unistd.h>
#include <pthread.h>
#include "zmtest_abslock.h"
#define TEST_NITER (1<<22)
#define WARMUP_ITER 128
#define CACHELINE_SZ 64
#define ARRAY_LEN 10
char cache_lines[CACHELINE_SZ * ARRAY_LEN] = {0};
#if ARRAY_LEN == 10
int i... |
wgs64.c | #include <stdio.h>
#include <omp.h>
int n =64;
int main(void) {
int fail = 0;
int a = -1;
//
#if 1
#pragma omp target
{ //nothing
}
#endif
#pragma omp target teams distribute thread_limit(64)
for (int k =0; k < n; k++)
{
// nothing
}
printf("Succeeded\n");
return fail;
}
| #include <stdio.h>
#include <omp.h>
int n = 64;
int
main(void)
{
int fail = 0;
int a = -1;
//
#if 1 //nothing
#endif
for (int k = 0; k < n; k++)
{
//nothing
}
printf("Succeeded\n");
return fail;
}
| #include <stdio.h>
#include <omp.h>
int n = 64;
int
main(void)
{
int fail = 0;
int a = -1;
//
#if 1
#pragma omp target
{
//nothing
}
#endif
#pragma omp target teams distribute thread_limit(64)
for (int k = 0; k < n; k++)
{
//nothing
}
printf("Succeeded\n");
... |
ellipticBuildJacobi.c | /*
The MIT License (MIT)
Copyright (c) 2017 Tim Warburton, Noel Chalmers, Jesse Chan, Ali Karakus
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitatio... |
#include "elliptic.h"
void BuildLocalIpdgBBDiagTri2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A);
void BuildLocalIpdgDiagTri2D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A);
void BuildLocalIpdgDiagQuad2D(elliptic_t* elliptic, mesh_t *mesh... |
#include "elliptic.h"
void BuildLocalIpdgBBDiagTri2D(elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A);
void BuildLocalIpdgDiagTri2D (elliptic_t* elliptic, mesh_t *mesh, dfloat lambda, dfloat *MS, dlong eM, dfloat *A);
void BuildLocalIpdgDiagQuad2D(elliptic_t* elliptic, mesh_t *mesh... |
integral_omp_sync.c | // Author: Fabio Rodrigues Pereira
// E-mail: fabior@uio.no
// compiling & running
// clang -Xpreprocessor -fopenmp integral_omp_sync.c -lomp
// ./a.out
// SPMD technique *video9
#include <stdlib.h> // rand, malloc, calloc and free.
#include <stdio.h> // printf
#include <math.h>
#include <time.h>
#include <omp.h>
... | // Author: Fabio Rodrigues Pereira
// E-mail: fabior@uio.no
// compiling & running
// clang -Xpreprocessor -fopenmp integral_omp_sync.c -lomp
// ./a.out
// SPMD technique *video9
#include <stdlib.h> // rand, malloc, calloc and free.
#include <stdio.h> // printf
#include <math.h>
#include <time.h>
#include <omp.h>
... | // Author: Fabio Rodrigues Pereira
// E-mail: fabior@uio.no
// compiling & running
// clang -Xpreprocessor -fopenmp integral_omp_sync.c -lomp
// ./a.out
// SPMD technique *video9
#include <stdlib.h> // rand, malloc, calloc and free.
#include <stdio.h> // printf
#include <math.h>
#include <time.h>
#include <omp.h>
... |
GB_unaryop__abs_int64_uint64.c | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2019, All Rights Reserved.
// http... | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2019, All Rights Reserved.
// http... | //------------------------------------------------------------------------------
// GB_unaryop: hard-coded functions for each built-in unary operator
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2019, All Rights Reserved.
// http... |
linear.c | //IN method.
//Linear transformation (weights only, no biases) of Ni inputs to No outputs.
//Input X has Ni neurons and output Y has No neurons.
//The vecs of length Ni are always contiguous in memory, such that:
//If col-major: Y[:,l] = W' * X[:,l]
//where:
//X has size Ni x L
//Y has size No x L
//W has size Ni x ... | //IN method.
//Linear transformation (weights only, no biases) of Ni inputs to No outputs.
//Input X has Ni neurons and output Y has No neurons.
//The vecs of length Ni are always contiguous in memory, such that:
//If col-major: Y[:,l] = W' * X[:,l]
//where:
//X has size Ni x L
//Y has size No x L
//W has size Ni x ... | //IN method.
//Linear transformation (weights only, no biases) of Ni inputs to No outputs.
//Input X has Ni neurons and output Y has No neurons.
//The vecs of length Ni are always contiguous in memory, such that:
//If col-major: Y[:,l] = W' * X[:,l]
//where:
//X has size Ni x L
//Y has size No x L
//W has size Ni x ... |
raytracer.h | #pragma once
#include "resource.h"
#include <linalg.h>
#include <memory>
#include <omp.h>
#include <random>
#include <time.h>
using namespace linalg::aliases;
namespace cg::renderer
{
struct ray
{
ray(float3 position, float3 direction) : position(position)
{
this->direction = normalize(direction);
}
float3 po... | #pragma once
#include "resource.h"
#include <linalg.h>
#include <memory>
#include <omp.h>
#include <random>
#include <time.h>
using namespace linalg::aliases;
namespace cg::renderer
{
struct ray
{
ray(float3 position, float3 direction):position(position)
{
this->direction = norma... | #pragma once
#include "resource.h"
#include <linalg.h>
#include <memory>
#include <omp.h>
#include <random>
#include <time.h>
using namespace linalg::aliases;
namespace cg::renderer
{
struct ray
{
ray(float3 position, float3 direction):position(position)
{
this->direction = norma... |
matrix.c | /*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% ... |
/*
* Include declarations.
*/
#include "MagickCore/studio.h"
#include "MagickCore/blob.h"
#include "MagickCore/blob-private.h"
#include "MagickCore/cache.h"
#include "MagickCore/exception.h"
#include "MagickCore/exception-private.h"
#include "MagickCore/image-private.h"
#include "MagickCore/matrix.h"
#include "Mag... |
/*
* Include declarations.
*/
#include "MagickCore/studio.h"
#include "MagickCore/blob.h"
#include "MagickCore/blob-private.h"
#include "MagickCore/cache.h"
#include "MagickCore/exception.h"
#include "MagickCore/exception-private.h"
#include "MagickCore/image-private.h"
#include "MagickCore/matrix.h"
#include "Mag... |
generator_spgemm_csr_asparse.c | /******************************************************************************
** Copyright (c) 2015-2019, Intel Corporation **
** All rights reserved. **
** **
... |
/* Alexander Heinecke (Intel Corp.)
******************************************************************************/
#include "generator_spgemm_csr_asparse.h"
#include "generator_common.h"
#include "libxsmm_main.h"
#if defined(LIBXSMM_OFFLOAD_TARGET)
# pragma offload_attribute(push,target(LIBXSMM_OFFLOAD_TARGET))
#end... |
/*
* Alexander Heinecke (Intel Corp.) ****************************************************************************
*/
#include "generator_spgemm_csr_asparse.h"
#include "generator_common.h"
#include "libxsmm_main.h"
#if defined(LIBXSMM_OFFLOAD_TARGET)
#pragma offload_attribute(push,target(LIBXSMM_OFFLOAD_TARGET))
#... |
rhs.c | //-------------------------------------------------------------------------//
// //
// This benchmark is an OpenMP C version of the NPB SP code. This OpenMP //
// C version is developed by the Center for Manycore Programming at Seoul //
// Nati... | //-------------------------------------------------------------------------//
// //
// This benchmark is an OpenMP C version of the NPB SP code. This OpenMP //
// C version is developed by the Center for Manycore Programming at Seoul //
// Nati... | //-------------------------------------------------------------------------//
// //
// This benchmark is an OpenMP C version of the NPB SP code. This OpenMP //
// C version is developed by the Center for Manycore Programming at Seoul //
// Nati... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.