Lines Matching refs:Function
220 // - an object, reference, function or function template that is
256 // A non-member function template can have internal linkage; any
258 const FunctionDecl *Function = 0;
261 Function = FunTmpl->getTemplatedDecl();
263 Function = cast<FunctionDecl>(D);
266 if (Function->getStorageClass() == SC_Static)
323 // variable or function with external linkage unless
330 // given variable or function shall be identical...
369 // - a function, unless it has internal linkage; or
370 } else if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
371 // In theory, we can modify the function's LV by the LV of its
376 if (Function->getStorageClass() == SC_PrivateExtern)
380 // If the declaration of an identifier for a function has no
385 (Function->getStorageClass() == SC_Extern ||
386 Function->getStorageClass() == SC_PrivateExtern ||
387 Function->getStorageClass() == SC_None)) {
397 if (const FunctionDecl *PrevFunc = Function->getPreviousDeclaration()) {
404 // In C++, then if the type of the function uses a type with
408 if (Context.getLangOptions().CPlusPlus && !Function->isExternC() &&
409 Function->getType()->getLinkage() == UniqueExternalLinkage)
415 = Function->getTemplateSpecializationInfo()) {
416 if (shouldConsiderTemplateLV(Function, specInfo)) {
463 // - a template, unless it is a function template that has
539 // If the type of the function uses a type with unique-external
651 // Clear cached linkage for function template decls, too.
688 // Use the most recent declaration of a function, and also handle
689 // function template specializations.
695 // If the function is a specialization of a template with an
744 // In addition, a member function, static data member, a named
754 // The name of a function declared in block scope and the name of
765 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
766 if (Function->isInAnonymousNamespace() && !Function->isExternC())
771 if (llvm::Optional<Visibility> Vis = Function->getExplicitVisibility())
775 if (const FunctionDecl *Prev = Function->getPreviousDeclaration()) {
906 // For function declarations, we keep track of redeclarations.
909 // For function templates, the underlying function declarations are linked.
936 // For non-function declarations, if the declarations are of the
1049 // Helper function: returns true if QT is or contains a type
1491 // Since we don't have a body for this function, we don't know if it's
1572 // In C, any non-static, non-overloadable function has external
1621 assert((!PrevDecl || PrevFunTmpl) && "Function/function template mismatch");
1645 /// \brief Returns a value indicating whether this function
1646 /// corresponds to a builtin function.
1648 /// The function corresponds to a built-in function if it is
1663 // This function has the name of a known C library
1664 // function. Determine whether it actually refers to the C library
1665 // function or whether it just has the same name.
1667 // If this is a static function, it's not a builtin.
1671 // If this function is at translation-unit scope and we're not in
1672 // C++, it refers to the C library function.
1677 // If the function is in an extern "C" linkage specification and is
1678 // not marked "overloadable", it's the real function.
1690 /// getNumParams - Return the number of parameters this function must have
1714 /// needed to call this function. This may be fewer than the number of
1715 /// function parameters, if some of the parameters have default
1780 /// \brief For a function declaration in C or C++, determine whether this
1784 /// function in a language where "inline" does not normally require an
1792 // In C99 mode, a function may have an inline definition (causing it to
1807 /// \brief For an inline function definition in C or C++, determine whether the
1810 /// Inline function definitions are always available for inlining optimizations.
1812 /// attributes, the definition of an inline function may or may not be
1819 /// In GNU89 mode, or if the gnu_inline attribute is attached to the function
1825 assert(doesThisDeclarationHaveABody() && "Must have the function definition");
1826 assert(isInlined() && "Function must be inline");
1850 // [...] If all of the file scope declarations for a function in a
1851 // translation unit include the inline function specifier without extern,
1871 // function, and does not forbid an external definition in another
1877 /// function represents, if any.
1885 /// getLiteralIdentifier - The literal suffix identifier this function
1926 "Member function is already a specialization");
1933 // If the function is invalid, it can't be implicitly instantiated.
2034 "Must specify the type of function template specialization");
2044 // Insert this function template specialization into the set of known
2045 // function template specializations.
2056 assert((!Existing || Existing->Function->isCanonicalDecl()) &&
2096 // For a function template specialization, query the specialization
2130 llvm_unreachable("Function cannot have a template specialization kind");
2149 // If this function was instantiated from a member function of a
2150 // class template, check whether that member function was defined out-of-line.
2157 // If this function was instantiated from a function template,
2158 // check whether that function template was defined out-of-line.
2548 FunctionDecl *New = new (C) FunctionDecl(Function, DC, StartLoc, NameInfo,
