This is an archive of the discontinued LLVM Phabricator instance.

Differential D44188

Misc typos
ClosedPublic

Authored by • luzpaz on Mar 6 2018, 8:48 PM.

Details

Reviewers
teemperor
alexfh
Commits
rG2a8c18d99118: Fix typos in clang
rL329399: Fix typos in clang
rC329399: Fix typos in clang
Summary

Found via codespell -q 3 -I ../clang-whitelist.txt
Where whitelist consists of:

archtype
cas
classs
checkk
compres
definit
frome
iff
inteval
ith
lod
methode
nd
optin
ot
pres
statics
te
thru

Diff Detail

Repository
rL LLVM

Event Timeline

• luzpaz created this revision.Mar 6 2018, 8:48 PM
Herald added a reviewer: teemperor. · View Herald TranscriptMar 6 2018, 8:48 PM
Herald added subscribers: cfe-commits, kbarton, whisperity and 6 others. · View Herald Transcript
• luzpaz updated this revision to Diff 137323.Mar 6 2018, 9:02 PM

Rebased and re-diffed

nhaehnle removed a subscriber: nhaehnle.Mar 7 2018, 1:37 AM
whisperity removed a subscriber: whisperity.Mar 10 2018, 1:31 AM
• luzpaz added a comment.Mar 14 2018, 6:23 AM

Please advise how to proceed

tra added a subscriber: tra.Mar 14 2018, 10:19 AM

You may want to split the patch into smaller pieces -- per leaf directory, for example.
That way potential reviewers would at least be able to see the changes (hundreds of files in one patch is a bit too much), and the subset of changes would be small enough for someone to own it (or at least familiar enough with it to give approval).

alexfh accepted this revision.Apr 6 2018, 7:02 AM
alexfh added a subscriber: alexfh.

Thanks!
I've looked through all the fixes. Most of them look reasonable. I've reverted a few files where I found something suspicious or outright wrong and will commit the rest of the patch after I ensure the tests pass.

These files couldn't be patched:

include/clang/Basic/AttrDocs.td
lib/Basic/VirtualFileSystem.cpp
lib/CodeGen/CGExpr.cpp
lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp
lib/Driver/ToolChains/Hexagon.cpp
lib/Sema/Sema.cpp
lib/StaticAnalyzer/Core/CoreEngine.cpp
test/CodeGenCXX/ms-integer-static-data-members.cpp

The list of the files I reverted:

lib/ARCMigrate/FileRemapper.cpp
lib/AST/ExprConstant.cpp
lib/Frontend/CacheTokens.cpp
lib/Frontend/CompilerInvocation.cpp
lib/Headers/htmintrin.h
lib/Parse/Parser.cpp
lib/Sema/SemaDeclCXX.cpp
lib/Sema/SemaLookup.cpp
test/CodeGen/builtins-arm-exclusive.c
test/CodeGen/vectorcall.c
test/Modules/odr_hash.cpp
test/Sema/warn-documentation-fixits.cpp
test/Sema/warn-documentation-unknown-command.cpp
This revision was not accepted when it landed; it landed in state Needs Review.Apr 6 2018, 8:20 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rC329399: Fix typos in clang (authored by alexfh). · Explain Why
Closed by commit rL329399: Fix typos in clang (authored by alexfh). · Explain Why
This revision was automatically updated to reflect the committed changes.
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: llvm-commits. · View Herald TranscriptApr 6 2018, 8:20 AM
alexfh mentioned this in rC329399: Fix typos in clang.Apr 6 2018, 8:21 AM
alexfh mentioned this in rL329399: Fix typos in clang.
alexfh added a comment.Apr 6 2018, 8:22 AM

Feel free to send the rest of the fixes as a separate patch.

teemperor mentioned this in D55475: Misc typos fixes in ./lib folder.Dec 9 2018, 6:34 AM

Revision Contents

PathSize
cfe/
trunk/
bindings/
python/
clang/
4 lines
cmake/
caches/
2 lines
docs/
2 lines
analyzer/
DesignDiscussions/
2 lines
2 lines
include/
clang-c/
4 lines
clang/
AST/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
6 lines
2 lines
4 lines
2 lines
8 lines
2 lines
ASTMatchers/
2 lines
Analysis/
Analyses/
2 lines
2 lines
Basic/
2 lines
4 lines
2 lines
4 lines
CodeGen/
2 lines
Driver/
2 lines
Frontend/
2 lines
2 lines
Lex/
2 lines
2 lines
2 lines
Parse/
4 lines
Sema/
2 lines
4 lines
StaticAnalyzer/
Core/
8 lines
BugReporter/
2 lines
PathSensitive/
2 lines
2 lines
2 lines
Tooling/
2 lines
Refactoring/
2 lines
4 lines
Rename/
2 lines
2 lines
2 lines
lib/
ARCMigrate/
2 lines
AST/
6 lines
4 lines
4 lines
2 lines
2 lines
2 lines
ASTMatchers/
Dynamic/
2 lines
Analysis/
2 lines
4 lines
Basic/
2 lines
2 lines
Targets/
2 lines
2 lines
CodeGen/
2 lines
6 lines
8 lines
8 lines
2 lines
2 lines
2 lines
4 lines
6 lines
8 lines
2 lines
8 lines
2 lines
4 lines
2 lines
4 lines
4 lines
8 lines
2 lines
2 lines
4 lines
2 lines
2 lines
Driver/
2 lines
ToolChains/
Arch/
2 lines
6 lines
2 lines
2 lines
Format/
2 lines
Frontend/
2 lines
2 lines
6 lines
2 lines
Rewrite/
4 lines
4 lines
Headers/
2 lines
2 lines
2 lines
4 lines
Lex/
2 lines
8 lines
2 lines
2 lines
2 lines
2 lines
Parse/
4 lines
4 lines
Sema/
2 lines
2 lines
8 lines
2 lines
2 lines
6 lines
2 lines
4 lines
6 lines
2 lines
2 lines
2 lines
8 lines
6 lines
2 lines
2 lines
4 lines
2 lines
Serialization/
2 lines
2 lines
StaticAnalyzer/
Checkers/
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
Core/
2 lines
2 lines
2 lines
Frontend/
2 lines
Tooling/
ASTDiff/
2 lines
Core/
2 lines
2 lines
Refactoring/
Rename/
2 lines
test/
ASTMerge/
namespace/
2 lines
Analysis/
2 lines
copypaste/
2 lines
2 lines
2 lines
18 lines
2 lines
2 lines
2 lines
2 lines
objc/
2 lines
2 lines
6 lines
CXX/
special/
class.init/
class.inhctor.init/
2 lines
CodeGen/
2 lines
2 lines
2 lines
CodeGenCUDA/
2 lines
2 lines
CodeGenCXX/
2 lines
2 lines
2 lines
2 lines
CodeGenOpenCL/
4 lines
Driver/
4 lines
8 lines
10 lines
2 lines
2 lines
2 lines
Headers/
2 lines
Index/
6 lines
Misc/
2 lines
2 lines
OpenMP/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
Parser/
4 lines
4 lines
Preprocessor/
4 lines
Sema/
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
SemaCUDA/
2 lines
SemaCXX/
2 lines
2 lines
2 lines
12 lines
2 lines
4 lines
2 lines
SemaObjC/
2 lines
2 lines
2 lines
tools/
c-index-test/
2 lines
clang-format/
2 lines
libclang/
4 lines
4 lines
6 lines
scan-build-py/
6 lines
libscanbuild/
4 lines
2 lines
scan-build/
bin/
4 lines
man/
2 lines
scan-view/
share/
6 lines
utils/
TableGen/
2 lines
2 lines
check_cfc/
2 lines
4 lines
www/
2 lines
analyzer/
6 lines
2 lines
2 lines
2 lines
2 lines

Diff 141349

cfe/trunk/bindings/python/clang/cindex.py

Show First 20 Lines • Show All 875 Lines • ▼ Show 20 Lines
# An expression whose specific kind is not exposed via this interface. # An expression whose specific kind is not exposed via this interface.
# #
# Unexposed expressions have the same operations as any other kind of # Unexposed expressions have the same operations as any other kind of
# expression; one can extract their location information, spelling, children, # expression; one can extract their location information, spelling, children,
# etc. However, the specific kind of the expression is not reported. # etc. However, the specific kind of the expression is not reported.
CursorKind.UNEXPOSED_EXPR = CursorKind(100) CursorKind.UNEXPOSED_EXPR = CursorKind(100)
# An expression that refers to some value declaration, such as a function, # An expression that refers to some value declaration, such as a function,
# varible, or enumerator. # variable, or enumerator.
CursorKind.DECL_REF_EXPR = CursorKind(101) CursorKind.DECL_REF_EXPR = CursorKind(101)
# An expression that refers to a member of a struct, union, class, Objective-C # An expression that refers to a member of a struct, union, class, Objective-C
# class, etc. # class, etc.
CursorKind.MEMBER_REF_EXPR = CursorKind(102) CursorKind.MEMBER_REF_EXPR = CursorKind(102)
# An expression that calls a function. # An expression that calls a function.
CursorKind.CALL_EXPR = CursorKind(103) CursorKind.CALL_EXPR = CursorKind(103)
▲ Show 20 Lines • Show All 603 Lines • ▼ Show 20 Lines def get_definition(self):
some entity, return a cursor that points to the definition of that some entity, return a cursor that points to the definition of that
entity. entity.
""" """
# TODO: Should probably check that this is either a reference or # TODO: Should probably check that this is either a reference or
# declaration prior to issuing the lookup. # declaration prior to issuing the lookup.
return conf.lib.clang_getCursorDefinition(self) return conf.lib.clang_getCursorDefinition(self)
def get_usr(self): def get_usr(self):
"""Return the Unified Symbol Resultion (USR) for the entity referenced """Return the Unified Symbol Resolution (USR) for the entity referenced
by the given cursor (or None). by the given cursor (or None).
A Unified Symbol Resolution (USR) is a string that identifies a A Unified Symbol Resolution (USR) is a string that identifies a
particular entity (function, class, variable, etc.) within a particular entity (function, class, variable, etc.) within a
program. USRs can be compared across translation units to determine, program. USRs can be compared across translation units to determine,
e.g., when references in one translation refer to an entity defined in e.g., when references in one translation refer to an entity defined in
another translation unit.""" another translation unit."""
return conf.lib.clang_getCursorUSR(self) return conf.lib.clang_getCursorUSR(self)
▲ Show 20 Lines • Show All 2,664 Lines • Show Last 20 Lines

cfe/trunk/cmake/caches/Apple-stage2.cmake

Show All 15 Lines
set(LLVM_ENABLE_MODULES ON CACHE BOOL "") set(LLVM_ENABLE_MODULES ON CACHE BOOL "")
set(LLVM_EXTERNALIZE_DEBUGINFO ON CACHE BOOL "") set(LLVM_EXTERNALIZE_DEBUGINFO ON CACHE BOOL "")
set(CLANG_PLUGIN_SUPPORT OFF CACHE BOOL "") set(CLANG_PLUGIN_SUPPORT OFF CACHE BOOL "")
set(BUG_REPORT_URL "http://developer.apple.com/bugreporter/" CACHE STRING "") set(BUG_REPORT_URL "http://developer.apple.com/bugreporter/" CACHE STRING "")
set(LLVM_BUILD_EXTERNAL_COMPILER_RT ON CACHE BOOL "Build Compiler-RT with just-built clang") set(LLVM_BUILD_EXTERNAL_COMPILER_RT ON CACHE BOOL "Build Compiler-RT with just-built clang")
set(COMPILER_RT_ENABLE_IOS ON CACHE BOOL "Build iOS Compiler-RT libraries") set(COMPILER_RT_ENABLE_IOS ON CACHE BOOL "Build iOS Compiler-RT libraries")
set(LLVM_CREATE_XCODE_TOOLCHAIN ON CACHE BOOL "Generate targets to create and install an Xcode compatable toolchain") set(LLVM_CREATE_XCODE_TOOLCHAIN ON CACHE BOOL "Generate targets to create and install an Xcode compatible toolchain")
# Make unit tests (if present) part of the ALL target # Make unit tests (if present) part of the ALL target
set(LLVM_BUILD_TESTS ON CACHE BOOL "") set(LLVM_BUILD_TESTS ON CACHE BOOL "")
set(LLVM_ENABLE_LTO ON CACHE BOOL "") set(LLVM_ENABLE_LTO ON CACHE BOOL "")
set(CMAKE_C_FLAGS "-fno-stack-protector -fno-common -Wno-profile-instr-unprofiled" CACHE STRING "") set(CMAKE_C_FLAGS "-fno-stack-protector -fno-common -Wno-profile-instr-unprofiled" CACHE STRING "")
set(CMAKE_CXX_FLAGS "-fno-stack-protector -fno-common -Wno-profile-instr-unprofiled" CACHE STRING "") set(CMAKE_CXX_FLAGS "-fno-stack-protector -fno-common -Wno-profile-instr-unprofiled" CACHE STRING "")
if(LLVM_ENABLE_LTO AND NOT LLVM_ENABLE_LTO STREQUAL "THIN") if(LLVM_ENABLE_LTO AND NOT LLVM_ENABLE_LTO STREQUAL "THIN")
Show All 38 Lines

cfe/trunk/docs/LibASTMatchersReference.html

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,551 Lines • ▼ Show 20 Lines
<tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMemberCallExpr.html">CXXMemberCallExpr</a>&gt;</td><td class="name" onclick="toggle('thisPointerType0')"><a name="thisPointerType0Anchor">thisPointerType</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr> <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMemberCallExpr.html">CXXMemberCallExpr</a>&gt;</td><td class="name" onclick="toggle('thisPointerType0')"><a name="thisPointerType0Anchor">thisPointerType</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
<tr><td colspan="4" class="doc" id="thisPointerType0"><pre>Matches if the expression's type either matches the specified <tr><td colspan="4" class="doc" id="thisPointerType0"><pre>Matches if the expression's type either matches the specified
matcher, or is a pointer to a type that matches the InnerMatcher. matcher, or is a pointer to a type that matches the InnerMatcher.
</pre></td></tr> </pre></td></tr>
<tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('forEachOverridden0')"><a name="forEachOverridden0Anchor">forEachOverridden</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt; InnerMatcher</td></tr> <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('forEachOverridden0')"><a name="forEachOverridden0Anchor">forEachOverridden</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt; InnerMatcher</td></tr>
<tr><td colspan="4" class="doc" id="forEachOverridden0"><pre>Matches each method overriden by the given method. This matcher may <tr><td colspan="4" class="doc" id="forEachOverridden0"><pre>Matches each method overridden by the given method. This matcher may
produce multiple matches. produce multiple matches.
Given Given
class A { virtual void f(); }; class A { virtual void f(); };
class B : public A { void f(); }; class B : public A { void f(); };
class C : public B { void f(); }; class C : public B { void f(); };
cxxMethodDecl(ofClass(hasName("C")), cxxMethodDecl(ofClass(hasName("C")),
forEachOverridden(cxxMethodDecl().bind("b"))).bind("d") forEachOverridden(cxxMethodDecl().bind("b"))).bind("d")
▲ Show 20 Lines • Show All 1,991 Lines • Show Last 20 Lines

cfe/trunk/docs/analyzer/DesignDiscussions/InitializerLists.rst

Show All 15 Lines
Approach (0): This can be trivially fixed by this patch, which causes pointers Approach (0): This can be trivially fixed by this patch, which causes pointers
passed into initializer list expressions to immediately escape. passed into initializer list expressions to immediately escape.
This fix is overly conservative though. So i did a bit of investigation as to This fix is overly conservative though. So i did a bit of investigation as to
how model std::initializer_list better. how model std::initializer_list better.
According to the standard, std::initializer_list<T> is an object that has According to the standard, std::initializer_list<T> is an object that has
methods begin(), end(), and size(), where begin() returns a pointer to continous methods begin(), end(), and size(), where begin() returns a pointer to continuous
array of size() objects of type T, and end() is equal to begin() plus size(). array of size() objects of type T, and end() is equal to begin() plus size().
The standard does hint that it should be possible to implement The standard does hint that it should be possible to implement
std::initializer_list<T> as a pair of pointers, or as a pointer and a size std::initializer_list<T> as a pair of pointers, or as a pointer and a size
integer, however specific fields that the object would contain are an integer, however specific fields that the object would contain are an
implementation detail. implementation detail.
Ideally, we should be able to model the initializer list's methods precisely. Ideally, we should be able to model the initializer list's methods precisely.
Or, at least, it should be possible to explain to the analyzer that the list Or, at least, it should be possible to explain to the analyzer that the list
▲ Show 20 Lines • Show All 289 Lines • Show Last 20 Lines

cfe/trunk/docs/doxygen.cfg.in

Show First 20 Lines • Show All 1,059 Lines • ▼ Show 20 Lines
# This tag requires that the tag GENERATE_HTML is set to YES. # This tag requires that the tag GENERATE_HTML is set to YES.
HTML_STYLESHEET = HTML_STYLESHEET =
# The HTML_EXTRA_STYLESHEET tag can be used to specify an additional user- # The HTML_EXTRA_STYLESHEET tag can be used to specify an additional user-
# defined cascading style sheet that is included after the standard style sheets # defined cascading style sheet that is included after the standard style sheets
# created by doxygen. Using this option one can overrule certain style aspects. # created by doxygen. Using this option one can overrule certain style aspects.
# This is preferred over using HTML_STYLESHEET since it does not replace the # This is preferred over using HTML_STYLESHEET since it does not replace the
# standard style sheet and is therefor more robust against future updates. # standard style sheet and is therefore more robust against future updates.
# Doxygen will copy the style sheet file to the output directory. For an example # Doxygen will copy the style sheet file to the output directory. For an example
# see the documentation. # see the documentation.
# This tag requires that the tag GENERATE_HTML is set to YES. # This tag requires that the tag GENERATE_HTML is set to YES.
HTML_EXTRA_STYLESHEET = HTML_EXTRA_STYLESHEET =
# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
# other source files which should be copied to the HTML output directory. Note # other source files which should be copied to the HTML output directory. Note
▲ Show 20 Lines • Show All 1,217 Lines • Show Last 20 Lines

cfe/trunk/include/clang-c/Index.h

Show First 20 Lines • Show All 4,982 Lines • ▼ Show 20 Linesenum CXCompletionChunkKind {
* int add(int x, int y); * int add(int x, int y);
* \endcode * \endcode
* *
* and the source code \c add(, where the code-completion point is after the * and the source code \c add(, where the code-completion point is after the
* "(", the code-completion string will contain a "current parameter" chunk * "(", the code-completion string will contain a "current parameter" chunk
* for "int x", indicating that the current argument will initialize that * for "int x", indicating that the current argument will initialize that
* parameter. After typing further, to \c add(17, (where the code-completion * parameter. After typing further, to \c add(17, (where the code-completion
* point is after the ","), the code-completion string will contain a * point is after the ","), the code-completion string will contain a
* "current paremeter" chunk to "int y". * "current parameter" chunk to "int y".
*/ */
CXCompletionChunk_CurrentParameter, CXCompletionChunk_CurrentParameter,
/** /**
* \brief A left parenthesis ('('), used to initiate a function call or * \brief A left parenthesis ('('), used to initiate a function call or
* signal the beginning of a function parameter list. * signal the beginning of a function parameter list.
*/ */
CXCompletionChunk_LeftParen, CXCompletionChunk_LeftParen,
/** /**
▲ Show 20 Lines • Show All 404 Lines • ▼ Show 20 Lines
* current location in the C/Objective-C/C++ grammar and the state of * current location in the C/Objective-C/C++ grammar and the state of
* semantic analysis, what completions to provide. These completions are * semantic analysis, what completions to provide. These completions are
* returned via a new \c CXCodeCompleteResults structure. * returned via a new \c CXCodeCompleteResults structure.
* *
* Code completion itself is meant to be triggered by the client when the * Code completion itself is meant to be triggered by the client when the
* user types punctuation characters or whitespace, at which point the * user types punctuation characters or whitespace, at which point the
* code-completion location will coincide with the cursor. For example, if \c p * code-completion location will coincide with the cursor. For example, if \c p
* is a pointer, code-completion might be triggered after the "-" and then * is a pointer, code-completion might be triggered after the "-" and then
* after the ">" in \c p->. When the code-completion location is afer the ">", * after the ">" in \c p->. When the code-completion location is after the ">",
* the completion results will provide, e.g., the members of the struct that * the completion results will provide, e.g., the members of the struct that
* "p" points to. The client is responsible for placing the cursor at the * "p" points to. The client is responsible for placing the cursor at the
* beginning of the token currently being typed, then filtering the results * beginning of the token currently being typed, then filtering the results
* based on the contents of the token. For example, when code-completing for * based on the contents of the token. For example, when code-completing for
* the expression \c p->get, the client should provide the location just after * the expression \c p->get, the client should provide the location just after
* the ">" (e.g., pointing at the "g") to this code-completion hook. Then, the * the ">" (e.g., pointing at the "g") to this code-completion hook. Then, the
* client can filter the results based on the current token text ("get"), only * client can filter the results based on the current token text ("get"), only
* showing those results that start with "get". The intent of this interface * showing those results that start with "get". The intent of this interface
▲ Show 20 Lines • Show All 1,052 Lines • Show Last 20 Lines

cfe/trunk/include/clang/AST/ASTContext.h

Show First 20 Lines • Show All 1,107 Lines • ▼ Show 20 Linespublic:
/// ///
/// The return type should be T with all prior qualifiers minus the address /// The return type should be T with all prior qualifiers minus the address
/// space. /// space.
QualType removeAddrSpaceQualType(QualType T) const; QualType removeAddrSpaceQualType(QualType T) const;
/// \brief Apply Objective-C protocol qualifiers to the given type. /// \brief Apply Objective-C protocol qualifiers to the given type.
/// \param allowOnPointerType specifies if we can apply protocol /// \param allowOnPointerType specifies if we can apply protocol
/// qualifiers on ObjCObjectPointerType. It can be set to true when /// qualifiers on ObjCObjectPointerType. It can be set to true when
/// contructing the canonical type of a Objective-C type parameter. /// constructing the canonical type of a Objective-C type parameter.
QualType applyObjCProtocolQualifiers(QualType type, QualType applyObjCProtocolQualifiers(QualType type,
ArrayRef<ObjCProtocolDecl *> protocols, bool &hasError, ArrayRef<ObjCProtocolDecl *> protocols, bool &hasError,
bool allowOnPointerType = false) const; bool allowOnPointerType = false) const;
/// \brief Return the uniqued reference to the type for an Objective-C /// \brief Return the uniqued reference to the type for an Objective-C
/// gc-qualified type. /// gc-qualified type.
/// ///
/// The retulting type has a union of the qualifiers from T and the gc /// The retulting type has a union of the qualifiers from T and the gc
▲ Show 20 Lines • Show All 1,848 Lines • Show Last 20 Lines

cfe/trunk/include/clang/AST/ASTTypeTraits.h

Show First 20 Lines • Show All 263 Lines • ▼ Show 20 Linespublic:
/// \brief For nodes which represent textual entities in the source code, /// \brief For nodes which represent textual entities in the source code,
/// return their SourceRange. For all other nodes, return SourceRange(). /// return their SourceRange. For all other nodes, return SourceRange().
SourceRange getSourceRange() const; SourceRange getSourceRange() const;
/// @{ /// @{
/// \brief Imposes an order on \c DynTypedNode. /// \brief Imposes an order on \c DynTypedNode.
/// ///
/// Supports comparison of nodes that support memoization. /// Supports comparison of nodes that support memoization.
/// FIXME: Implement comparsion for other node types (currently /// FIXME: Implement comparison for other node types (currently
/// only Stmt, Decl, Type and NestedNameSpecifier return memoization data). /// only Stmt, Decl, Type and NestedNameSpecifier return memoization data).
bool operator<(const DynTypedNode &Other) const { bool operator<(const DynTypedNode &Other) const {
if (!NodeKind.isSame(Other.NodeKind)) if (!NodeKind.isSame(Other.NodeKind))
return NodeKind < Other.NodeKind; return NodeKind < Other.NodeKind;
if (ASTNodeKind::getFromNodeKind<QualType>().isSame(NodeKind)) if (ASTNodeKind::getFromNodeKind<QualType>().isSame(NodeKind))
return getUnchecked<QualType>().getAsOpaquePtr() < return getUnchecked<QualType>().getAsOpaquePtr() <
Other.getUnchecked<QualType>().getAsOpaquePtr(); Other.getUnchecked<QualType>().getAsOpaquePtr();
▲ Show 20 Lines • Show All 237 Lines • Show Last 20 Lines

cfe/trunk/include/clang/AST/CanonicalType.h

Show First 20 Lines • Show All 318 Lines • ▼ Show 20 Linespublic:
/// for the given type T. In that case, we reference members of the /// for the given type T. In that case, we reference members of the
/// CanProxyAdaptor specialization. Otherwise, this operator will be hidden /// CanProxyAdaptor specialization. Otherwise, this operator will be hidden
/// by the arrow operator in the primary CanProxyAdaptor template. /// by the arrow operator in the primary CanProxyAdaptor template.
const CanProxyAdaptor<T> *operator->() const { const CanProxyAdaptor<T> *operator->() const {
return static_cast<const CanProxyAdaptor<T> *>(this); return static_cast<const CanProxyAdaptor<T> *>(this);
} }
}; };
/// \brief Replacable canonical proxy adaptor class that provides the link /// \brief Replaceable canonical proxy adaptor class that provides the link
/// between a canonical type and the accessors of the type. /// between a canonical type and the accessors of the type.
/// ///
/// The CanProxyAdaptor is a replaceable class template that is instantiated /// The CanProxyAdaptor is a replaceable class template that is instantiated
/// as part of each canonical proxy type. The primary template merely provides /// as part of each canonical proxy type. The primary template merely provides
/// redirection to the underlying type (T), e.g., @c PointerType. One can /// redirection to the underlying type (T), e.g., @c PointerType. One can
/// provide specializations of this class template for each underlying type /// provide specializations of this class template for each underlying type
/// that provide accessors returning canonical types (@c CanQualType) rather /// that provide accessors returning canonical types (@c CanQualType) rather
/// than the more typical @c QualType, to propagate the notion of "canonical" /// than the more typical @c QualType, to propagate the notion of "canonical"
▲ Show 20 Lines • Show All 352 Lines • Show Last 20 Lines

cfe/trunk/include/clang/AST/Comment.h

Show First 20 Lines • Show All 984 Lines • ▼ Show 20 Lines
/// Information about the declaration, useful to clients of FullComment. /// Information about the declaration, useful to clients of FullComment.
struct DeclInfo { struct DeclInfo {
/// Declaration the comment is actually attached to (in the source). /// Declaration the comment is actually attached to (in the source).
/// Should not be NULL. /// Should not be NULL.
const Decl *CommentDecl; const Decl *CommentDecl;
/// CurrentDecl is the declaration with which the FullComment is associated. /// CurrentDecl is the declaration with which the FullComment is associated.
/// ///
/// It can be different from \c CommentDecl. It happens when we we decide /// It can be different from \c CommentDecl. It happens when we decide
/// that the comment originally attached to \c CommentDecl is fine for /// that the comment originally attached to \c CommentDecl is fine for
/// \c CurrentDecl too (for example, for a redeclaration or an overrider of /// \c CurrentDecl too (for example, for a redeclaration or an overrider of
/// \c CommentDecl). /// \c CommentDecl).
/// ///
/// The information in the DeclInfo corresponds to CurrentDecl. /// The information in the DeclInfo corresponds to CurrentDecl.
const Decl *CurrentDecl; const Decl *CurrentDecl;
/// Parameters that can be referenced by \\param if \c CommentDecl is something /// Parameters that can be referenced by \\param if \c CommentDecl is something
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

cfe/trunk/include/clang/AST/CommentLexer.h

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Linesclass Token {
/// tokens. /// tokens.
unsigned Length; unsigned Length;
/// Contains text value associated with a token. /// Contains text value associated with a token.
const char *TextPtr; const char *TextPtr;
/// Integer value associated with a token. /// Integer value associated with a token.
/// ///
/// If the token is a konwn command, contains command ID and TextPtr is /// If the token is a known command, contains command ID and TextPtr is
/// unused (command spelling can be found with CommandTraits). Otherwise, /// unused (command spelling can be found with CommandTraits). Otherwise,
/// contains the length of the string that starts at TextPtr. /// contains the length of the string that starts at TextPtr.
unsigned IntVal; unsigned IntVal;
public: public:
SourceLocation getLocation() const LLVM_READONLY { return Loc; } SourceLocation getLocation() const LLVM_READONLY { return Loc; }
void setLocation(SourceLocation SL) { Loc = SL; } void setLocation(SourceLocation SL) { Loc = SL; }
▲ Show 20 Lines • Show All 278 Lines • Show Last 20 Lines

cfe/trunk/include/clang/AST/DataCollection.h

//===--- DatatCollection.h --------------------------------------*- C++ -*-===// //===--- DatatCollection.h --------------------------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// \file /// \file
/// \brief This file declares helper methods for collecting data from AST nodes. /// \brief This file declares helper methods for collecting data from AST nodes.
/// ///
/// To collect data from Stmt nodes, subclass ConstStmtVisitor and include /// To collect data from Stmt nodes, subclass ConstStmtVisitor and include
/// StmtDataCollectors.inc after defining the macros that you need. This /// StmtDataCollectors.inc after defining the macros that you need. This
/// provides data collection implementations for most Stmt kinds. Note /// provides data collection implementations for most Stmt kinds. Note
/// that that code requires some conditions to be met: /// that the code requires some conditions to be met:
/// ///
/// - There must be a method addData(const T &Data) that accepts strings, /// - There must be a method addData(const T &Data) that accepts strings,
/// integral types as well as QualType. All data is forwarded using /// integral types as well as QualType. All data is forwarded using
/// to this method. /// to this method.
/// - The ASTContext of the Stmt must be accessible by the name Context. /// - The ASTContext of the Stmt must be accessible by the name Context.
/// ///
/// It is also possible to override individual visit methods. Have a look at /// It is also possible to override individual visit methods. Have a look at
/// the DataCollector in lib/Analysis/CloneDetection.cpp for a usage example. /// the DataCollector in lib/Analysis/CloneDetection.cpp for a usage example.
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

cfe/trunk/include/clang/AST/DeclCXX.h

Show First 20 Lines • Show All 1,072 Lines • ▼ Show 20 Linespublic:
/// constructor for this class. /// constructor for this class.
bool needsOverloadResolutionForMoveConstructor() const { bool needsOverloadResolutionForMoveConstructor() const {
return data().NeedOverloadResolutionForMoveConstructor; return data().NeedOverloadResolutionForMoveConstructor;
} }
/// \brief Determine whether this class has a user-declared copy assignment /// \brief Determine whether this class has a user-declared copy assignment
/// operator. /// operator.
/// ///
/// When false, a copy assigment operator will be implicitly declared. /// When false, a copy assignment operator will be implicitly declared.
bool hasUserDeclaredCopyAssignment() const { bool hasUserDeclaredCopyAssignment() const {
return data().UserDeclaredSpecialMembers & SMF_CopyAssignment; return data().UserDeclaredSpecialMembers & SMF_CopyAssignment;
} }
/// \brief Determine whether this class needs an implicit copy /// \brief Determine whether this class needs an implicit copy
/// assignment operator to be lazily declared. /// assignment operator to be lazily declared.
bool needsImplicitCopyAssignment() const { bool needsImplicitCopyAssignment() const {
return !(data().DeclaredSpecialMembers & SMF_CopyAssignment); return !(data().DeclaredSpecialMembers & SMF_CopyAssignment);
▲ Show 20 Lines • Show All 846 Lines • ▼ Show 20 Lines bool isDependentLambda() const {
return isLambda() && getLambdaData().Dependent; return isLambda() && getLambdaData().Dependent;
} }
TypeSourceInfo *getLambdaTypeInfo() const { TypeSourceInfo *getLambdaTypeInfo() const {
return getLambdaData().MethodTyInfo; return getLambdaData().MethodTyInfo;
} }
// \brief Determine whether this type is an Interface Like type for // \brief Determine whether this type is an Interface Like type for
// __interface inheritence purposes. // __interface inheritance purposes.
bool isInterfaceLike() const; bool isInterfaceLike() const;
static bool classof(const Decl *D) { return classofKind(D->getKind()); } static bool classof(const Decl *D) { return classofKind(D->getKind()); }
static bool classofKind(Kind K) { static bool classofKind(Kind K) {
return K >= firstCXXRecord && K <= lastCXXRecord; return K >= firstCXXRecord && K <= lastCXXRecord;
} }
}; };
▲ Show 20 Lines • Show All 1,974 Lines • Show Last 20 Lines

cfe/trunk/include/clang/AST/Expr.h

Show First 20 Lines • Show All 580 Lines • ▼ Show 20 Linespublic:
/// an rvalue using any crazy technique (that has nothing to do with language /// an rvalue using any crazy technique (that has nothing to do with language
/// standards) that we want to, even if the expression has side-effects. If /// standards) that we want to, even if the expression has side-effects. If
/// this function returns true, it returns the folded constant in Result. If /// this function returns true, it returns the folded constant in Result. If
/// the expression is a glvalue, an lvalue-to-rvalue conversion will be /// the expression is a glvalue, an lvalue-to-rvalue conversion will be
/// applied. /// applied.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx) const; bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx) const;
/// EvaluateAsBooleanCondition - Return true if this is a constant /// EvaluateAsBooleanCondition - Return true if this is a constant
/// which we we can fold and convert to a boolean condition using /// which we can fold and convert to a boolean condition using
/// any crazy technique that we want to, even if the expression has /// any crazy technique that we want to, even if the expression has
/// side-effects. /// side-effects.
bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx) const; bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx) const;
enum SideEffectsKind { enum SideEffectsKind {
SE_NoSideEffects, ///< Strictly evaluate the expression. SE_NoSideEffects, ///< Strictly evaluate the expression.
SE_AllowUndefinedBehavior, ///< Allow UB that we can give a value, but not SE_AllowUndefinedBehavior, ///< Allow UB that we can give a value, but not
///< arbitrary unmodeled side effects. ///< arbitrary unmodeled side effects.
▲ Show 20 Lines • Show All 2,497 Lines • ▼ Show 20 Linespublic:
bool isEqualityOp() const { return isEqualityOp(getOpcode()); } bool isEqualityOp() const { return isEqualityOp(getOpcode()); }
static bool isComparisonOp(Opcode Opc) { return Opc >= BO_Cmp && Opc<=BO_NE; } static bool isComparisonOp(Opcode Opc) { return Opc >= BO_Cmp && Opc<=BO_NE; }
bool isComparisonOp() const { return isComparisonOp(getOpcode()); } bool isComparisonOp() const { return isComparisonOp(getOpcode()); }
static Opcode negateComparisonOp(Opcode Opc) { static Opcode negateComparisonOp(Opcode Opc) {
switch (Opc) { switch (Opc) {
default: default:
llvm_unreachable("Not a comparsion operator."); llvm_unreachable("Not a comparison operator.");
case BO_LT: return BO_GE; case BO_LT: return BO_GE;
case BO_GT: return BO_LE; case BO_GT: return BO_LE;
case BO_LE: return BO_GT; case BO_LE: return BO_GT;
case BO_GE: return BO_LT; case BO_GE: return BO_LT;
case BO_EQ: return BO_NE; case BO_EQ: return BO_NE;
case BO_NE: return BO_EQ; case BO_NE: return BO_EQ;
} }
} }
static Opcode reverseComparisonOp(Opcode Opc) { static Opcode reverseComparisonOp(Opcode Opc) {
switch (Opc) { switch (Opc) {
default: default:
llvm_unreachable("Not a comparsion operator."); llvm_unreachable("Not a comparison operator.");
case BO_LT: return BO_GT; case BO_LT: return BO_GT;
case BO_GT: return BO_LT; case BO_GT: return BO_LT;
case BO_LE: return BO_GE; case BO_LE: return BO_GE;
case BO_GE: return BO_LE; case BO_GE: return BO_LE;
case BO_EQ: case BO_EQ:
case BO_NE: case BO_NE:
return Opc; return Opc;
} }
▲ Show 20 Lines • Show All 2,158 Lines • Show Last 20 Lines

cfe/trunk/include/clang/AST/ExternalASTMerger.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
public: public:
ExternalASTMerger(const ImporterTarget &Target, ExternalASTMerger(const ImporterTarget &Target,
llvm::ArrayRef<ImporterSource> Sources); llvm::ArrayRef<ImporterSource> Sources);
/// Add a set of ASTContexts as possible origins. /// Add a set of ASTContexts as possible origins.
/// ///
/// Usually the set will be initialized in the constructor, but long-lived /// Usually the set will be initialized in the constructor, but long-lived
/// ExternalASTMergers may neeed to import from new sources (for example, /// ExternalASTMergers may need to import from new sources (for example,
/// newly-parsed source files). /// newly-parsed source files).
/// ///
/// Ensures that Importers does not gain duplicate entries as a result. /// Ensures that Importers does not gain duplicate entries as a result.
void AddSources(llvm::ArrayRef<ImporterSource> Sources); void AddSources(llvm::ArrayRef<ImporterSource> Sources);
/// Remove a set of ASTContexts as possible origins. /// Remove a set of ASTContexts as possible origins.
/// ///
/// Sometimes an origin goes away (for example, if a source file gets /// Sometimes an origin goes away (for example, if a source file gets
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

cfe/trunk/include/clang/AST/NestedNameSpecifier.h

Show First 20 Lines • Show All 244 Lines • ▼ Show 20 Linespublic:
/// \brief Construct an empty nested-name-specifier. /// \brief Construct an empty nested-name-specifier.
NestedNameSpecifierLoc() = default; NestedNameSpecifierLoc() = default;
/// \brief Construct a nested-name-specifier with source location information /// \brief Construct a nested-name-specifier with source location information
/// from /// from
NestedNameSpecifierLoc(NestedNameSpecifier *Qualifier, void *Data) NestedNameSpecifierLoc(NestedNameSpecifier *Qualifier, void *Data)
: Qualifier(Qualifier), Data(Data) {} : Qualifier(Qualifier), Data(Data) {}
/// \brief Evalutes true when this nested-name-specifier location is /// \brief Evaluates true when this nested-name-specifier location is
/// non-empty. /// non-empty.
explicit operator bool() const { return Qualifier; } explicit operator bool() const { return Qualifier; }
/// \brief Evalutes true when this nested-name-specifier location is /// \brief Evaluates true when this nested-name-specifier location is
/// empty. /// empty.
bool hasQualifier() const { return Qualifier; } bool hasQualifier() const { return Qualifier; }
/// \brief Retrieve the nested-name-specifier to which this instance /// \brief Retrieve the nested-name-specifier to which this instance
/// refers. /// refers.
NestedNameSpecifier *getNestedNameSpecifier() const { NestedNameSpecifier *getNestedNameSpecifier() const {
return Qualifier; return Qualifier;
} }
▲ Show 20 Lines • Show All 255 Lines • Show Last 20 Lines

cfe/trunk/include/clang/AST/RecursiveASTVisitor.h

Show First 20 Lines • Show All 140 Lines • ▼ Show 20 Lines
/// are still visited, and the patterns of partial specializations /// are still visited, and the patterns of partial specializations
/// are visited separately. This behavior can be changed by /// are visited separately. This behavior can be changed by
/// overriding shouldVisitTemplateInstantiations() in the derived class /// overriding shouldVisitTemplateInstantiations() in the derived class
/// to return true, in which case all known implicit and explicit /// to return true, in which case all known implicit and explicit
/// instantiations will be visited at the same time as the pattern /// instantiations will be visited at the same time as the pattern
/// from which they were produced. /// from which they were produced.
/// ///
/// By default, this visitor preorder traverses the AST. If postorder traversal /// By default, this visitor preorder traverses the AST. If postorder traversal
/// is needed, the \c shouldTraversePostOrder method needs to be overriden /// is needed, the \c shouldTraversePostOrder method needs to be overridden
/// to return \c true. /// to return \c true.
template <typename Derived> class RecursiveASTVisitor { template <typename Derived> class RecursiveASTVisitor {
public: public:
/// A queue used for performing data recursion over statements. /// A queue used for performing data recursion over statements.
/// Parameters involving this type are used to implement data /// Parameters involving this type are used to implement data
/// recursion over Stmts and Exprs within this class, and should /// recursion over Stmts and Exprs within this class, and should
/// typically not be explicitly specified by derived classes. /// typically not be explicitly specified by derived classes.
/// The bool bit indicates whether the statement has been traversed or not. /// The bool bit indicates whether the statement has been traversed or not.
▲ Show 20 Lines • Show All 3,074 Lines • Show Last 20 Lines

cfe/trunk/include/clang/AST/StmtOpenMP.h

Show First 20 Lines • Show All 623 Lines • ▼ Show 20 Lines struct DistCombinedHelperExprs {
Expr *EUB; Expr *EUB;
/// Distribute loop iteration variable init used when composing 'omp /// Distribute loop iteration variable init used when composing 'omp
/// distribute' /// distribute'
/// with 'omp for' in a same construct /// with 'omp for' in a same construct
Expr *Init; Expr *Init;
/// Distribute Loop condition used when composing 'omp distribute' /// Distribute Loop condition used when composing 'omp distribute'
/// with 'omp for' in a same construct /// with 'omp for' in a same construct
Expr *Cond; Expr *Cond;
/// Update of LowerBound for statically sheduled omp loops for /// Update of LowerBound for statically scheduled omp loops for
/// outer loop in combined constructs (e.g. 'distribute parallel for') /// outer loop in combined constructs (e.g. 'distribute parallel for')
Expr *NLB; Expr *NLB;
/// Update of UpperBound for statically sheduled omp loops for /// Update of UpperBound for statically scheduled omp loops for
/// outer loop in combined constructs (e.g. 'distribute parallel for') /// outer loop in combined constructs (e.g. 'distribute parallel for')
Expr *NUB; Expr *NUB;
}; };
/// \brief The expressions built for the OpenMP loop CodeGen for the /// \brief The expressions built for the OpenMP loop CodeGen for the
/// whole collapsed loop nest. /// whole collapsed loop nest.
struct HelperExprs { struct HelperExprs {
/// \brief Loop iteration variable. /// \brief Loop iteration variable.
Show All 17 Lines struct HelperExprs {
/// \brief LowerBound - local variable passed to runtime. /// \brief LowerBound - local variable passed to runtime.
Expr *LB; Expr *LB;
/// \brief UpperBound - local variable passed to runtime. /// \brief UpperBound - local variable passed to runtime.
Expr *UB; Expr *UB;
/// \brief Stride - local variable passed to runtime. /// \brief Stride - local variable passed to runtime.
Expr *ST; Expr *ST;
/// \brief EnsureUpperBound -- expression UB = min(UB, NumIterations). /// \brief EnsureUpperBound -- expression UB = min(UB, NumIterations).
Expr *EUB; Expr *EUB;
/// \brief Update of LowerBound for statically sheduled 'omp for' loops. /// \brief Update of LowerBound for statically scheduled 'omp for' loops.
Expr *NLB; Expr *NLB;
/// \brief Update of UpperBound for statically sheduled 'omp for' loops. /// \brief Update of UpperBound for statically scheduled 'omp for' loops.
Expr *NUB; Expr *NUB;
/// \brief PreviousLowerBound - local variable passed to runtime in the /// \brief PreviousLowerBound - local variable passed to runtime in the
/// enclosing schedule or null if that does not apply. /// enclosing schedule or null if that does not apply.
Expr *PrevLB; Expr *PrevLB;
/// \brief PreviousUpperBound - local variable passed to runtime in the /// \brief PreviousUpperBound - local variable passed to runtime in the
/// enclosing schedule or null if that does not apply. /// enclosing schedule or null if that does not apply.
Expr *PrevUB; Expr *PrevUB;
/// \brief DistInc - increment expression for distribute loop when found /// \brief DistInc - increment expression for distribute loop when found
▲ Show 20 Lines • Show All 3,368 Lines • Show Last 20 Lines

cfe/trunk/include/clang/AST/Type.h

Show First 20 Lines • Show All 2,004 Lines • ▼ Show 20 Lines#include "clang/Basic/OpenCLImageTypes.def"
CXXRecordDecl *getAsCXXRecordDecl() const; CXXRecordDecl *getAsCXXRecordDecl() const;
/// \brief Retrieves the TagDecl that this type refers to, either /// \brief Retrieves the TagDecl that this type refers to, either
/// because the type is a TagType or because it is the injected-class-name /// because the type is a TagType or because it is the injected-class-name
/// type of a class template or class template partial specialization. /// type of a class template or class template partial specialization.
TagDecl *getAsTagDecl() const; TagDecl *getAsTagDecl() const;
/// If this is a pointer or reference to a RecordType, return the /// If this is a pointer or reference to a RecordType, return the
/// CXXRecordDecl that that type refers to. /// CXXRecordDecl that the type refers to.
/// ///
/// If this is not a pointer or reference, or the type being pointed to does /// If this is not a pointer or reference, or the type being pointed to does
/// not refer to a CXXRecordDecl, returns NULL. /// not refer to a CXXRecordDecl, returns NULL.
const CXXRecordDecl *getPointeeCXXRecordDecl() const; const CXXRecordDecl *getPointeeCXXRecordDecl() const;
/// Get the DeducedType whose type will be deduced for a variable with /// Get the DeducedType whose type will be deduced for a variable with
/// an initializer of this type. This looks through declarators like pointer /// an initializer of this type. This looks through declarators like pointer
/// types, but not through decltype or typedefs. /// types, but not through decltype or typedefs.
▲ Show 20 Lines • Show All 4,467 Lines • Show Last 20 Lines

cfe/trunk/include/clang/ASTMatchers/ASTMatchers.h

Show First 20 Lines • Show All 4,292 Lines • ▼ Show 20 Lines
/// \endcode /// \endcode
AST_MATCHER_P(CXXMethodDecl, ofClass, AST_MATCHER_P(CXXMethodDecl, ofClass,
internal::Matcher<CXXRecordDecl>, InnerMatcher) { internal::Matcher<CXXRecordDecl>, InnerMatcher) {
const CXXRecordDecl *Parent = Node.getParent(); const CXXRecordDecl *Parent = Node.getParent();
return (Parent != nullptr && return (Parent != nullptr &&
InnerMatcher.matches(*Parent, Finder, Builder)); InnerMatcher.matches(*Parent, Finder, Builder));
} }
/// \brief Matches each method overriden by the given method. This matcher may /// \brief Matches each method overridden by the given method. This matcher may
/// produce multiple matches. /// produce multiple matches.
/// ///
/// Given /// Given
/// \code /// \code
/// class A { virtual void f(); }; /// class A { virtual void f(); };
/// class B : public A { void f(); }; /// class B : public A { void f(); };
/// class C : public B { void f(); }; /// class C : public B { void f(); };
/// \endcode /// \endcode
▲ Show 20 Lines • Show All 1,675 Lines • Show Last 20 Lines

cfe/trunk/include/clang/Analysis/Analyses/ThreadSafetyTraverse.h

Show All 26 Lines
#include <ostream> #include <ostream>
namespace clang { namespace clang {
namespace threadSafety { namespace threadSafety {
namespace til { namespace til {
// Defines an interface used to traverse SExprs. Traversals have been made as // Defines an interface used to traverse SExprs. Traversals have been made as
// generic as possible, and are intended to handle any kind of pass over the // generic as possible, and are intended to handle any kind of pass over the
// AST, e.g. visiters, copying, non-destructive rewriting, destructive // AST, e.g. visitors, copying, non-destructive rewriting, destructive
// (in-place) rewriting, hashing, typing, etc. // (in-place) rewriting, hashing, typing, etc.
// //
// Traversals implement the functional notion of a "fold" operation on SExprs. // Traversals implement the functional notion of a "fold" operation on SExprs.
// Each SExpr class provides a traverse method, which does the following: // Each SExpr class provides a traverse method, which does the following:
// * e->traverse(v): // * e->traverse(v):
// // compute a result r_i for each subexpression e_i // // compute a result r_i for each subexpression e_i
// for (i = 1..n) r_i = v.traverse(e_i); // for (i = 1..n) r_i = v.traverse(e_i);
// // combine results into a result for e, where X is the class of e // // combine results into a result for e, where X is the class of e
▲ Show 20 Lines • Show All 870 Lines • Show Last 20 Lines

cfe/trunk/include/clang/Analysis/CloneDetection.h

Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines
/// First, this class needs several declarations with statement bodies which /// First, this class needs several declarations with statement bodies which
/// can be passed via analyzeCodeBody. Afterwards all statements can be /// can be passed via analyzeCodeBody. Afterwards all statements can be
/// searched for clones by calling findClones with a given list of constraints /// searched for clones by calling findClones with a given list of constraints
/// that should specify the wanted properties of the clones. /// that should specify the wanted properties of the clones.
/// ///
/// The result of findClones can be further constrained with the constrainClones /// The result of findClones can be further constrained with the constrainClones
/// method. /// method.
/// ///
/// This class only searches for clones in exectuable source code /// This class only searches for clones in executable source code
/// (e.g. function bodies). Other clones (e.g. cloned comments or declarations) /// (e.g. function bodies). Other clones (e.g. cloned comments or declarations)
/// are not supported. /// are not supported.
class CloneDetector { class CloneDetector {
public: public:
/// A collection of StmtSequences that share an arbitrary property. /// A collection of StmtSequences that share an arbitrary property.
typedef llvm::SmallVector<StmtSequence, 8> CloneGroup; typedef llvm::SmallVector<StmtSequence, 8> CloneGroup;
▲ Show 20 Lines • Show All 275 Lines • Show Last 20 Lines

cfe/trunk/include/clang/Basic/Attr.td

Show First 20 Lines • Show All 2,655 Lines • ▼ Show 20 Linesdef InitSeg : Attr {
}]; }];
} }
def LoopHint : Attr { def LoopHint : Attr {
/// #pragma clang loop <option> directive /// #pragma clang loop <option> directive
/// vectorize: vectorizes loop operations if State == Enable. /// vectorize: vectorizes loop operations if State == Enable.
/// vectorize_width: vectorize loop operations with width 'Value'. /// vectorize_width: vectorize loop operations with width 'Value'.
/// interleave: interleave multiple loop iterations if State == Enable. /// interleave: interleave multiple loop iterations if State == Enable.
/// interleave_count: interleaves 'Value' loop interations. /// interleave_count: interleaves 'Value' loop iterations.
/// unroll: fully unroll loop if State == Enable. /// unroll: fully unroll loop if State == Enable.
/// unroll_count: unrolls loop 'Value' times. /// unroll_count: unrolls loop 'Value' times.
/// distribute: attempt to distribute loop if State == Enable /// distribute: attempt to distribute loop if State == Enable
/// #pragma unroll <argument> directive /// #pragma unroll <argument> directive
/// <no arg>: fully unrolls loop. /// <no arg>: fully unrolls loop.
/// boolean: fully unrolls loop if State == Enable. /// boolean: fully unrolls loop if State == Enable.
/// expression: unrolls loop 'Value' times. /// expression: unrolls loop 'Value' times.
▲ Show 20 Lines • Show All 207 Lines • Show Last 20 Lines

cfe/trunk/include/clang/Basic/AttrDocs.td

Show First 20 Lines • Show All 2,792 Lines • ▼ Show 20 Lines .. code-block:: c++
}; };
}]; }];
} }
def NoThrowDocs : Documentation { def NoThrowDocs : Documentation {
let Category = DocCatFunction; let Category = DocCatFunction;
let Content = [{ let Content = [{
Clang supports the GNU style ``__attribute__((nothrow))`` and Microsoft style Clang supports the GNU style ``__attribute__((nothrow))`` and Microsoft style
``__declspec(nothrow)`` attribute as an equivilent of `noexcept` on function ``__declspec(nothrow)`` attribute as an equivalent of `noexcept` on function
declarations. This attribute informs the compiler that the annotated function declarations. This attribute informs the compiler that the annotated function
does not throw an exception. This prevents exception-unwinding. This attribute does not throw an exception. This prevents exception-unwinding. This attribute
is particularly useful on functions in the C Standard Library that are is particularly useful on functions in the C Standard Library that are
guaranteed to not throw an exception. guaranteed to not throw an exception.
}]; }];
} }
def InternalLinkageDocs : Documentation { def InternalLinkageDocs : Documentation {
▲ Show 20 Lines • Show All 295 Lines • ▼ Show 20 Linesdef AbiTagsDocs : Documentation {
let Category = DocCatFunction; let Category = DocCatFunction;
let Content = [{ let Content = [{
The ``abi_tag`` attribute can be applied to a function, variable, class or The ``abi_tag`` attribute can be applied to a function, variable, class or
inline namespace declaration to modify the mangled name of the entity. It gives inline namespace declaration to modify the mangled name of the entity. It gives
the ability to distinguish between different versions of the same entity but the ability to distinguish between different versions of the same entity but
with different ABI versions supported. For example, a newer version of a class with different ABI versions supported. For example, a newer version of a class
could have a different set of data members and thus have a different size. Using could have a different set of data members and thus have a different size. Using
the ``abi_tag`` attribute, it is possible to have different mangled names for the ``abi_tag`` attribute, it is possible to have different mangled names for
a global variable of the class type. Therefor, the old code could keep using a global variable of the class type. Therefore, the old code could keep using
the old manged name and the new code will use the new mangled name with tags. the old manged name and the new code will use the new mangled name with tags.
}]; }];
} }
def PreserveMostDocs : Documentation { def PreserveMostDocs : Documentation {
let Category = DocCatCallingConvs; let Category = DocCatCallingConvs;
let Content = [{ let Content = [{
On X86-64 and AArch64 targets, this attribute changes the calling convention of On X86-64 and AArch64 targets, this attribute changes the calling convention of
▲ Show 20 Lines • Show All 183 Lines • Show Last 20 Lines

cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 745 Lines • ▼ Show 20 Lines
def warn_pragma_pack_no_pop_eof : Warning<"unterminated " def warn_pragma_pack_no_pop_eof : Warning<"unterminated "
"'#pragma pack (push, ...)' at end of file">, InGroup<PragmaPack>; "'#pragma pack (push, ...)' at end of file">, InGroup<PragmaPack>;
def note_pragma_pack_here : Note< def note_pragma_pack_here : Note<
"previous '#pragma pack' directive that modifies alignment is here">; "previous '#pragma pack' directive that modifies alignment is here">;
def note_pragma_pack_pop_instead_reset : Note< def note_pragma_pack_pop_instead_reset : Note<
"did you intend to use '#pragma pack (pop)' instead of '#pragma pack()'?">; "did you intend to use '#pragma pack (pop)' instead of '#pragma pack()'?">;
// Follow the Microsoft implementation. // Follow the Microsoft implementation.
def warn_pragma_pack_show : Warning<"value of #pragma pack(show) == %0">; def warn_pragma_pack_show : Warning<"value of #pragma pack(show) == %0">;
def warn_pragma_pack_pop_identifer_and_alignment : Warning< def warn_pragma_pack_pop_identifier_and_alignment : Warning<
"specifying both a name and alignment to 'pop' is undefined">; "specifying both a name and alignment to 'pop' is undefined">;
def warn_pragma_pop_failed : Warning<"#pragma %0(pop, ...) failed: %1">, def warn_pragma_pop_failed : Warning<"#pragma %0(pop, ...) failed: %1">,
InGroup<IgnoredPragmas>; InGroup<IgnoredPragmas>;
def warn_cxx_ms_struct : def warn_cxx_ms_struct :
Warning<"ms_struct may not produce Microsoft-compatible layouts for classes " Warning<"ms_struct may not produce Microsoft-compatible layouts for classes "
"with base classes or virtual functions">, "with base classes or virtual functions">,
DefaultError, InGroup<IncompatibleMSStruct>; DefaultError, InGroup<IncompatibleMSStruct>;
def warn_npot_ms_struct : def warn_npot_ms_struct :
▲ Show 20 Lines • Show All 8,613 Lines • Show Last 20 Lines

cfe/trunk/include/clang/Basic/Version.h

Show All 24 Linesnamespace clang {
/// Clang was built. /// Clang was built.
std::string getClangRepositoryPath(); std::string getClangRepositoryPath();
/// \brief Retrieves the repository path from which LLVM was built. /// \brief Retrieves the repository path from which LLVM was built.
/// ///
/// This supports LLVM residing in a separate repository from clang. /// This supports LLVM residing in a separate repository from clang.
std::string getLLVMRepositoryPath(); std::string getLLVMRepositoryPath();
/// \brief Retrieves the repository revision number (or identifer) from which /// \brief Retrieves the repository revision number (or identifier) from which
/// this Clang was built. /// this Clang was built.
std::string getClangRevision(); std::string getClangRevision();
/// \brief Retrieves the repository revision number (or identifer) from which /// \brief Retrieves the repository revision number (or identifier) from which
/// LLVM was built. /// LLVM was built.
/// ///
/// If Clang and LLVM are in the same repository, this returns the same /// If Clang and LLVM are in the same repository, this returns the same
/// string as getClangRevision. /// string as getClangRevision.
std::string getLLVMRevision(); std::string getLLVMRevision();
/// \brief Retrieves the full repository version that is an amalgamation of /// \brief Retrieves the full repository version that is an amalgamation of
/// the information in getClangRepositoryPath() and getClangRevision(). /// the information in getClangRepositoryPath() and getClangRevision().
Show All 17 Lines

cfe/trunk/include/clang/CodeGen/ConstantInitBuilder.h

Show First 20 Lines • Show All 260 Lines • ▼ Show 20 Linespublic:
}; };
/// Add a placeholder value to the structure. The returned position /// Add a placeholder value to the structure. The returned position
/// can be used to set the value later; it will not be invalidated by /// can be used to set the value later; it will not be invalidated by
/// any intermediate operations except (1) filling the same position or /// any intermediate operations except (1) filling the same position or
/// (2) finishing the entire builder. /// (2) finishing the entire builder.
/// ///
/// This is useful for emitting certain kinds of structure which /// This is useful for emitting certain kinds of structure which
/// contain some sort of summary field, generaly a count, before any /// contain some sort of summary field, generally a count, before any
/// of the data. By emitting a placeholder first, the structure can /// of the data. By emitting a placeholder first, the structure can
/// be emitted eagerly. /// be emitted eagerly.
PlaceholderPosition addPlaceholder() { PlaceholderPosition addPlaceholder() {
assert(!Finished && "cannot add more values after finishing builder"); assert(!Finished && "cannot add more values after finishing builder");
assert(!Frozen && "cannot add values while subbuilder is active"); assert(!Frozen && "cannot add values while subbuilder is active");
Builder.Buffer.push_back(nullptr); Builder.Buffer.push_back(nullptr);
return Builder.Buffer.size() - 1; return Builder.Buffer.size() - 1;
} }
▲ Show 20 Lines • Show All 284 Lines • Show Last 20 Lines

cfe/trunk/include/clang/Driver/Multilib.h

Show First 20 Lines • Show All 144 Lines • ▼ Show 20 Linespublic:
MultilibSet &FilterOut(const char *Regex); MultilibSet &FilterOut(const char *Regex);
/// Add a completed Multilib to the set /// Add a completed Multilib to the set
void push_back(const Multilib &M); void push_back(const Multilib &M);
/// Union this set of multilibs with another /// Union this set of multilibs with another
void combineWith(const MultilibSet &MS); void combineWith(const MultilibSet &MS);
/// Remove all of thie multilibs from the set /// Remove all of the multilibs from the set
void clear() { Multilibs.clear(); } void clear() { Multilibs.clear(); }
iterator begin() { return Multilibs.begin(); } iterator begin() { return Multilibs.begin(); }
const_iterator begin() const { return Multilibs.begin(); } const_iterator begin() const { return Multilibs.begin(); }
iterator end() { return Multilibs.end(); } iterator end() { return Multilibs.end(); }
const_iterator end() const { return Multilibs.end(); } const_iterator end() const { return Multilibs.end(); }
Show All 36 Lines

cfe/trunk/include/clang/Frontend/ASTUnit.h

Show First 20 Lines • Show All 204 Lines • ▼ Show 20 Linesprivate:
/// building the precompiled preamble fails, we won't try again for /// building the precompiled preamble fails, we won't try again for
/// some number of calls. /// some number of calls.
unsigned PreambleRebuildCounter = 0; unsigned PreambleRebuildCounter = 0;
/// \brief Cache pairs "filename - source location" /// \brief Cache pairs "filename - source location"
/// ///
/// Cache contains only source locations from preamble so it is /// Cache contains only source locations from preamble so it is
/// guaranteed that they stay valid when the SourceManager is recreated. /// guaranteed that they stay valid when the SourceManager is recreated.
/// This cache is used when loading preambule to increase performance /// This cache is used when loading preamble to increase performance
/// of that loading. It must be cleared when preamble is recreated. /// of that loading. It must be cleared when preamble is recreated.
llvm::StringMap<SourceLocation> PreambleSrcLocCache; llvm::StringMap<SourceLocation> PreambleSrcLocCache;
/// The contents of the preamble. /// The contents of the preamble.
llvm::Optional<PrecompiledPreamble> Preamble; llvm::Optional<PrecompiledPreamble> Preamble;
/// \brief When non-NULL, this is the buffer used to store the contents of /// \brief When non-NULL, this is the buffer used to store the contents of
/// the main file when it has been padded for use with the precompiled /// the main file when it has been padded for use with the precompiled
▲ Show 20 Lines • Show All 654 Lines • Show Last 20 Lines

cfe/trunk/include/clang/Frontend/PrecompiledPreamble.h

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Lines bool CanReuse(const CompilerInvocation &Invocation,
vfs::FileSystem *VFS) const; vfs::FileSystem *VFS) const;
/// Changes options inside \p CI to use PCH from this preamble. Also remaps /// Changes options inside \p CI to use PCH from this preamble. Also remaps
/// main file to \p MainFileBuffer and updates \p VFS to ensure the preamble /// main file to \p MainFileBuffer and updates \p VFS to ensure the preamble
/// is accessible. /// is accessible.
/// Requires that CanReuse() is true. /// Requires that CanReuse() is true.
/// For in-memory preambles, PrecompiledPreamble instance continues to own the /// For in-memory preambles, PrecompiledPreamble instance continues to own the
/// MemoryBuffer with the Preamble after this method returns. The caller is /// MemoryBuffer with the Preamble after this method returns. The caller is
/// reponsible for making sure the PrecompiledPreamble instance outlives the /// responsible for making sure the PrecompiledPreamble instance outlives the
/// compiler run and the AST that will be using the PCH. /// compiler run and the AST that will be using the PCH.
void AddImplicitPreamble(CompilerInvocation &CI, void AddImplicitPreamble(CompilerInvocation &CI,
IntrusiveRefCntPtr<vfs::FileSystem> &VFS, IntrusiveRefCntPtr<vfs::FileSystem> &VFS,
llvm::MemoryBuffer *MainFileBuffer) const; llvm::MemoryBuffer *MainFileBuffer) const;
/// Configure \p CI to use this preamble. /// Configure \p CI to use this preamble.
/// Like AddImplicitPreamble, but doesn't assume CanReuse() is true. /// Like AddImplicitPreamble, but doesn't assume CanReuse() is true.
/// If this preamble does not match the file, it may parse differently. /// If this preamble does not match the file, it may parse differently.
▲ Show 20 Lines • Show All 192 Lines • Show Last 20 Lines

cfe/trunk/include/clang/Lex/HeaderSearch.h

Show First 20 Lines • Show All 271 Lines • ▼ Show 20 Linespublic:
FileManager &getFileMgr() const { return FileMgr; } FileManager &getFileMgr() const { return FileMgr; }
/// \brief Interface for setting the file search paths. /// \brief Interface for setting the file search paths.
void SetSearchPaths(const std::vector<DirectoryLookup> &dirs, void SetSearchPaths(const std::vector<DirectoryLookup> &dirs,
unsigned angledDirIdx, unsigned systemDirIdx, unsigned angledDirIdx, unsigned systemDirIdx,
bool noCurDirSearch) { bool noCurDirSearch) {
assert(angledDirIdx <= systemDirIdx && systemDirIdx <= dirs.size() && assert(angledDirIdx <= systemDirIdx && systemDirIdx <= dirs.size() &&
"Directory indicies are unordered"); "Directory indices are unordered");
SearchDirs = dirs; SearchDirs = dirs;
AngledDirIdx = angledDirIdx; AngledDirIdx = angledDirIdx;
SystemDirIdx = systemDirIdx; SystemDirIdx = systemDirIdx;
NoCurDirSearch = noCurDirSearch; NoCurDirSearch = noCurDirSearch;
//LookupFileCache.clear(); //LookupFileCache.clear();
} }
/// \brief Add an additional search path. /// \brief Add an additional search path.
▲ Show 20 Lines • Show All 479 Lines • Show Last 20 Lines

cfe/trunk/include/clang/Lex/ModuleMap.h

Show First 20 Lines • Show All 193 Lines • ▼ Show 20 Linesprivate:
/// that is generated from the umbrella header. /// that is generated from the umbrella header.
/// ///
/// This mapping is used to map headers that haven't explicitly been named /// This mapping is used to map headers that haven't explicitly been named
/// in the module map over to the module that includes them via its umbrella /// in the module map over to the module that includes them via its umbrella
/// header. /// header.
llvm::DenseMap<const DirectoryEntry *, Module *> UmbrellaDirs; llvm::DenseMap<const DirectoryEntry *, Module *> UmbrellaDirs;
/// \brief A generation counter that is used to test whether modules of the /// \brief A generation counter that is used to test whether modules of the
/// same name may shadow or are illegal redefintions. /// same name may shadow or are illegal redefinitions.
/// ///
/// Modules from earlier scopes may shadow modules from later ones. /// Modules from earlier scopes may shadow modules from later ones.
/// Modules from the same scope may not have the same name. /// Modules from the same scope may not have the same name.
unsigned CurrentModuleScopeID = 0; unsigned CurrentModuleScopeID = 0;
llvm::DenseMap<Module *, unsigned> ModuleScopeIDs; llvm::DenseMap<Module *, unsigned> ModuleScopeIDs;
/// \brief The set of attributes that can be attached to a module. /// \brief The set of attributes that can be attached to a module.
▲ Show 20 Lines • Show All 446 Lines • Show Last 20 Lines

cfe/trunk/include/clang/Lex/TokenLexer.h

Show First 20 Lines • Show All 192 Lines • ▼ Show 20 Linesprivate:
/// them into a string. \p VCtx is used to determine which token represents /// them into a string. \p VCtx is used to determine which token represents
/// the first __VA_OPT__ replacement token. /// the first __VA_OPT__ replacement token.
/// ///
/// \param[in,out] ReplacementToks - Contains the current Replacement Tokens /// \param[in,out] ReplacementToks - Contains the current Replacement Tokens
/// (prior to rescanning and token pasting), the tail end of which represents /// (prior to rescanning and token pasting), the tail end of which represents
/// the tokens just expanded through __VA_OPT__ processing. These (sub) /// the tokens just expanded through __VA_OPT__ processing. These (sub)
/// sequence of tokens are folded into one stringified token. /// sequence of tokens are folded into one stringified token.
/// ///
/// \param[in] VCtx - contains relevent contextual information about the /// \param[in] VCtx - contains relevant contextual information about the
/// state of the tokens around and including the __VA_OPT__ token, necessary /// state of the tokens around and including the __VA_OPT__ token, necessary
/// for stringification. /// for stringification.
void stringifyVAOPTContents(SmallVectorImpl<Token> &ReplacementToks, void stringifyVAOPTContents(SmallVectorImpl<Token> &ReplacementToks,
const VAOptExpansionContext &VCtx, const VAOptExpansionContext &VCtx,
SourceLocation VAOPTClosingParenLoc); SourceLocation VAOPTClosingParenLoc);
/// Expand the arguments of a function-like macro so that we can quickly /// Expand the arguments of a function-like macro so that we can quickly
/// return preexpanded tokens from Tokens. /// return preexpanded tokens from Tokens.
Show All 35 Lines

cfe/trunk/include/clang/Parse/Parser.h

Show First 20 Lines • Show All 1,091 Lines • ▼ Show 20 Lines struct LateParsedMethodDeclaration : public LateParsedDeclaration {
Parser* Self; Parser* Self;
/// Method - The method declaration. /// Method - The method declaration.
Decl *Method; Decl *Method;
/// \brief Whether this member function had an associated template /// \brief Whether this member function had an associated template
/// scope. When true, D is a template declaration. /// scope. When true, D is a template declaration.
/// othewise, it is a member function declaration. /// otherwise, it is a member function declaration.
bool TemplateScope; bool TemplateScope;
/// DefaultArgs - Contains the parameters of the function and /// DefaultArgs - Contains the parameters of the function and
/// their default arguments. At least one of the parameters will /// their default arguments. At least one of the parameters will
/// have a default argument, but all of the parameters of the /// have a default argument, but all of the parameters of the
/// method will be stored so that they can be reintroduced into /// method will be stored so that they can be reintroduced into
/// scope at the appropriate times. /// scope at the appropriate times.
SmallVector<LateParsedDefaultArgument, 8> DefaultArgs; SmallVector<LateParsedDefaultArgument, 8> DefaultArgs;
Show All 39 Lines ParsingClass(Decl *TagOrTemplate, bool TopLevelClass, bool IsInterface)
IsInterface(IsInterface), TagOrTemplate(TagOrTemplate) { } IsInterface(IsInterface), TagOrTemplate(TagOrTemplate) { }
/// \brief Whether this is a "top-level" class, meaning that it is /// \brief Whether this is a "top-level" class, meaning that it is
/// not nested within another class. /// not nested within another class.
bool TopLevelClass : 1; bool TopLevelClass : 1;
/// \brief Whether this class had an associated template /// \brief Whether this class had an associated template
/// scope. When true, TagOrTemplate is a template declaration; /// scope. When true, TagOrTemplate is a template declaration;
/// othewise, it is a tag declaration. /// otherwise, it is a tag declaration.
bool TemplateScope : 1; bool TemplateScope : 1;
/// \brief Whether this class is an __interface. /// \brief Whether this class is an __interface.
bool IsInterface : 1; bool IsInterface : 1;
/// \brief The class or class template whose definition we are parsing. /// \brief The class or class template whose definition we are parsing.
Decl *TagOrTemplate; Decl *TagOrTemplate;
▲ Show 20 Lines • Show All 1,690 Lines • Show Last 20 Lines

cfe/trunk/include/clang/Sema/AttributeList.h

Show First 20 Lines • Show All 316 Lines • ▼ Show 20 Lines AttributeList(IdentifierInfo *attrName, SourceRange attrRange,
Invalid(false), UsedAsTypeAttr(false), IsAvailability(false), Invalid(false), UsedAsTypeAttr(false), IsAvailability(false),
IsTypeTagForDatatype(false), IsProperty(true), HasParsedType(false), IsTypeTagForDatatype(false), IsProperty(true), HasParsedType(false),
HasProcessingCache(false) { HasProcessingCache(false) {
new (&getPropertyDataBuffer()) PropertyData(getterId, setterId); new (&getPropertyDataBuffer()) PropertyData(getterId, setterId);
AttrKind = getKind(getName(), getScopeName(), syntaxUsed); AttrKind = getKind(getName(), getScopeName(), syntaxUsed);
} }
/// Type tag information is stored immediately following the arguments, if /// Type tag information is stored immediately following the arguments, if
/// any, at the end of the object. They are mutually exlusive with /// any, at the end of the object. They are mutually exclusive with
/// availability slots. /// availability slots.
TypeTagForDatatypeData &getTypeTagForDatatypeDataSlot() { TypeTagForDatatypeData &getTypeTagForDatatypeDataSlot() {
return *reinterpret_cast<TypeTagForDatatypeData*>(getArgsBuffer()+NumArgs); return *reinterpret_cast<TypeTagForDatatypeData*>(getArgsBuffer()+NumArgs);
} }
const TypeTagForDatatypeData &getTypeTagForDatatypeDataSlot() const { const TypeTagForDatatypeData &getTypeTagForDatatypeDataSlot() const {
return *reinterpret_cast<const TypeTagForDatatypeData*>(getArgsBuffer() return *reinterpret_cast<const TypeTagForDatatypeData*>(getArgsBuffer()
+ NumArgs); + NumArgs);
} }
▲ Show 20 Lines • Show All 603 Lines • Show Last 20 Lines

cfe/trunk/include/clang/Sema/TypoCorrection.h

Show First 20 Lines • Show All 285 Lines • ▼ Show 20 Linespublic:
explicit CorrectionCandidateCallback(IdentifierInfo *Typo = nullptr, explicit CorrectionCandidateCallback(IdentifierInfo *Typo = nullptr,
NestedNameSpecifier *TypoNNS = nullptr) NestedNameSpecifier *TypoNNS = nullptr)
: Typo(Typo), TypoNNS(TypoNNS) {} : Typo(Typo), TypoNNS(TypoNNS) {}
virtual ~CorrectionCandidateCallback() = default; virtual ~CorrectionCandidateCallback() = default;
/// \brief Simple predicate used by the default RankCandidate to /// \brief Simple predicate used by the default RankCandidate to
/// determine whether to return an edit distance of 0 or InvalidDistance. /// determine whether to return an edit distance of 0 or InvalidDistance.
/// This can be overrided by validators that only need to determine if a /// This can be overridden by validators that only need to determine if a
/// candidate is viable, without ranking potentially viable candidates. /// candidate is viable, without ranking potentially viable candidates.
/// Only ValidateCandidate or RankCandidate need to be overriden by a /// Only ValidateCandidate or RankCandidate need to be overridden by a
/// callback wishing to check the viability of correction candidates. /// callback wishing to check the viability of correction candidates.
/// The default predicate always returns true if the candidate is not a type /// The default predicate always returns true if the candidate is not a type
/// name or keyword, true for types if WantTypeSpecifiers is true, and true /// name or keyword, true for types if WantTypeSpecifiers is true, and true
/// for keywords if WantTypeSpecifiers, WantExpressionKeywords, /// for keywords if WantTypeSpecifiers, WantExpressionKeywords,
/// WantCXXNamedCasts, WantRemainingKeywords, or WantObjCSuper is true. /// WantCXXNamedCasts, WantRemainingKeywords, or WantObjCSuper is true.
virtual bool ValidateCandidate(const TypoCorrection &candidate); virtual bool ValidateCandidate(const TypoCorrection &candidate);
/// \brief Method used by Sema::CorrectTypo to assign an "edit distance" rank /// \brief Method used by Sema::CorrectTypo to assign an "edit distance" rank
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

cfe/trunk/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h

Show First 20 Lines • Show All 361 Lines • ▼ Show 20 Linespublic:
/// interpreted as true and the "false" string is interpreted as false. /// interpreted as true and the "false" string is interpreted as false.
/// ///
/// If an option value is not provided, returns the given \p DefaultVal. /// If an option value is not provided, returns the given \p DefaultVal.
/// @param [in] Name Name for option to retrieve. /// @param [in] Name Name for option to retrieve.
/// @param [in] DefaultVal Default value returned if no such option was /// @param [in] DefaultVal Default value returned if no such option was
/// specified. /// specified.
/// @param [in] C The optional checker parameter that can be used to restrict /// @param [in] C The optional checker parameter that can be used to restrict
/// the search to the options of this particular checker (and its parents /// the search to the options of this particular checker (and its parents
/// dependening on search mode). /// depending on search mode).
/// @param [in] SearchInParents If set to true and the searched option was not /// @param [in] SearchInParents If set to true and the searched option was not
/// specified for the given checker the options for the parent packages will /// specified for the given checker the options for the parent packages will
/// be searched as well. The inner packages take precedence over the outer /// be searched as well. The inner packages take precedence over the outer
/// ones. /// ones.
bool getBooleanOption(StringRef Name, bool DefaultVal, bool getBooleanOption(StringRef Name, bool DefaultVal,
const ento::CheckerBase *C = nullptr, const ento::CheckerBase *C = nullptr,
bool SearchInParents = false); bool SearchInParents = false);
/// Variant that accepts a Optional value to cache the result. /// Variant that accepts a Optional value to cache the result.
/// ///
/// @param [in,out] V Return value storage, returned if parameter contains /// @param [in,out] V Return value storage, returned if parameter contains
/// an existing valid option, else it is used to store a return value /// an existing valid option, else it is used to store a return value
/// @param [in] Name Name for option to retrieve. /// @param [in] Name Name for option to retrieve.
/// @param [in] DefaultVal Default value returned if no such option was /// @param [in] DefaultVal Default value returned if no such option was
/// specified. /// specified.
/// @param [in] C The optional checker parameter that can be used to restrict /// @param [in] C The optional checker parameter that can be used to restrict
/// the search to the options of this particular checker (and its parents /// the search to the options of this particular checker (and its parents
/// dependening on search mode). /// depending on search mode).
/// @param [in] SearchInParents If set to true and the searched option was not /// @param [in] SearchInParents If set to true and the searched option was not
/// specified for the given checker the options for the parent packages will /// specified for the given checker the options for the parent packages will
/// be searched as well. The inner packages take precedence over the outer /// be searched as well. The inner packages take precedence over the outer
/// ones. /// ones.
bool getBooleanOption(Optional<bool> &V, StringRef Name, bool DefaultVal, bool getBooleanOption(Optional<bool> &V, StringRef Name, bool DefaultVal,
const ento::CheckerBase *C = nullptr, const ento::CheckerBase *C = nullptr,
bool SearchInParents = false); bool SearchInParents = false);
/// Interprets an option's string value as an integer value. /// Interprets an option's string value as an integer value.
/// ///
/// If an option value is not provided, returns the given \p DefaultVal. /// If an option value is not provided, returns the given \p DefaultVal.
/// @param [in] Name Name for option to retrieve. /// @param [in] Name Name for option to retrieve.
/// @param [in] DefaultVal Default value returned if no such option was /// @param [in] DefaultVal Default value returned if no such option was
/// specified. /// specified.
/// @param [in] C The optional checker parameter that can be used to restrict /// @param [in] C The optional checker parameter that can be used to restrict
/// the search to the options of this particular checker (and its parents /// the search to the options of this particular checker (and its parents
/// dependening on search mode). /// depending on search mode).
/// @param [in] SearchInParents If set to true and the searched option was not /// @param [in] SearchInParents If set to true and the searched option was not
/// specified for the given checker the options for the parent packages will /// specified for the given checker the options for the parent packages will
/// be searched as well. The inner packages take precedence over the outer /// be searched as well. The inner packages take precedence over the outer
/// ones. /// ones.
int getOptionAsInteger(StringRef Name, int DefaultVal, int getOptionAsInteger(StringRef Name, int DefaultVal,
const ento::CheckerBase *C = nullptr, const ento::CheckerBase *C = nullptr,
bool SearchInParents = false); bool SearchInParents = false);
/// Query an option's string value. /// Query an option's string value.
/// ///
/// If an option value is not provided, returns the given \p DefaultVal. /// If an option value is not provided, returns the given \p DefaultVal.
/// @param [in] Name Name for option to retrieve. /// @param [in] Name Name for option to retrieve.
/// @param [in] DefaultVal Default value returned if no such option was /// @param [in] DefaultVal Default value returned if no such option was
/// specified. /// specified.
/// @param [in] C The optional checker parameter that can be used to restrict /// @param [in] C The optional checker parameter that can be used to restrict
/// the search to the options of this particular checker (and its parents /// the search to the options of this particular checker (and its parents
/// dependening on search mode). /// depending on search mode).
/// @param [in] SearchInParents If set to true and the searched option was not /// @param [in] SearchInParents If set to true and the searched option was not
/// specified for the given checker the options for the parent packages will /// specified for the given checker the options for the parent packages will
/// be searched as well. The inner packages take precedence over the outer /// be searched as well. The inner packages take precedence over the outer
/// ones. /// ones.
StringRef getOptionAsString(StringRef Name, StringRef DefaultVal, StringRef getOptionAsString(StringRef Name, StringRef DefaultVal,
const ento::CheckerBase *C = nullptr, const ento::CheckerBase *C = nullptr,
bool SearchInParents = false); bool SearchInParents = false);
▲ Show 20 Lines • Show All 255 Lines • Show Last 20 Lines

cfe/trunk/include/clang/StaticAnalyzer/Core/BugReporter/BugType.h

//===--- BugType.h - Bug Information Desciption ----------------*- C++ -*-===// //===--- BugType.h - Bug Information Description ---------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
public: public:
const static unsigned NoArgRequirement = std::numeric_limits<unsigned>::max(); const static unsigned NoArgRequirement = std::numeric_limits<unsigned>::max();
/// \brief Constructs a CallDescription object. /// \brief Constructs a CallDescription object.
/// ///
/// @param FuncName The name of the function that will be matched. /// @param FuncName The name of the function that will be matched.
/// ///
/// @param RequiredArgs The number of arguments that is expected to match a /// @param RequiredArgs The number of arguments that is expected to match a
/// call. Omit this parameter to match every occurance of call with a given /// call. Omit this parameter to match every occurrence of call with a given
/// name regardless the number of arguments. /// name regardless the number of arguments.
CallDescription(StringRef FuncName, unsigned RequiredArgs = NoArgRequirement) CallDescription(StringRef FuncName, unsigned RequiredArgs = NoArgRequirement)
: FuncName(FuncName), RequiredArgs(RequiredArgs) {} : FuncName(FuncName), RequiredArgs(RequiredArgs) {}
/// \brief Get the name of the function that this object matches. /// \brief Get the name of the function that this object matches.
StringRef getFunctionName() const { return FuncName; } StringRef getFunctionName() const { return FuncName; }
}; };
▲ Show 20 Lines • Show All 1,044 Lines • Show Last 20 Lines

cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h

Show First 20 Lines • Show All 235 Lines • ▼ Show 20 Linesprotected:
bool Finalized; bool Finalized;
bool HasGeneratedNodes = false; bool HasGeneratedNodes = false;
/// \brief The frontier set - a set of nodes which need to be propagated after /// \brief The frontier set - a set of nodes which need to be propagated after
/// the builder dies. /// the builder dies.
ExplodedNodeSet &Frontier; ExplodedNodeSet &Frontier;
/// Checkes if the results are ready. /// Checks if the results are ready.
virtual bool checkResults() { virtual bool checkResults() {
return Finalized; return Finalized;
} }
bool hasNoSinksInFrontier() { bool hasNoSinksInFrontier() {
for (const auto I : Frontier) for (const auto I : Frontier)
if (I->isSink()) if (I->isSink())
return false; return false;
▲ Show 20 Lines • Show All 323 Lines • Show Last 20 Lines

cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h

Show First 20 Lines • Show All 504 Lines • ▼ Show 20 Linesprivate:
static bool isKind(const NonLoc& V) { static bool isKind(const NonLoc& V) {
return V.getSubKind() == LazyCompoundValKind; return V.getSubKind() == LazyCompoundValKind;
} }
}; };
/// \brief Value representing pointer-to-member. /// \brief Value representing pointer-to-member.
/// ///
/// This value is qualified as NonLoc because neither loading nor storing /// This value is qualified as NonLoc because neither loading nor storing
/// operations are aplied to it. Instead, the analyzer uses the L-value coming /// operations are applied to it. Instead, the analyzer uses the L-value coming
/// from pointer-to-member applied to an object. /// from pointer-to-member applied to an object.
/// This SVal is represented by a DeclaratorDecl which can be a member function /// This SVal is represented by a DeclaratorDecl which can be a member function
/// pointer or a member data pointer and a list of CXXBaseSpecifiers. This list /// pointer or a member data pointer and a list of CXXBaseSpecifiers. This list
/// is required to accumulate the pointer-to-member cast history to figure out /// is required to accumulate the pointer-to-member cast history to figure out
/// the correct subobject field. /// the correct subobject field.
class PointerToMember : public NonLoc { class PointerToMember : public NonLoc {
friend class ento::SValBuilder; friend class ento::SValBuilder;
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

cfe/trunk/include/clang/Tooling/FileMatchTrie.h

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Linespublic:
/// \brief Insert a new absolute path. Relative paths are ignored. /// \brief Insert a new absolute path. Relative paths are ignored.
void insert(StringRef NewPath); void insert(StringRef NewPath);
/// \brief Finds the corresponding file in this trie. /// \brief Finds the corresponding file in this trie.
/// ///
/// Returns file name stored in this trie that is equivalent to 'FileName' /// Returns file name stored in this trie that is equivalent to 'FileName'
/// according to 'Comparator', if it can be uniquely identified. If there /// according to 'Comparator', if it can be uniquely identified. If there
/// are no matches an empty \c StringRef is returned. If there are ambigious /// are no matches an empty \c StringRef is returned. If there are ambiguous
/// matches, an empty \c StringRef is returned and a corresponding message /// matches, an empty \c StringRef is returned and a corresponding message
/// written to 'Error'. /// written to 'Error'.
StringRef findEquivalent(StringRef FileName, StringRef findEquivalent(StringRef FileName,
raw_ostream &Error) const; raw_ostream &Error) const;
private: private:
FileMatchTrieNode *Root; FileMatchTrieNode *Root;
std::unique_ptr<PathComparator> Comparator; std::unique_ptr<PathComparator> Comparator;
}; };
} // namespace tooling } // namespace tooling
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLING_FILEMATCHTRIE_H #endif // LLVM_CLANG_TOOLING_FILEMATCHTRIE_H

cfe/trunk/include/clang/Tooling/Refactoring/RefactoringActionRule.h

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines
/// A refactoring action rule is a wrapper class around a specific refactoring /// A refactoring action rule is a wrapper class around a specific refactoring
/// action rule (SourceChangeRefactoringRule, etc) that, in addition to invoking /// action rule (SourceChangeRefactoringRule, etc) that, in addition to invoking
/// the action, describes the requirements that determine when the action can be /// the action, describes the requirements that determine when the action can be
/// initiated. /// initiated.
class RefactoringActionRule : public RefactoringActionRuleBase { class RefactoringActionRule : public RefactoringActionRuleBase {
public: public:
/// Returns true when the rule has a source selection requirement that has /// Returns true when the rule has a source selection requirement that has
/// to be fullfilled before refactoring can be performed. /// to be fulfilled before refactoring can be performed.
virtual bool hasSelectionRequirement() = 0; virtual bool hasSelectionRequirement() = 0;
/// Traverses each refactoring option used by the rule and invokes the /// Traverses each refactoring option used by the rule and invokes the
/// \c visit callback in the consumer for each option. /// \c visit callback in the consumer for each option.
/// ///
/// Options are visited in the order of use, e.g. if a rule has two /// Options are visited in the order of use, e.g. if a rule has two
/// requirements that use options, the options from the first requirement /// requirements that use options, the options from the first requirement
/// are visited before the options in the second requirement. /// are visited before the options in the second requirement.
virtual void visitRefactoringOptions(RefactoringOptionVisitor &Visitor) = 0; virtual void visitRefactoringOptions(RefactoringOptionVisitor &Visitor) = 0;
}; };
} // end namespace tooling } // end namespace tooling
} // end namespace clang } // end namespace clang
#endif // LLVM_CLANG_TOOLING_REFACTOR_REFACTORING_ACTION_RULE_H #endif // LLVM_CLANG_TOOLING_REFACTOR_REFACTORING_ACTION_RULE_H

cfe/trunk/include/clang/Tooling/Refactoring/RefactoringResultConsumer.h

Show All 20 Lines
/// An abstract interface that consumes the various refactoring results that can /// An abstract interface that consumes the various refactoring results that can
/// be produced by refactoring actions. /// be produced by refactoring actions.
/// ///
/// A valid refactoring result must be handled by a \c handle method. /// A valid refactoring result must be handled by a \c handle method.
class RefactoringResultConsumer { class RefactoringResultConsumer {
public: public:
virtual ~RefactoringResultConsumer() {} virtual ~RefactoringResultConsumer() {}
/// Handles an initation or an invication error. An initiation error typically /// Handles an initiation or an invication error. An initiation error typically
/// has a \c DiagnosticError payload that describes why initation failed. /// has a \c DiagnosticError payload that describes why initiation failed.
virtual void handleError(llvm::Error Err) = 0; virtual void handleError(llvm::Error Err) = 0;
/// Handles the source replacements that are produced by a refactoring action. /// Handles the source replacements that are produced by a refactoring action.
virtual void handle(AtomicChanges SourceReplacements) { virtual void handle(AtomicChanges SourceReplacements) {
defaultResultHandler(); defaultResultHandler();
} }
/// Handles the symbol occurrences that are found by an interactive /// Handles the symbol occurrences that are found by an interactive
Show All 14 Lines

cfe/trunk/include/clang/Tooling/Refactoring/Rename/RenamingAction.h

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines
private: private:
QualifiedRenameRule(const NamedDecl *ND, QualifiedRenameRule(const NamedDecl *ND,
std::string NewQualifiedName) std::string NewQualifiedName)
: ND(ND), NewQualifiedName(std::move(NewQualifiedName)) {} : ND(ND), NewQualifiedName(std::move(NewQualifiedName)) {}
Expected<AtomicChanges> Expected<AtomicChanges>
createSourceReplacements(RefactoringRuleContext &Context) override; createSourceReplacements(RefactoringRuleContext &Context) override;
// A NamedDecl which indentifies the symbol being renamed. // A NamedDecl which identifies the symbol being renamed.
const NamedDecl *ND; const NamedDecl *ND;
// The new qualified name to change the symbol to. // The new qualified name to change the symbol to.
std::string NewQualifiedName; std::string NewQualifiedName;
}; };
/// Returns source replacements that correspond to the rename of the given /// Returns source replacements that correspond to the rename of the given
/// symbol occurrences. /// symbol occurrences.
llvm::Expected<std::vector<AtomicChange>> llvm::Expected<std::vector<AtomicChange>>
Show All 29 Lines

cfe/trunk/include/clang/Tooling/Refactoring/Rename/SymbolName.h

Show All 15 Lines
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
namespace clang { namespace clang {
namespace tooling { namespace tooling {
/// A name of a symbol. /// A name of a symbol.
/// ///
/// Symbol's name can be composed of multiple strings. For example, Objective-C /// Symbol's name can be composed of multiple strings. For example, Objective-C
/// methods can contain multiple argument lables: /// methods can contain multiple argument labels:
/// ///
/// \code /// \code
/// - (void) myMethodNamePiece: (int)x anotherNamePieces:(int)y; /// - (void) myMethodNamePiece: (int)x anotherNamePieces:(int)y;
/// // ^~ string 0 ~~~~~ ^~ string 1 ~~~~~ /// // ^~ string 0 ~~~~~ ^~ string 1 ~~~~~
/// \endcode /// \endcode
class SymbolName { class SymbolName {
public: public:
explicit SymbolName(StringRef Name) { explicit SymbolName(StringRef Name) {
Show All 17 Lines

cfe/trunk/include/clang/Tooling/Tooling.h

Show First 20 Lines • Show All 333 Lines • ▼ Show 20 Linespublic:
/// \brief Clear the command line arguments adjuster chain. /// \brief Clear the command line arguments adjuster chain.
void clearArgumentsAdjusters(); void clearArgumentsAdjusters();
/// Runs an action over all files specified in the command line. /// Runs an action over all files specified in the command line.
/// ///
/// \param Action Tool action. /// \param Action Tool action.
/// ///
/// \returns 0 on success; 1 if any error occured; 2 if there is no error but /// \returns 0 on success; 1 if any error occurred; 2 if there is no error but
/// some files are skipped due to missing compile commands. /// some files are skipped due to missing compile commands.
int run(ToolAction *Action); int run(ToolAction *Action);
/// \brief Create an AST for each file specified in the command line and /// \brief Create an AST for each file specified in the command line and
/// append them to ASTs. /// append them to ASTs.
int buildASTs(std::vector<std::unique_ptr<ASTUnit>> &ASTs); int buildASTs(std::vector<std::unique_ptr<ASTUnit>> &ASTs);
/// \brief Returns the file manager used in the tool. /// \brief Returns the file manager used in the tool.
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

cfe/trunk/lib/ARCMigrate/ObjCMT.cpp

Show First 20 Lines • Show All 1,095 Lines • ▼ Show 20 Lines
} }
static bool MatchTwoAttributeLists(const AttrVec &Attrs1, const AttrVec &Attrs2, static bool MatchTwoAttributeLists(const AttrVec &Attrs1, const AttrVec &Attrs2,
bool &AvailabilityArgsMatch) { bool &AvailabilityArgsMatch) {
// This list is very small, so this need not be optimized. // This list is very small, so this need not be optimized.
for (unsigned i = 0, e = Attrs1.size(); i != e; i++) { for (unsigned i = 0, e = Attrs1.size(); i != e; i++) {
bool match = false; bool match = false;
for (unsigned j = 0, f = Attrs2.size(); j != f; j++) { for (unsigned j = 0, f = Attrs2.size(); j != f; j++) {
// Matching attribute kind only. Except for Availabilty attributes, // Matching attribute kind only. Except for Availability attributes,
// we are not getting into details of the attributes. For all practical purposes // we are not getting into details of the attributes. For all practical purposes
// this is sufficient. // this is sufficient.
if (Attrs1[i]->getKind() == Attrs2[j]->getKind()) { if (Attrs1[i]->getKind() == Attrs2[j]->getKind()) {
if (AvailabilityArgsMatch) if (AvailabilityArgsMatch)
AvailabilityArgsMatch = AvailabilityAttrsMatch(Attrs1[i], Attrs2[j]); AvailabilityArgsMatch = AvailabilityAttrsMatch(Attrs1[i], Attrs2[j]);
match = true; match = true;
break; break;
} }
▲ Show 20 Lines • Show All 1,157 Lines • Show Last 20 Lines

cfe/trunk/lib/AST/ASTContext.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,457 Lines • ▼ Show 20 Linesbool ASTContext::QIdProtocolsAdoptObjCObjectProtocols(QualType QT,
if (!OPT) if (!OPT)
return false; return false;
if (!IDecl->hasDefinition()) if (!IDecl->hasDefinition())
return false; return false;
llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocols; llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocols;
CollectInheritedProtocols(IDecl, InheritedProtocols); CollectInheritedProtocols(IDecl, InheritedProtocols);
if (InheritedProtocols.empty()) if (InheritedProtocols.empty())
return false; return false;
// Check that if every protocol in list of id<plist> conforms to a protcol // Check that if every protocol in list of id<plist> conforms to a protocol
// of IDecl's, then bridge casting is ok. // of IDecl's, then bridge casting is ok.
bool Conforms = false; bool Conforms = false;
for (auto *Proto : OPT->quals()) { for (auto *Proto : OPT->quals()) {
Conforms = false; Conforms = false;
for (auto *PI : InheritedProtocols) { for (auto *PI : InheritedProtocols) {
if (ProtocolCompatibleWithProtocol(Proto, PI)) { if (ProtocolCompatibleWithProtocol(Proto, PI)) {
Conforms = true; Conforms = true;
break; break;
▲ Show 20 Lines • Show All 2,065 Lines • ▼ Show 20 Lines case Type::ObjCObject: {
if (Ty->isObjCIdType()) { if (Ty->isObjCIdType()) {
S += "{objc_object=}"; S += "{objc_object=}";
return; return;
} }
else if (Ty->isObjCClassType()) { else if (Ty->isObjCClassType()) {
S += "{objc_class=}"; S += "{objc_class=}";
return; return;
} }
// TODO: Double check to make sure this intentially falls through. // TODO: Double check to make sure this intentionally falls through.
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
} }
case Type::ObjCInterface: { case Type::ObjCInterface: {
// Ignore protocol qualifiers when mangling at this level. // Ignore protocol qualifiers when mangling at this level.
// @encode(class_name) // @encode(class_name)
ObjCInterfaceDecl *OI = T->castAs<ObjCObjectType>()->getInterface(); ObjCInterfaceDecl *OI = T->castAs<ObjCObjectType>()->getInterface();
S += '{'; S += '{';
Show All 22 Lines case Type::ObjCObjectPointer: {
if (OPT->isObjCIdType()) { if (OPT->isObjCIdType()) {
S += '@'; S += '@';
return; return;
} }
if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) { if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) {
// FIXME: Consider if we need to output qualifiers for 'Class<p>'. // FIXME: Consider if we need to output qualifiers for 'Class<p>'.
// Since this is a binary compatibility issue, need to consult with runtime // Since this is a binary compatibility issue, need to consult with runtime
// folks. Fortunately, this is a *very* obsure construct. // folks. Fortunately, this is a *very* obscure construct.
S += '#'; S += '#';
return; return;
} }
if (OPT->isObjCQualifiedIdType()) { if (OPT->isObjCQualifiedIdType()) {
getObjCEncodingForTypeImpl(getObjCIdType(), S, getObjCEncodingForTypeImpl(getObjCIdType(), S,
ExpandPointedToStructures, ExpandPointedToStructures,
ExpandStructures, FD); ExpandStructures, FD);
▲ Show 20 Lines • Show All 3,387 Lines • Show Last 20 Lines

cfe/trunk/lib/AST/DeclCXX.cpp

Show First 20 Lines • Show All 1,759 Lines • ▼ Show 20 Lines if (mayBeAbstract()) {
bool Done = false; bool Done = false;
for (CXXFinalOverriderMap::iterator M = FinalOverriders->begin(), for (CXXFinalOverriderMap::iterator M = FinalOverriders->begin(),
MEnd = FinalOverriders->end(); MEnd = FinalOverriders->end();
M != MEnd && !Done; ++M) { M != MEnd && !Done; ++M) {
for (OverridingMethods::iterator SO = M->second.begin(), for (OverridingMethods::iterator SO = M->second.begin(),
SOEnd = M->second.end(); SOEnd = M->second.end();
SO != SOEnd && !Done; ++SO) { SO != SOEnd && !Done; ++SO) {
assert(SO->second.size() > 0 && assert(SO->second.size() > 0 &&
"All virtual functions have overridding virtual functions"); "All virtual functions have overriding virtual functions");
// C++ [class.abstract]p4: // C++ [class.abstract]p4:
// A class is abstract if it contains or inherits at least one // A class is abstract if it contains or inherits at least one
// pure virtual function for which the final overrider is pure // pure virtual function for which the final overrider is pure
// virtual. // virtual.
if (SO->second.front().Method->isPure()) { if (SO->second.front().Method->isPure()) {
data().Abstract = true; data().Abstract = true;
Done = true; Done = true;
▲ Show 20 Lines • Show All 583 Lines • ▼ Show 20 Lines if ((getNumParams() < 1) ||
(getDescribedFunctionTemplate() != nullptr)) (getDescribedFunctionTemplate() != nullptr))
return false; return false;
const ParmVarDecl *Param = getParamDecl(0); const ParmVarDecl *Param = getParamDecl(0);
ASTContext &Context = getASTContext(); ASTContext &Context = getASTContext();
CanQualType ParamType = Context.getCanonicalType(Param->getType()); CanQualType ParamType = Context.getCanonicalType(Param->getType());
// Is it the same as our our class type? // Is it the same as our class type?
CanQualType ClassTy CanQualType ClassTy
= Context.getCanonicalType(Context.getTagDeclType(getParent())); = Context.getCanonicalType(Context.getTagDeclType(getParent()));
if (ParamType.getUnqualifiedType() != ClassTy) if (ParamType.getUnqualifiedType() != ClassTy)
return false; return false;
return true; return true;
} }
▲ Show 20 Lines • Show All 488 Lines • Show Last 20 Lines

cfe/trunk/lib/AST/DeclObjC.cpp

Show First 20 Lines • Show All 1,132 Lines • ▼ Show 20 Lines
static void CollectOverriddenMethodsRecurse(const ObjCContainerDecl *Container, static void CollectOverriddenMethodsRecurse(const ObjCContainerDecl *Container,
const ObjCMethodDecl *Method, const ObjCMethodDecl *Method,
SmallVectorImpl<const ObjCMethodDecl *> &Methods, SmallVectorImpl<const ObjCMethodDecl *> &Methods,
bool MovedToSuper) { bool MovedToSuper) {
if (!Container) if (!Container)
return; return;
// In categories look for overriden methods from protocols. A method from // In categories look for overridden methods from protocols. A method from
// category is not "overriden" since it is considered as the "same" method // category is not "overridden" since it is considered as the "same" method
// (same USR) as the one from the interface. // (same USR) as the one from the interface.
if (const ObjCCategoryDecl * if (const ObjCCategoryDecl *
Category = dyn_cast<ObjCCategoryDecl>(Container)) { Category = dyn_cast<ObjCCategoryDecl>(Container)) {
// Check whether we have a matching method at this category but only if we // Check whether we have a matching method at this category but only if we
// are at the super class level. // are at the super class level.
if (MovedToSuper) if (MovedToSuper)
if (ObjCMethodDecl * if (ObjCMethodDecl *
Overridden = Container->getMethod(Method->getSelector(), Overridden = Container->getMethod(Method->getSelector(),
▲ Show 20 Lines • Show All 1,090 Lines • Show Last 20 Lines

cfe/trunk/lib/AST/MicrosoftMangle.cpp

Show First 20 Lines • Show All 1,003 Lines • ▼ Show 20 Lines if (const BlockDecl *BD = dyn_cast<BlockDecl>(DC)) {
// to discriminate between named static data initializers in the same // to discriminate between named static data initializers in the same
// scope. This is handled differently from parameters, which use // scope. This is handled differently from parameters, which use
// positions to discriminate between multiple instances. // positions to discriminate between multiple instances.
if (const auto *MC = BD->getBlockManglingContextDecl()) if (const auto *MC = BD->getBlockManglingContextDecl())
if (!isa<ParmVarDecl>(MC)) if (!isa<ParmVarDecl>(MC))
if (const auto *ND = dyn_cast<NamedDecl>(MC)) if (const auto *ND = dyn_cast<NamedDecl>(MC))
mangleUnqualifiedName(ND); mangleUnqualifiedName(ND);
// MS ABI and Itanium manglings are in inverted scopes. In the case of a // MS ABI and Itanium manglings are in inverted scopes. In the case of a
// RecordDecl, mangle the entire scope hierachy at this point rather than // RecordDecl, mangle the entire scope hierarchy at this point rather than
// just the unqualified name to get the ordering correct. // just the unqualified name to get the ordering correct.
if (const auto *RD = dyn_cast<RecordDecl>(DC)) if (const auto *RD = dyn_cast<RecordDecl>(DC))
mangleName(RD); mangleName(RD);
else else
Out << '@'; Out << '@';
// void __cdecl // void __cdecl
Out << "YAX"; Out << "YAX";
// struct __block_literal * // struct __block_literal *
▲ Show 20 Lines • Show All 2,229 Lines • Show Last 20 Lines

cfe/trunk/lib/AST/Stmt.cpp

Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Linesstatic struct StmtClassNameTable {
unsigned Size; unsigned Size;
} StmtClassInfo[Stmt::lastStmtConstant+1]; } StmtClassInfo[Stmt::lastStmtConstant+1];
static StmtClassNameTable &getStmtInfoTableEntry(Stmt::StmtClass E) { static StmtClassNameTable &getStmtInfoTableEntry(Stmt::StmtClass E) {
static bool Initialized = false; static bool Initialized = false;
if (Initialized) if (Initialized)
return StmtClassInfo[E]; return StmtClassInfo[E];
// Intialize the table on the first use. // Initialize the table on the first use.
Initialized = true; Initialized = true;
#define ABSTRACT_STMT(STMT) #define ABSTRACT_STMT(STMT)
#define STMT(CLASS, PARENT) \ #define STMT(CLASS, PARENT) \
StmtClassInfo[(unsigned)Stmt::CLASS##Class].Name = #CLASS; \ StmtClassInfo[(unsigned)Stmt::CLASS##Class].Name = #CLASS; \
StmtClassInfo[(unsigned)Stmt::CLASS##Class].Size = sizeof(CLASS); StmtClassInfo[(unsigned)Stmt::CLASS##Class].Size = sizeof(CLASS);
#include "clang/AST/StmtNodes.inc" #include "clang/AST/StmtNodes.inc"
return StmtClassInfo[E]; return StmtClassInfo[E];
▲ Show 20 Lines • Show All 1,066 Lines • Show Last 20 Lines

cfe/trunk/lib/AST/VTableBuilder.cpp

Show First 20 Lines • Show All 2,989 Lines • ▼ Show 20 Lines if (OverriddenMD) {
assert(!MethodInfoMap.count(MD) && assert(!MethodInfoMap.count(MD) &&
"Should not have method info for this method yet!"); "Should not have method info for this method yet!");
MethodInfoMap.insert(std::make_pair(MD, MI)); MethodInfoMap.insert(std::make_pair(MD, MI));
continue; continue;
} }
// In case we need a return adjustment, we'll add a new slot for // In case we need a return adjustment, we'll add a new slot for
// the overrider. Mark the overriden method as shadowed by the new slot. // the overrider. Mark the overridden method as shadowed by the new slot.
OverriddenMethodInfo.Shadowed = true; OverriddenMethodInfo.Shadowed = true;
// Force a special name mangling for a return-adjusting thunk // Force a special name mangling for a return-adjusting thunk
// unless the method is the final overrider without this adjustment. // unless the method is the final overrider without this adjustment.
ForceReturnAdjustmentMangling = ForceReturnAdjustmentMangling =
!(MD == FinalOverriderMD && ThisAdjustmentOffset.isEmpty()); !(MD == FinalOverriderMD && ThisAdjustmentOffset.isEmpty());
} else if (Base.getBaseOffset() != WhichVFPtr.FullOffsetInMDC || } else if (Base.getBaseOffset() != WhichVFPtr.FullOffsetInMDC ||
MD->size_overridden_methods()) { MD->size_overridden_methods()) {
▲ Show 20 Lines • Show All 745 Lines • Show Last 20 Lines

cfe/trunk/lib/ASTMatchers/Dynamic/Parser.cpp

Show First 20 Lines • Show All 518 Lines • ▼ Show 20 Lines for (const auto &Completion : S->getMatcherCompletions(AcceptedTypes)) {
addCompletion(CompToken, Completion); addCompletion(CompToken, Completion);
} }
for (const auto &Completion : getNamedValueCompletions(AcceptedTypes)) { for (const auto &Completion : getNamedValueCompletions(AcceptedTypes)) {
addCompletion(CompToken, Completion); addCompletion(CompToken, Completion);
} }
} }
/// \brief Parse an <Expresssion> /// \brief Parse an <Expression>
bool Parser::parseExpressionImpl(VariantValue *Value) { bool Parser::parseExpressionImpl(VariantValue *Value) {
switch (Tokenizer->nextTokenKind()) { switch (Tokenizer->nextTokenKind()) {
case TokenInfo::TK_Literal: case TokenInfo::TK_Literal:
*Value = Tokenizer->consumeNextToken().Value; *Value = Tokenizer->consumeNextToken().Value;
return true; return true;
case TokenInfo::TK_Ident: case TokenInfo::TK_Ident:
return parseIdentifierPrefixImpl(Value); return parseIdentifierPrefixImpl(Value);
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

cfe/trunk/lib/Analysis/CloneDetection.cpp

Show First 20 Lines • Show All 375 Lines • ▼ Show 20 Lines for (CloneDetector::CloneGroup &Group : Sequences) {
// Check for each StmtSequence if its successor has the same hash value. // Check for each StmtSequence if its successor has the same hash value.
// We don't check the last StmtSequence as it has no successor. // We don't check the last StmtSequence as it has no successor.
// Note: The 'size - 1 ' in the condition is safe because we check for an // Note: The 'size - 1 ' in the condition is safe because we check for an
// empty Group vector at the beginning of this function. // empty Group vector at the beginning of this function.
for (unsigned i = 0; i < StmtsByHash.size() - 1; ++i) { for (unsigned i = 0; i < StmtsByHash.size() - 1; ++i) {
const auto Current = StmtsByHash[i]; const auto Current = StmtsByHash[i];
// It's likely that we just found an sequence of StmtSequences that // It's likely that we just found a sequence of StmtSequences that
// represent a CloneGroup, so we create a new group and start checking and // represent a CloneGroup, so we create a new group and start checking and
// adding the StmtSequences in this sequence. // adding the StmtSequences in this sequence.
CloneDetector::CloneGroup NewGroup; CloneDetector::CloneGroup NewGroup;
size_t PrototypeHash = Current.first; size_t PrototypeHash = Current.first;
for (; i < StmtsByHash.size(); ++i) { for (; i < StmtsByHash.size(); ++i) {
// A different hash value means we have reached the end of the sequence. // A different hash value means we have reached the end of the sequence.
▲ Show 20 Lines • Show All 239 Lines • Show Last 20 Lines

cfe/trunk/lib/Analysis/ThreadSafetyCommon.cpp

Show First 20 Lines • Show All 811 Lines • ▼ Show 20 Lines for (auto *Pm : Parms) {
til::SExpr *Lp = new (Arena) til::LiteralPtr(Pm); til::SExpr *Lp = new (Arena) til::LiteralPtr(Pm);
til::SExpr *Ld = new (Arena) til::Load(Lp); til::SExpr *Ld = new (Arena) til::Load(Lp);
til::SExpr *V = addStatement(Ld, nullptr, Pm); til::SExpr *V = addStatement(Ld, nullptr, Pm);
addVarDecl(Pm, V); addVarDecl(Pm, V);
} }
} }
void SExprBuilder::enterCFGBlock(const CFGBlock *B) { void SExprBuilder::enterCFGBlock(const CFGBlock *B) {
// Intialize TIL basic block and add it to the CFG. // Initialize TIL basic block and add it to the CFG.
CurrentBB = lookupBlock(B); CurrentBB = lookupBlock(B);
CurrentBB->reservePredecessors(B->pred_size()); CurrentBB->reservePredecessors(B->pred_size());
Scfg->add(CurrentBB); Scfg->add(CurrentBB);
CurrentBlockInfo = &BBInfo[B->getBlockID()]; CurrentBlockInfo = &BBInfo[B->getBlockID()];
// CurrentLVarMap is moved to ExitMap on block exit. // CurrentLVarMap is moved to ExitMap on block exit.
// FIXME: the entry block will hold function parameters. // FIXME: the entry block will hold function parameters.
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines if (N == 1) {
auto *Tm = new (Arena) til::Goto(BB, Idx); auto *Tm = new (Arena) til::Goto(BB, Idx);
CurrentBB->setTerminator(Tm); CurrentBB->setTerminator(Tm);
} }
else if (N == 2) { else if (N == 2) {
til::SExpr *C = translate(B->getTerminatorCondition(true), nullptr); til::SExpr *C = translate(B->getTerminatorCondition(true), nullptr);
til::BasicBlock *BB1 = *It ? lookupBlock(*It) : nullptr; til::BasicBlock *BB1 = *It ? lookupBlock(*It) : nullptr;
++It; ++It;
til::BasicBlock *BB2 = *It ? lookupBlock(*It) : nullptr; til::BasicBlock *BB2 = *It ? lookupBlock(*It) : nullptr;
// FIXME: make sure these arent' critical edges. // FIXME: make sure these aren't critical edges.
auto *Tm = new (Arena) til::Branch(C, BB1, BB2); auto *Tm = new (Arena) til::Branch(C, BB1, BB2);
CurrentBB->setTerminator(Tm); CurrentBB->setTerminator(Tm);
} }
} }
void SExprBuilder::handleSuccessor(const CFGBlock *Succ) { void SExprBuilder::handleSuccessor(const CFGBlock *Succ) {
++CurrentBlockInfo->UnprocessedSuccessors; ++CurrentBlockInfo->UnprocessedSuccessors;
} }
Show All 34 Lines

cfe/trunk/lib/Basic/DiagnosticIDs.cpp

Show First 20 Lines • Show All 464 Lines • ▼ Show 20 Lines if (Result == diag::Severity::Warning && State->IgnoreAllWarnings)
return diag::Severity::Ignored; return diag::Severity::Ignored;
// If -Werror is enabled, map warnings to errors unless explicitly disabled. // If -Werror is enabled, map warnings to errors unless explicitly disabled.
if (Result == diag::Severity::Warning) { if (Result == diag::Severity::Warning) {
if (State->WarningsAsErrors && !Mapping.hasNoWarningAsError()) if (State->WarningsAsErrors && !Mapping.hasNoWarningAsError())
Result = diag::Severity::Error; Result = diag::Severity::Error;
} }
// If -Wfatal-errors is enabled, map errors to fatal unless explicity // If -Wfatal-errors is enabled, map errors to fatal unless explicitly
// disabled. // disabled.
if (Result == diag::Severity::Error) { if (Result == diag::Severity::Error) {
if (State->ErrorsAsFatal && !Mapping.hasNoErrorAsFatal()) if (State->ErrorsAsFatal && !Mapping.hasNoErrorAsFatal())
Result = diag::Severity::Fatal; Result = diag::Severity::Fatal;
} }
// Custom diagnostics always are emitted in system headers. // Custom diagnostics always are emitted in system headers.
bool ShowInSystemHeader = bool ShowInSystemHeader =
▲ Show 20 Lines • Show All 263 Lines • Show Last 20 Lines

cfe/trunk/lib/Basic/SourceManager.cpp

Show First 20 Lines • Show All 1,881 Lines • ▼ Show 20 Linesvoid SourceManager::associateFileChunkWithMacroArgExp(
unsigned EndOffs = BeginOffs + ExpansionLength; unsigned EndOffs = BeginOffs + ExpansionLength;
// Add a new chunk for this macro argument. A previous macro argument chunk // Add a new chunk for this macro argument. A previous macro argument chunk
// may have been lexed again, so e.g. if the map is // may have been lexed again, so e.g. if the map is
// 0 -> SourceLocation() // 0 -> SourceLocation()
// 100 -> Expanded loc #1 // 100 -> Expanded loc #1
// 110 -> SourceLocation() // 110 -> SourceLocation()
// and we found a new macro FileID that lexed from offet 105 with length 3, // and we found a new macro FileID that lexed from offset 105 with length 3,
// the new map will be: // the new map will be:
// 0 -> SourceLocation() // 0 -> SourceLocation()
// 100 -> Expanded loc #1 // 100 -> Expanded loc #1
// 105 -> Expanded loc #2 // 105 -> Expanded loc #2
// 108 -> Expanded loc #1 // 108 -> Expanded loc #1
// 110 -> SourceLocation() // 110 -> SourceLocation()
// //
// Since re-lexed macro chunks will always be the same size or less of // Since re-lexed macro chunks will always be the same size or less of
▲ Show 20 Lines • Show All 349 Lines • Show Last 20 Lines

cfe/trunk/lib/Basic/Targets/PPC.cpp

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Linesvoid PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
// ABI options. // ABI options.
if (ABI == "elfv1" || ABI == "elfv1-qpx") if (ABI == "elfv1" || ABI == "elfv1-qpx")
Builder.defineMacro("_CALL_ELF", "1"); Builder.defineMacro("_CALL_ELF", "1");
if (ABI == "elfv2") if (ABI == "elfv2")
Builder.defineMacro("_CALL_ELF", "2"); Builder.defineMacro("_CALL_ELF", "2");
// This typically is only for a new enough linker (bfd >= 2.16.2 or gold), but // This typically is only for a new enough linker (bfd >= 2.16.2 or gold), but
// our suppport post-dates this and it should work on all 64-bit ppc linux // our support post-dates this and it should work on all 64-bit ppc linux
// platforms. It is guaranteed to work on all elfv2 platforms. // platforms. It is guaranteed to work on all elfv2 platforms.
if (getTriple().getOS() == llvm::Triple::Linux && PointerWidth == 64) if (getTriple().getOS() == llvm::Triple::Linux && PointerWidth == 64)
Builder.defineMacro("_CALL_LINUX", "1"); Builder.defineMacro("_CALL_LINUX", "1");
// Subtarget options. // Subtarget options.
Builder.defineMacro("__NATURAL_ALIGNMENT__"); Builder.defineMacro("__NATURAL_ALIGNMENT__");
Builder.defineMacro("__REGISTER_PREFIX__", ""); Builder.defineMacro("__REGISTER_PREFIX__", "");
▲ Show 20 Lines • Show All 405 Lines • Show Last 20 Lines

cfe/trunk/lib/Basic/Targets/X86.cpp

Show First 20 Lines • Show All 1,527 Lines • ▼ Show 20 Linesbool X86TargetInfo::validateAsmConstraint(
case 'D': // edi. case 'D': // edi.
case 'A': // edx:eax. case 'A': // edx:eax.
case 't': // Top of floating point stack. case 't': // Top of floating point stack.
case 'u': // Second from top of floating point stack. case 'u': // Second from top of floating point stack.
case 'q': // Any register accessible as [r]l: a, b, c, and d. case 'q': // Any register accessible as [r]l: a, b, c, and d.
case 'y': // Any MMX register. case 'y': // Any MMX register.
case 'v': // Any {X,Y,Z}MM register (Arch & context dependent) case 'v': // Any {X,Y,Z}MM register (Arch & context dependent)
case 'x': // Any SSE register. case 'x': // Any SSE register.
case 'k': // Any AVX512 mask register (same as Yk, additionaly allows k0 case 'k': // Any AVX512 mask register (same as Yk, additionally allows k0
// for intermideate k reg operations). // for intermideate k reg operations).
case 'Q': // Any register accessible as [r]h: a, b, c, and d. case 'Q': // Any register accessible as [r]h: a, b, c, and d.
case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp. case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
case 'l': // "Index" registers: any general register that can be used as an case 'l': // "Index" registers: any general register that can be used as an
// index in a base+index memory access. // index in a base+index memory access.
Info.setAllowsRegister(); Info.setAllowsRegister();
return true; return true;
// Floating point constant constraints. // Floating point constant constraints.
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/BackendUtil.cpp

Show First 20 Lines • Show All 815 Lines • ▼ Show 20 Lines default:
llvm_unreachable("Invalid optimization level!"); llvm_unreachable("Invalid optimization level!");
case 1: case 1:
return PassBuilder::O1; return PassBuilder::O1;
case 2: case 2:
switch (Opts.OptimizeSize) { switch (Opts.OptimizeSize) {
default: default:
llvm_unreachable("Invalide optimization level for size!"); llvm_unreachable("Invalid optimization level for size!");
case 0: case 0:
return PassBuilder::O2; return PassBuilder::O2;
case 1: case 1:
return PassBuilder::Os; return PassBuilder::Os;
case 2: case 2:
▲ Show 20 Lines • Show All 502 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/CGBlocks.cpp

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
static llvm::Constant *buildDisposeHelper(CodeGenModule &CGM, static llvm::Constant *buildDisposeHelper(CodeGenModule &CGM,
const CGBlockInfo &blockInfo) { const CGBlockInfo &blockInfo) {
return CodeGenFunction(CGM).GenerateDestroyHelperFunction(blockInfo); return CodeGenFunction(CGM).GenerateDestroyHelperFunction(blockInfo);
} }
/// buildBlockDescriptor - Build the block descriptor meta-data for a block. /// buildBlockDescriptor - Build the block descriptor meta-data for a block.
/// buildBlockDescriptor is accessed from 5th field of the Block_literal /// buildBlockDescriptor is accessed from 5th field of the Block_literal
/// meta-data and contains stationary information about the block literal. /// meta-data and contains stationary information about the block literal.
/// Its definition will have 4 (or optinally 6) words. /// Its definition will have 4 (or optionally 6) words.
/// \code /// \code
/// struct Block_descriptor { /// struct Block_descriptor {
/// unsigned long reserved; /// unsigned long reserved;
/// unsigned long size; // size of Block_literal metadata in bytes. /// unsigned long size; // size of Block_literal metadata in bytes.
/// void *copy_func_helper_decl; // optional copy helper. /// void *copy_func_helper_decl; // optional copy helper.
/// void *destroy_func_decl; // optioanl destructor helper. /// void *destroy_func_decl; // optioanl destructor helper.
/// void *block_method_encoding_address; // @encode for block literal signature. /// void *block_method_encoding_address; // @encode for block literal signature.
/// void *block_layout_info; // encoding of captured block variables. /// void *block_layout_info; // encoding of captured block variables.
▲ Show 20 Lines • Show All 247 Lines • ▼ Show 20 Lines if (auto *Helper =
Offset += CGM.getDataLayout().getTypeAllocSize(I); Offset += CGM.getDataLayout().getTypeAllocSize(I);
elementTypes.push_back(I); elementTypes.push_back(I);
} }
} }
info.BlockAlign = CharUnits::fromQuantity(BlockAlign); info.BlockAlign = CharUnits::fromQuantity(BlockAlign);
info.BlockSize = CharUnits::fromQuantity(Offset); info.BlockSize = CharUnits::fromQuantity(Offset);
} else { } else {
// The header is basically 'struct { void *; int; int; void *; void *; }'. // The header is basically 'struct { void *; int; int; void *; void *; }'.
// Assert that that struct is packed. // Assert that the struct is packed.
assert(CGM.getIntSize() <= CGM.getPointerSize()); assert(CGM.getIntSize() <= CGM.getPointerSize());
assert(CGM.getIntAlign() <= CGM.getPointerAlign()); assert(CGM.getIntAlign() <= CGM.getPointerAlign());
assert((2 * CGM.getIntSize()).isMultipleOf(CGM.getPointerAlign())); assert((2 * CGM.getIntSize()).isMultipleOf(CGM.getPointerAlign()));
info.BlockAlign = CGM.getPointerAlign(); info.BlockAlign = CGM.getPointerAlign();
info.BlockSize = 3 * CGM.getPointerSize() + 2 * CGM.getIntSize(); info.BlockSize = 3 * CGM.getPointerSize() + 2 * CGM.getIntSize();
elementTypes.push_back(CGM.VoidPtrTy); elementTypes.push_back(CGM.VoidPtrTy);
elementTypes.push_back(CGM.IntTy); elementTypes.push_back(CGM.IntTy);
elementTypes.push_back(CGM.IntTy); elementTypes.push_back(CGM.IntTy);
▲ Show 20 Lines • Show All 540 Lines • ▼ Show 20 Lines if (blockDecl->isConversionFromLambda()) {
// special; we'll simply emit it directly. // special; we'll simply emit it directly.
src = Address::invalid(); src = Address::invalid();
} else if (CI.isByRef()) { } else if (CI.isByRef()) {
if (BlockInfo && CI.isNested()) { if (BlockInfo && CI.isNested()) {
// We need to use the capture from the enclosing block. // We need to use the capture from the enclosing block.
const CGBlockInfo::Capture &enclosingCapture = const CGBlockInfo::Capture &enclosingCapture =
BlockInfo->getCapture(variable); BlockInfo->getCapture(variable);
// This is a [[type]]*, except that a byref entry wil just be an i8**. // This is a [[type]]*, except that a byref entry will just be an i8**.
src = Builder.CreateStructGEP(LoadBlockStruct(), src = Builder.CreateStructGEP(LoadBlockStruct(),
enclosingCapture.getIndex(), enclosingCapture.getIndex(),
enclosingCapture.getOffset(), enclosingCapture.getOffset(),
"block.capture.addr"); "block.capture.addr");
} else { } else {
auto I = LocalDeclMap.find(variable); auto I = LocalDeclMap.find(variable);
assert(I != LocalDeclMap.end()); assert(I != LocalDeclMap.end());
src = I->second; src = I->second;
▲ Show 20 Lines • Show All 1,742 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/CGBuiltin.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 378 Lines • ▼ Show 20 LinesEncompassingIntegerType(ArrayRef<struct WidthAndSignedness> Types) {
// If any of the given types is signed, we must return a signed type. // If any of the given types is signed, we must return a signed type.
bool Signed = false; bool Signed = false;
for (const auto &Type : Types) { for (const auto &Type : Types) {
Signed |= Type.Signed; Signed |= Type.Signed;
} }
// The encompassing type must have a width greater than or equal to the width // The encompassing type must have a width greater than or equal to the width
// of the specified types. Aditionally, if the encompassing type is signed, // of the specified types. Additionally, if the encompassing type is signed,
// its width must be strictly greater than the width of any unsigned types // its width must be strictly greater than the width of any unsigned types
// given. // given.
unsigned Width = 0; unsigned Width = 0;
for (const auto &Type : Types) { for (const auto &Type : Types) {
unsigned MinWidth = Type.Width + (Signed && !Type.Signed); unsigned MinWidth = Type.Width + (Signed && !Type.Signed);
if (Width < MinWidth) { if (Width < MinWidth) {
Width = MinWidth; Width = MinWidth;
} }
▲ Show 20 Lines • Show All 77 Lines • ▼ Show 20 LinesCodeGenFunction::emitBuiltinObjectSize(const Expr *E, unsigned Type,
Value *Ptr = EmittedE ? EmittedE : EmitScalarExpr(E); Value *Ptr = EmittedE ? EmittedE : EmitScalarExpr(E);
assert(Ptr->getType()->isPointerTy() && assert(Ptr->getType()->isPointerTy() &&
"Non-pointer passed to __builtin_object_size?"); "Non-pointer passed to __builtin_object_size?");
Value *F = CGM.getIntrinsic(Intrinsic::objectsize, {ResType, Ptr->getType()}); Value *F = CGM.getIntrinsic(Intrinsic::objectsize, {ResType, Ptr->getType()});
// LLVM only supports 0 and 2, make sure that we pass along that as a boolean. // LLVM only supports 0 and 2, make sure that we pass along that as a boolean.
Value *Min = Builder.getInt1((Type & 2) != 0); Value *Min = Builder.getInt1((Type & 2) != 0);
// For GCC compatability, __builtin_object_size treat NULL as unknown size. // For GCC compatibility, __builtin_object_size treat NULL as unknown size.
Value *NullIsUnknown = Builder.getTrue(); Value *NullIsUnknown = Builder.getTrue();
return Builder.CreateCall(F, {Ptr, Min, NullIsUnknown}); return Builder.CreateCall(F, {Ptr, Min, NullIsUnknown});
} }
// Many of MSVC builtins are on both x64 and ARM; to avoid repeating code, we // Many of MSVC builtins are on both x64 and ARM; to avoid repeating code, we
// handle them here. // handle them here.
enum class CodeGenFunction::MSVCIntrin { enum class CodeGenFunction::MSVCIntrin {
_BitScanForward, _BitScanForward,
▲ Show 20 Lines • Show All 1,601 Lines • ▼ Show 20 Lines llvm::StoreInst *Store =
StoreSize); StoreSize);
Store->setAtomic(llvm::AtomicOrdering::Release); Store->setAtomic(llvm::AtomicOrdering::Release);
return RValue::get(nullptr); return RValue::get(nullptr);
} }
case Builtin::BI__sync_synchronize: { case Builtin::BI__sync_synchronize: {
// We assume this is supposed to correspond to a C++0x-style // We assume this is supposed to correspond to a C++0x-style
// sequentially-consistent fence (i.e. this is only usable for // sequentially-consistent fence (i.e. this is only usable for
// synchonization, not device I/O or anything like that). This intrinsic // synchronization, not device I/O or anything like that). This intrinsic
// is really badly designed in the sense that in theory, there isn't // is really badly designed in the sense that in theory, there isn't
// any way to safely use it... but in practice, it mostly works // any way to safely use it... but in practice, it mostly works
// to use it with non-atomic loads and stores to get acquire/release // to use it with non-atomic loads and stores to get acquire/release
// semantics. // semantics.
Builder.CreateFence(llvm::AtomicOrdering::SequentiallyConsistent); Builder.CreateFence(llvm::AtomicOrdering::SequentiallyConsistent);
return RValue::get(nullptr); return RValue::get(nullptr);
} }
▲ Show 20 Lines • Show All 1,206 Lines • ▼ Show 20 Lines
// See if we have a target specific intrinsic. // See if we have a target specific intrinsic.
const char *Name = getContext().BuiltinInfo.getName(BuiltinID); const char *Name = getContext().BuiltinInfo.getName(BuiltinID);
Intrinsic::ID IntrinsicID = Intrinsic::not_intrinsic; Intrinsic::ID IntrinsicID = Intrinsic::not_intrinsic;
StringRef Prefix = StringRef Prefix =
llvm::Triple::getArchTypePrefix(getTarget().getTriple().getArch()); llvm::Triple::getArchTypePrefix(getTarget().getTriple().getArch());
if (!Prefix.empty()) { if (!Prefix.empty()) {
IntrinsicID = Intrinsic::getIntrinsicForGCCBuiltin(Prefix.data(), Name); IntrinsicID = Intrinsic::getIntrinsicForGCCBuiltin(Prefix.data(), Name);
// NOTE we dont need to perform a compatibility flag check here since the // NOTE we don't need to perform a compatibility flag check here since the
// intrinsics are declared in Builtins*.def via LANGBUILTIN which filter the // intrinsics are declared in Builtins*.def via LANGBUILTIN which filter the
// MS builtins via ALL_MS_LANGUAGES and are filtered earlier. // MS builtins via ALL_MS_LANGUAGES and are filtered earlier.
if (IntrinsicID == Intrinsic::not_intrinsic) if (IntrinsicID == Intrinsic::not_intrinsic)
IntrinsicID = Intrinsic::getIntrinsicForMSBuiltin(Prefix.data(), Name); IntrinsicID = Intrinsic::getIntrinsicForMSBuiltin(Prefix.data(), Name);
} }
if (IntrinsicID != Intrinsic::not_intrinsic) { if (IntrinsicID != Intrinsic::not_intrinsic) {
SmallVector<Value*, 16> Args; SmallVector<Value*, 16> Args;
▲ Show 20 Lines • Show All 7,640 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/CGDebugInfo.cpp

Show First 20 Lines • Show All 811 Lines • ▼ Show 20 Linesstatic SmallString<256> getUniqueTagTypeName(const TagType *Ty,
// TODO: This is using the RTTI name. Is there a better way to get // TODO: This is using the RTTI name. Is there a better way to get
// a unique string for a type? // a unique string for a type?
llvm::raw_svector_ostream Out(FullName); llvm::raw_svector_ostream Out(FullName);
CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(QualType(Ty, 0), Out); CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(QualType(Ty, 0), Out);
return FullName; return FullName;
} }
/// \return the approproate DWARF tag for a composite type. /// \return the appropriate DWARF tag for a composite type.
static llvm::dwarf::Tag getTagForRecord(const RecordDecl *RD) { static llvm::dwarf::Tag getTagForRecord(const RecordDecl *RD) {
llvm::dwarf::Tag Tag; llvm::dwarf::Tag Tag;
if (RD->isStruct() || RD->isInterface()) if (RD->isStruct() || RD->isInterface())
Tag = llvm::dwarf::DW_TAG_structure_type; Tag = llvm::dwarf::DW_TAG_structure_type;
else if (RD->isUnion()) else if (RD->isUnion())
Tag = llvm::dwarf::DW_TAG_union_type; Tag = llvm::dwarf::DW_TAG_union_type;
else { else {
// FIXME: This could be a struct type giving a default visibility different // FIXME: This could be a struct type giving a default visibility different
▲ Show 20 Lines • Show All 1,272 Lines • ▼ Show 20 Lines if (ModRef != ModuleCache.end())
return cast<llvm::DIModule>(ModRef->second); return cast<llvm::DIModule>(ModRef->second);
// Macro definitions that were defined with "-D" on the command line. // Macro definitions that were defined with "-D" on the command line.
SmallString<128> ConfigMacros; SmallString<128> ConfigMacros;
{ {
llvm::raw_svector_ostream OS(ConfigMacros); llvm::raw_svector_ostream OS(ConfigMacros);
const auto &PPOpts = CGM.getPreprocessorOpts(); const auto &PPOpts = CGM.getPreprocessorOpts();
unsigned I = 0; unsigned I = 0;
// Translate the macro definitions back into a commmand line. // Translate the macro definitions back into a command line.
for (auto &M : PPOpts.Macros) { for (auto &M : PPOpts.Macros) {
if (++I > 1) if (++I > 1)
OS << " "; OS << " ";
const std::string &Macro = M.first; const std::string &Macro = M.first;
bool Undef = M.second; bool Undef = M.second;
OS << "\"-" << (Undef ? 'U' : 'D'); OS << "\"-" << (Undef ? 'U' : 'D');
for (char c : Macro) for (char c : Macro)
switch (c) { switch (c) {
▲ Show 20 Lines • Show All 748 Lines • ▼ Show 20 Lines case llvm::dwarf::DW_TAG_enumeration_type:
// them distinct if they are ODR-uniqued. // them distinct if they are ODR-uniqued.
if (FullName.empty()) if (FullName.empty())
break; break;
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
case llvm::dwarf::DW_TAG_structure_type: case llvm::dwarf::DW_TAG_structure_type:
case llvm::dwarf::DW_TAG_union_type: case llvm::dwarf::DW_TAG_union_type:
case llvm::dwarf::DW_TAG_class_type: case llvm::dwarf::DW_TAG_class_type:
// Immediatley resolve to a distinct node. // Immediately resolve to a distinct node.
RealDecl = RealDecl =
llvm::MDNode::replaceWithDistinct(llvm::TempDICompositeType(RealDecl)); llvm::MDNode::replaceWithDistinct(llvm::TempDICompositeType(RealDecl));
break; break;
} }
RegionMap[Ty->getDecl()].reset(RealDecl); RegionMap[Ty->getDecl()].reset(RealDecl);
TypeCache[QualType(Ty, 0).getAsOpaquePtr()].reset(RealDecl); TypeCache[QualType(Ty, 0).getAsOpaquePtr()].reset(RealDecl);
▲ Show 20 Lines • Show All 699 Lines • ▼ Show 20 Lines if (VD->hasAttr<BlocksAttr>()) {
Expr.push_back(offset.getQuantity()); Expr.push_back(offset.getQuantity());
} }
} else if (const auto *RT = dyn_cast<RecordType>(VD->getType())) { } else if (const auto *RT = dyn_cast<RecordType>(VD->getType())) {
// If VD is an anonymous union then Storage represents value for // If VD is an anonymous union then Storage represents value for
// all union fields. // all union fields.
const RecordDecl *RD = RT->getDecl(); const RecordDecl *RD = RT->getDecl();
if (RD->isUnion() && RD->isAnonymousStructOrUnion()) { if (RD->isUnion() && RD->isAnonymousStructOrUnion()) {
// GDB has trouble finding local variables in anonymous unions, so we emit // GDB has trouble finding local variables in anonymous unions, so we emit
// artifical local variables for each of the members. // artificial local variables for each of the members.
// //
// FIXME: Remove this code as soon as GDB supports this. // FIXME: Remove this code as soon as GDB supports this.
// The debug info verifier in LLVM operates based on the assumption that a // The debug info verifier in LLVM operates based on the assumption that a
// variable has the same size as its storage and we had to disable the check // variable has the same size as its storage and we had to disable the check
// for artificial variables. // for artificial variables.
for (const auto *Field : RD->fields()) { for (const auto *Field : RD->fields()) {
llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit); llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
StringRef FieldName = Field->getName(); StringRef FieldName = Field->getName();
▲ Show 20 Lines • Show All 612 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/CGExprAgg.cpp

Show First 20 Lines • Show All 740 Lines • ▼ Show 20 Lines if (Expr *op = findPeephole(E->getSubExpr(), peepholeTarget)) {
return Visit(op); return Visit(op);
} }
// If we're converting an r-value of non-atomic type to an r-value // If we're converting an r-value of non-atomic type to an r-value
// of atomic type, just emit directly into the relevant sub-object. // of atomic type, just emit directly into the relevant sub-object.
if (isToAtomic) { if (isToAtomic) {
AggValueSlot valueDest = Dest; AggValueSlot valueDest = Dest;
if (!valueDest.isIgnored() && CGF.CGM.isPaddedAtomicType(atomicType)) { if (!valueDest.isIgnored() && CGF.CGM.isPaddedAtomicType(atomicType)) {
// Zero-initialize. (Strictly speaking, we only need to intialize // Zero-initialize. (Strictly speaking, we only need to initialize
// the padding at the end, but this is simpler.) // the padding at the end, but this is simpler.)
if (!Dest.isZeroed()) if (!Dest.isZeroed())
CGF.EmitNullInitialization(Dest.getAddress(), atomicType); CGF.EmitNullInitialization(Dest.getAddress(), atomicType);
// Build a GEP to refer to the subobject. // Build a GEP to refer to the subobject.
Address valueAddr = Address valueAddr =
CGF.Builder.CreateStructGEP(valueDest.getAddress(), 0, CGF.Builder.CreateStructGEP(valueDest.getAddress(), 0,
CharUnits()); CharUnits());
▲ Show 20 Lines • Show All 1,024 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/CGExprComplex.cpp

Show First 20 Lines • Show All 1,050 Lines • ▼ Show 20 LinesComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) {
if (E->getNumInits() == 2) { if (E->getNumInits() == 2) {
llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0)); llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0));
llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1)); llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1));
return ComplexPairTy(Real, Imag); return ComplexPairTy(Real, Imag);
} else if (E->getNumInits() == 1) { } else if (E->getNumInits() == 1) {
return Visit(E->getInit(0)); return Visit(E->getInit(0));
} }
// Empty init list intializes to null // Empty init list initializes to null
assert(E->getNumInits() == 0 && "Unexpected number of inits"); assert(E->getNumInits() == 0 && "Unexpected number of inits");
QualType Ty = E->getType()->castAs<ComplexType>()->getElementType(); QualType Ty = E->getType()->castAs<ComplexType>()->getElementType();
llvm::Type* LTy = CGF.ConvertType(Ty); llvm::Type* LTy = CGF.ConvertType(Ty);
llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy); llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy);
return ComplexPairTy(zeroConstant, zeroConstant); return ComplexPairTy(zeroConstant, zeroConstant);
} }
ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) { ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) {
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/CGObjCMac.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 6,942 Lines • ▼ Show 20 Lines IvarOffsetValue = CGF.Builder.CreateAlignedLoad(IvarOffsetValue,
CGF.getSizeAlign(), "ivar"); CGF.getSizeAlign(), "ivar");
if (IsIvarOffsetKnownIdempotent(CGF, Ivar)) if (IsIvarOffsetKnownIdempotent(CGF, Ivar))
cast<llvm::LoadInst>(IvarOffsetValue) cast<llvm::LoadInst>(IvarOffsetValue)
->setMetadata(CGM.getModule().getMDKindID("invariant.load"), ->setMetadata(CGM.getModule().getMDKindID("invariant.load"),
llvm::MDNode::get(VMContext, None)); llvm::MDNode::get(VMContext, None));
// This could be 32bit int or 64bit integer depending on the architecture. // This could be 32bit int or 64bit integer depending on the architecture.
// Cast it to 64bit integer value, if it is a 32bit integer ivar offset value // Cast it to 64bit integer value, if it is a 32bit integer ivar offset value
// as this is what caller always expectes. // as this is what caller always expects.
if (ObjCTypes.IvarOffsetVarTy == ObjCTypes.IntTy) if (ObjCTypes.IvarOffsetVarTy == ObjCTypes.IntTy)
IvarOffsetValue = CGF.Builder.CreateIntCast( IvarOffsetValue = CGF.Builder.CreateIntCast(
IvarOffsetValue, ObjCTypes.LongTy, true, "ivar.conv"); IvarOffsetValue, ObjCTypes.LongTy, true, "ivar.conv");
return IvarOffsetValue; return IvarOffsetValue;
} }
static void appendSelectorForMessageRefTable(std::string &buffer, static void appendSelectorForMessageRefTable(std::string &buffer,
Selector selector) { Selector selector) {
▲ Show 20 Lines • Show All 642 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/CGOpenCLRuntime.h

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines virtual void EmitWorkGroupLocalVarDecl(CodeGenFunction &CGF,
const VarDecl &D); const VarDecl &D);
virtual llvm::Type *convertOpenCLSpecificType(const Type *T); virtual llvm::Type *convertOpenCLSpecificType(const Type *T);
virtual llvm::Type *getPipeType(const PipeType *T); virtual llvm::Type *getPipeType(const PipeType *T);
llvm::PointerType *getSamplerType(const Type *T); llvm::PointerType *getSamplerType(const Type *T);
// \brief Returnes a value which indicates the size in bytes of the pipe // \brief Returns a value which indicates the size in bytes of the pipe
// element. // element.
virtual llvm::Value *getPipeElemSize(const Expr *PipeArg); virtual llvm::Value *getPipeElemSize(const Expr *PipeArg);
// \brief Returnes a value which indicates the alignment in bytes of the pipe // \brief Returns a value which indicates the alignment in bytes of the pipe
// element. // element.
virtual llvm::Value *getPipeElemAlign(const Expr *PipeArg); virtual llvm::Value *getPipeElemAlign(const Expr *PipeArg);
/// \return __generic void* type. /// \return __generic void* type.
llvm::PointerType *getGenericVoidPointerType(); llvm::PointerType *getGenericVoidPointerType();
/// \return enqueued block information for enqueued block. /// \return enqueued block information for enqueued block.
EnqueuedBlockInfo emitOpenCLEnqueuedBlock(CodeGenFunction &CGF, EnqueuedBlockInfo emitOpenCLEnqueuedBlock(CodeGenFunction &CGF,
Show All 20 Lines

cfe/trunk/lib/CodeGen/CGOpenMPRuntime.h

Show First 20 Lines • Show All 127 Lines • ▼ Show 20 Linesprivate:
/// List of addresses of original shared variables/expressions. /// List of addresses of original shared variables/expressions.
SmallVector<std::pair<LValue, LValue>, 4> SharedAddresses; SmallVector<std::pair<LValue, LValue>, 4> SharedAddresses;
/// Sizes of the reduction items in chars. /// Sizes of the reduction items in chars.
SmallVector<std::pair<llvm::Value *, llvm::Value *>, 4> Sizes; SmallVector<std::pair<llvm::Value *, llvm::Value *>, 4> Sizes;
/// Base declarations for the reduction items. /// Base declarations for the reduction items.
SmallVector<const VarDecl *, 4> BaseDecls; SmallVector<const VarDecl *, 4> BaseDecls;
/// Emits lvalue for shared expresion. /// Emits lvalue for shared expression.
LValue emitSharedLValue(CodeGenFunction &CGF, const Expr *E); LValue emitSharedLValue(CodeGenFunction &CGF, const Expr *E);
/// Emits upper bound for shared expression (if array section). /// Emits upper bound for shared expression (if array section).
LValue emitSharedLValueUB(CodeGenFunction &CGF, const Expr *E); LValue emitSharedLValueUB(CodeGenFunction &CGF, const Expr *E);
/// Performs aggregate initialization. /// Performs aggregate initialization.
/// \param N Number of reduction item in the common list. /// \param N Number of reduction item in the common list.
/// \param PrivateAddr Address of the corresponding private item. /// \param PrivateAddr Address of the corresponding private item.
/// \param SharedLVal Address of the original shared variable. /// \param SharedLVal Address of the original shared variable.
/// \param DRD Declare reduction construct used for reduction item. /// \param DRD Declare reduction construct used for reduction item.
▲ Show 20 Lines • Show All 1,313 Lines • ▼ Show 20 Linespublic:
/// Emit code for doacross ordered directive with 'depend' clause. /// Emit code for doacross ordered directive with 'depend' clause.
/// \param C 'depend' clause with 'sink|source' dependency kind. /// \param C 'depend' clause with 'sink|source' dependency kind.
virtual void emitDoacrossOrdered(CodeGenFunction &CGF, virtual void emitDoacrossOrdered(CodeGenFunction &CGF,
const OMPDependClause *C); const OMPDependClause *C);
/// Translates the native parameter of outlined function if this is required /// Translates the native parameter of outlined function if this is required
/// for target. /// for target.
/// \param FD Field decl from captured record for the paramater. /// \param FD Field decl from captured record for the parameter.
/// \param NativeParam Parameter itself. /// \param NativeParam Parameter itself.
virtual const VarDecl *translateParameter(const FieldDecl *FD, virtual const VarDecl *translateParameter(const FieldDecl *FD,
const VarDecl *NativeParam) const { const VarDecl *NativeParam) const {
return NativeParam; return NativeParam;
} }
/// Gets the address of the native argument basing on the address of the /// Gets the address of the native argument basing on the address of the
/// target-specific parameter. /// target-specific parameter.
▲ Show 20 Lines • Show All 569 Lines • ▼ Show 20 Linespublic:
/// Emit code for doacross ordered directive with 'depend' clause. /// Emit code for doacross ordered directive with 'depend' clause.
/// \param C 'depend' clause with 'sink|source' dependency kind. /// \param C 'depend' clause with 'sink|source' dependency kind.
void emitDoacrossOrdered(CodeGenFunction &CGF, void emitDoacrossOrdered(CodeGenFunction &CGF,
const OMPDependClause *C) override; const OMPDependClause *C) override;
/// Translates the native parameter of outlined function if this is required /// Translates the native parameter of outlined function if this is required
/// for target. /// for target.
/// \param FD Field decl from captured record for the paramater. /// \param FD Field decl from captured record for the parameter.
/// \param NativeParam Parameter itself. /// \param NativeParam Parameter itself.
const VarDecl *translateParameter(const FieldDecl *FD, const VarDecl *translateParameter(const FieldDecl *FD,
const VarDecl *NativeParam) const override; const VarDecl *NativeParam) const override;
/// Gets the address of the native argument basing on the address of the /// Gets the address of the native argument basing on the address of the
/// target-specific parameter. /// target-specific parameter.
/// \param NativeParam Parameter itself. /// \param NativeParam Parameter itself.
/// \param TargetParam Corresponding target-specific parameter. /// \param TargetParam Corresponding target-specific parameter.
Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam, Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam,
const VarDecl *TargetParam) const override; const VarDecl *TargetParam) const override;
}; };
} // namespace CodeGen } // namespace CodeGen
} // namespace clang } // namespace clang
#endif #endif

cfe/trunk/lib/CodeGen/CGOpenMPRuntime.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,802 Lines • ▼ Show 20 Linesvoid CGOpenMPRuntime::createOffloadEntriesAndInfoMetadata() {
// can easily figure out what to emit. The produced metadata looks like // can easily figure out what to emit. The produced metadata looks like
// this: // this:
// //
// !omp_offload.info = !{!1, ...} // !omp_offload.info = !{!1, ...}
// //
// Right now we only generate metadata for function that contain target // Right now we only generate metadata for function that contain target
// regions. // regions.
// If we do not have entries, we dont need to do anything. // If we do not have entries, we don't need to do anything.
if (OffloadEntriesInfoManager.empty()) if (OffloadEntriesInfoManager.empty())
return; return;
llvm::Module &M = CGM.getModule(); llvm::Module &M = CGM.getModule();
llvm::LLVMContext &C = M.getContext(); llvm::LLVMContext &C = M.getContext();
SmallVector<const OffloadEntriesInfoManagerTy::OffloadEntryInfo *, 16> SmallVector<const OffloadEntriesInfoManagerTy::OffloadEntryInfo *, 16>
OrderedEntries(OffloadEntriesInfoManager.size()); OrderedEntries(OffloadEntriesInfoManager.size());
▲ Show 20 Lines • Show All 1,117 Lines • ▼ Show 20 Lines for (unsigned i = 0; i < NumDependencies; ++i) {
CGF.EmitStoreOfScalar(llvm::ConstantInt::get(LLVMFlagsTy, DepKind), CGF.EmitStoreOfScalar(llvm::ConstantInt::get(LLVMFlagsTy, DepKind),
FlagsLVal); FlagsLVal);
} }
DependenciesArray = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast( DependenciesArray = CGF.Builder.CreatePointerBitCastOrAddrSpaceCast(
CGF.Builder.CreateStructGEP(DependenciesArray, 0, CharUnits::Zero()), CGF.Builder.CreateStructGEP(DependenciesArray, 0, CharUnits::Zero()),
CGF.VoidPtrTy); CGF.VoidPtrTy);
} }
// NOTE: routine and part_id fields are intialized by __kmpc_omp_task_alloc() // NOTE: routine and part_id fields are initialized by __kmpc_omp_task_alloc()
// libcall. // libcall.
// Build kmp_int32 __kmpc_omp_task_with_deps(ident_t *, kmp_int32 gtid, // Build kmp_int32 __kmpc_omp_task_with_deps(ident_t *, kmp_int32 gtid,
// kmp_task_t *new_task, kmp_int32 ndeps, kmp_depend_info_t *dep_list, // kmp_task_t *new_task, kmp_int32 ndeps, kmp_depend_info_t *dep_list,
// kmp_int32 ndeps_noalias, kmp_depend_info_t *noalias_dep_list) if dependence // kmp_int32 ndeps_noalias, kmp_depend_info_t *noalias_dep_list) if dependence
// list is not empty // list is not empty
auto *ThreadID = getThreadID(CGF, Loc); auto *ThreadID = getThreadID(CGF, Loc);
auto *UpLoc = emitUpdateLocation(CGF, Loc); auto *UpLoc = emitUpdateLocation(CGF, Loc);
llvm::Value *TaskArgs[] = { UpLoc, ThreadID, NewTask }; llvm::Value *TaskArgs[] = { UpLoc, ThreadID, NewTask };
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Linesvoid CGOpenMPRuntime::emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc,
llvm::Value *TaskFunction, llvm::Value *TaskFunction,
QualType SharedsTy, Address Shareds, QualType SharedsTy, Address Shareds,
const Expr *IfCond, const Expr *IfCond,
const OMPTaskDataTy &Data) { const OMPTaskDataTy &Data) {
if (!CGF.HaveInsertPoint()) if (!CGF.HaveInsertPoint())
return; return;
TaskResultTy Result = TaskResultTy Result =
emitTaskInit(CGF, Loc, D, TaskFunction, SharedsTy, Shareds, Data); emitTaskInit(CGF, Loc, D, TaskFunction, SharedsTy, Shareds, Data);
// NOTE: routine and part_id fields are intialized by __kmpc_omp_task_alloc() // NOTE: routine and part_id fields are initialized by __kmpc_omp_task_alloc()
// libcall. // libcall.
// Call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t *task, int // Call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t *task, int
// if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int nogroup, int // if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int nogroup, int
// sched, kmp_uint64 grainsize, void *task_dup); // sched, kmp_uint64 grainsize, void *task_dup);
llvm::Value *ThreadID = getThreadID(CGF, Loc); llvm::Value *ThreadID = getThreadID(CGF, Loc);
llvm::Value *UpLoc = emitUpdateLocation(CGF, Loc); llvm::Value *UpLoc = emitUpdateLocation(CGF, Loc);
llvm::Value *IfVal; llvm::Value *IfVal;
if (IfCond) { if (IfCond) {
▲ Show 20 Lines • Show All 1,546 Lines • ▼ Show 20 Linespublic:
void generateInfoForComponentList( void generateInfoForComponentList(
OpenMPMapClauseKind MapType, OpenMPMapClauseKind MapTypeModifier, OpenMPMapClauseKind MapType, OpenMPMapClauseKind MapTypeModifier,
OMPClauseMappableExprCommon::MappableExprComponentListRef Components, OMPClauseMappableExprCommon::MappableExprComponentListRef Components,
MapBaseValuesArrayTy &BasePointers, MapValuesArrayTy &Pointers, MapBaseValuesArrayTy &BasePointers, MapValuesArrayTy &Pointers,
MapValuesArrayTy &Sizes, MapFlagsArrayTy &Types, MapValuesArrayTy &Sizes, MapFlagsArrayTy &Types,
bool IsFirstComponentList, bool IsImplicit) const { bool IsFirstComponentList, bool IsImplicit) const {
// The following summarizes what has to be generated for each map and the // The following summarizes what has to be generated for each map and the
// types bellow. The generated information is expressed in this order: // types below. The generated information is expressed in this order:
// base pointer, section pointer, size, flags // base pointer, section pointer, size, flags
// (to add to the ones that come from the map type and modifier). // (to add to the ones that come from the map type and modifier).
// //
// double d; // double d;
// int i[100]; // int i[100];
// float *p; // float *p;
// //
// struct S1 { // struct S1 {
▲ Show 20 Lines • Show All 2,120 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/CGOpenMPRuntimeNVPTX.h

Show First 20 Lines • Show All 272 Lines • ▼ Show 20 Linespublic:
/// Returns specified OpenMP runtime function for the current OpenMP /// Returns specified OpenMP runtime function for the current OpenMP
/// implementation. Specialized for the NVPTX device. /// implementation. Specialized for the NVPTX device.
/// \param Function OpenMP runtime function. /// \param Function OpenMP runtime function.
/// \return Specified function. /// \return Specified function.
llvm::Constant *createNVPTXRuntimeFunction(unsigned Function); llvm::Constant *createNVPTXRuntimeFunction(unsigned Function);
/// Translates the native parameter of outlined function if this is required /// Translates the native parameter of outlined function if this is required
/// for target. /// for target.
/// \param FD Field decl from captured record for the paramater. /// \param FD Field decl from captured record for the parameter.
/// \param NativeParam Parameter itself. /// \param NativeParam Parameter itself.
const VarDecl *translateParameter(const FieldDecl *FD, const VarDecl *translateParameter(const FieldDecl *FD,
const VarDecl *NativeParam) const override; const VarDecl *NativeParam) const override;
/// Gets the address of the native argument basing on the address of the /// Gets the address of the native argument basing on the address of the
/// target-specific parameter. /// target-specific parameter.
/// \param NativeParam Parameter itself. /// \param NativeParam Parameter itself.
/// \param TargetParam Corresponding target-specific parameter. /// \param TargetParam Corresponding target-specific parameter.
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/CGRecordLayoutBuilder.cpp

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
/// a zero sized (empty struct) storage type. /// a zero sized (empty struct) storage type.
/// * Clang reads the complete type rather than the base type when generating /// * Clang reads the complete type rather than the base type when generating
/// code to access fields. Bitfields in tail position with tail padding may /// code to access fields. Bitfields in tail position with tail padding may
/// be clipped in the base class but not the complete class (we may discover /// be clipped in the base class but not the complete class (we may discover
/// that the tail padding is not used in the complete class.) However, /// that the tail padding is not used in the complete class.) However,
/// because LLVM reads from the complete type it can generate incorrect code /// because LLVM reads from the complete type it can generate incorrect code
/// if we do not clip the tail padding off of the bitfield in the complete /// if we do not clip the tail padding off of the bitfield in the complete
/// layout. This introduces a somewhat awkward extra unnecessary clip stage. /// layout. This introduces a somewhat awkward extra unnecessary clip stage.
/// The location of the clip is stored internally as a sentinal of type /// The location of the clip is stored internally as a sentinel of type
/// SCISSOR. If LLVM were updated to read base types (which it probably /// SCISSOR. If LLVM were updated to read base types (which it probably
/// should because locations of things such as VBases are bogus in the llvm /// should because locations of things such as VBases are bogus in the llvm
/// type anyway) then we could eliminate the SCISSOR. /// type anyway) then we could eliminate the SCISSOR.
/// * Itanium allows nearly empty primary virtual bases. These bases don't get /// * Itanium allows nearly empty primary virtual bases. These bases don't get
/// get their own storage because they're laid out as part of another base /// get their own storage because they're laid out as part of another base
/// or at the beginning of the structure. Determining if a VBase actually /// or at the beginning of the structure. Determining if a VBase actually
/// gets storage awkwardly involves a walk of all bases. /// gets storage awkwardly involves a walk of all bases.
/// * VFPtrs and VBPtrs do *not* make a record NotZeroInitializable. /// * VFPtrs and VBPtrs do *not* make a record NotZeroInitializable.
struct CGRecordLowering { struct CGRecordLowering {
// MemberInfo is a helper structure that contains information about a record // MemberInfo is a helper structure that contains information about a record
// member. In additional to the standard member types, there exists a // member. In additional to the standard member types, there exists a
// sentinal member type that ensures correct rounding. // sentinel member type that ensures correct rounding.
struct MemberInfo { struct MemberInfo {
CharUnits Offset; CharUnits Offset;
enum InfoKind { VFPtr, VBPtr, Field, Base, VBase, Scissor } Kind; enum InfoKind { VFPtr, VBPtr, Field, Base, VBase, Scissor } Kind;
llvm::Type *Data; llvm::Type *Data;
union { union {
const FieldDecl *FD; const FieldDecl *FD;
const CXXRecordDecl *RD; const CXXRecordDecl *RD;
}; };
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Linesstruct CGRecordLowering {
/// not the primary vbase of some base class. /// not the primary vbase of some base class.
bool hasOwnStorage(const CXXRecordDecl *Decl, const CXXRecordDecl *Query); bool hasOwnStorage(const CXXRecordDecl *Decl, const CXXRecordDecl *Query);
void calculateZeroInit(); void calculateZeroInit();
/// \brief Lowers bitfield storage types to I8 arrays for bitfields with tail /// \brief Lowers bitfield storage types to I8 arrays for bitfields with tail
/// padding that is or can potentially be used. /// padding that is or can potentially be used.
void clipTailPadding(); void clipTailPadding();
/// \brief Determines if we need a packed llvm struct. /// \brief Determines if we need a packed llvm struct.
void determinePacked(bool NVBaseType); void determinePacked(bool NVBaseType);
/// \brief Inserts padding everwhere it's needed. /// \brief Inserts padding everywhere it's needed.
void insertPadding(); void insertPadding();
/// \brief Fills out the structures that are ultimately consumed. /// \brief Fills out the structures that are ultimately consumed.
void fillOutputFields(); void fillOutputFields();
// Input memoization fields. // Input memoization fields.
CodeGenTypes &Types; CodeGenTypes &Types;
const ASTContext &Context; const ASTContext &Context;
const RecordDecl *D; const RecordDecl *D;
const CXXRecordDecl *RD; const CXXRecordDecl *RD;
▲ Show 20 Lines • Show All 426 Lines • ▼ Show 20 Linesvoid CGRecordLowering::determinePacked(bool NVBaseType) {
// record's alignment, it must be packed. // record's alignment, it must be packed.
if (Members.back().Offset % Alignment) if (Members.back().Offset % Alignment)
Packed = true; Packed = true;
// If the non-virtual sub-object is not a multiple of the non-virtual // If the non-virtual sub-object is not a multiple of the non-virtual
// sub-object's alignment, it must be packed. We cannot have a packed // sub-object's alignment, it must be packed. We cannot have a packed
// non-virtual sub-object and an unpacked complete object or vise versa. // non-virtual sub-object and an unpacked complete object or vise versa.
if (NVSize % NVAlignment) if (NVSize % NVAlignment)
Packed = true; Packed = true;
// Update the alignment of the sentinal. // Update the alignment of the sentinel.
if (!Packed) if (!Packed)
Members.back().Data = getIntNType(Context.toBits(Alignment)); Members.back().Data = getIntNType(Context.toBits(Alignment));
} }
void CGRecordLowering::insertPadding() { void CGRecordLowering::insertPadding() {
std::vector<std::pair<CharUnits, CharUnits> > Padding; std::vector<std::pair<CharUnits, CharUnits> > Padding;
CharUnits Size = CharUnits::Zero(); CharUnits Size = CharUnits::Zero();
for (std::vector<MemberInfo>::const_iterator Member = Members.begin(), for (std::vector<MemberInfo>::const_iterator Member = Members.begin(),
▲ Show 20 Lines • Show All 255 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/CGStmt.cpp

Show First 20 Lines • Show All 1,031 Lines • ▼ Show 20 Linesvoid CodeGenFunction::EmitReturnStmt(const ReturnStmt &S) {
} }
// Returning from an outlined SEH helper is UB, and we already warn on it. // Returning from an outlined SEH helper is UB, and we already warn on it.
if (IsOutlinedSEHHelper) { if (IsOutlinedSEHHelper) {
Builder.CreateUnreachable(); Builder.CreateUnreachable();
Builder.ClearInsertionPoint(); Builder.ClearInsertionPoint();
} }
// Emit the result value, even if unused, to evalute the side effects. // Emit the result value, even if unused, to evaluate the side effects.
const Expr *RV = S.getRetValue(); const Expr *RV = S.getRetValue();
// Treat block literals in a return expression as if they appeared // Treat block literals in a return expression as if they appeared
// in their own scope. This permits a small, easily-implemented // in their own scope. This permits a small, easily-implemented
// exception to our over-conservative rules about not jumping to // exception to our over-conservative rules about not jumping to
// statements following block literals with non-trivial cleanups. // statements following block literals with non-trivial cleanups.
RunCleanupsScope cleanupScope(*this); RunCleanupsScope cleanupScope(*this);
if (const ExprWithCleanups *cleanups = if (const ExprWithCleanups *cleanups =
▲ Show 20 Lines • Show All 1,279 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp

Show First 20 Lines • Show All 4,455 Lines • ▼ Show 20 Lines bool IsRegistered = PrivateScope.addPrivate(OrigVD, [&]() -> Address {
Address InitAddr = Builder.CreateBitCast(InitAddrIt->second, AddrTy); Address InitAddr = Builder.CreateBitCast(InitAddrIt->second, AddrTy);
setAddrOfLocalVar(InitVD, InitAddr); setAddrOfLocalVar(InitVD, InitAddr);
// Emit private declaration, it will be initialized by the value we // Emit private declaration, it will be initialized by the value we
// declaration we just added to the local declarations map. // declaration we just added to the local declarations map.
EmitDecl(*PvtVD); EmitDecl(*PvtVD);
// The initialization variables reached its purpose in the emission // The initialization variables reached its purpose in the emission
// ofthe previous declaration, so we don't need it anymore. // of the previous declaration, so we don't need it anymore.
LocalDeclMap.erase(InitVD); LocalDeclMap.erase(InitVD);
// Return the address of the private variable. // Return the address of the private variable.
return GetAddrOfLocalVar(PvtVD); return GetAddrOfLocalVar(PvtVD);
}); });
assert(IsRegistered && "firstprivate var already registered as private"); assert(IsRegistered && "firstprivate var already registered as private");
// Silence the warning about unused variable. // Silence the warning about unused variable.
(void)IsRegistered; (void)IsRegistered;
Show All 25 Linesvoid CodeGenFunction::EmitOMPTargetDataDirective(
DevicePointerPrivActionTy PrivAction(PrivatizeDevicePointers); DevicePointerPrivActionTy PrivAction(PrivatizeDevicePointers);
auto &&CodeGen = [&S, &Info, &PrivatizeDevicePointers]( auto &&CodeGen = [&S, &Info, &PrivatizeDevicePointers](
CodeGenFunction &CGF, PrePostActionTy &Action) { CodeGenFunction &CGF, PrePostActionTy &Action) {
auto &&InnermostCodeGen = [&S](CodeGenFunction &CGF, PrePostActionTy &) { auto &&InnermostCodeGen = [&S](CodeGenFunction &CGF, PrePostActionTy &) {
CGF.EmitStmt(S.getInnermostCapturedStmt()->getCapturedStmt()); CGF.EmitStmt(S.getInnermostCapturedStmt()->getCapturedStmt());
}; };
// Codegen that selects wheather to generate the privatization code or not. // Codegen that selects whether to generate the privatization code or not.
auto &&PrivCodeGen = [&S, &Info, &PrivatizeDevicePointers, auto &&PrivCodeGen = [&S, &Info, &PrivatizeDevicePointers,
&InnermostCodeGen](CodeGenFunction &CGF, &InnermostCodeGen](CodeGenFunction &CGF,
PrePostActionTy &Action) { PrePostActionTy &Action) {
RegionCodeGenTy RCG(InnermostCodeGen); RegionCodeGenTy RCG(InnermostCodeGen);
PrivatizeDevicePointers = false; PrivatizeDevicePointers = false;
// Call the pre-action to change the status of PrivatizeDevicePointers if // Call the pre-action to change the status of PrivatizeDevicePointers if
// needed. // needed.
▲ Show 20 Lines • Show All 427 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/CGVTables.cpp

Show First 20 Lines • Show All 864 Lines • ▼ Show 20 Lines switch (RD->getTemplateSpecializationKind()) {
case TSK_ExplicitInstantiationDefinition: case TSK_ExplicitInstantiationDefinition:
return NonDiscardableODRLinkage; return NonDiscardableODRLinkage;
} }
llvm_unreachable("Invalid TemplateSpecializationKind!"); llvm_unreachable("Invalid TemplateSpecializationKind!");
} }
/// This is a callback from Sema to tell us that that a particular vtable is /// This is a callback from Sema to tell us that a particular vtable is
/// required to be emitted in this translation unit. /// required to be emitted in this translation unit.
/// ///
/// This is only called for vtables that _must_ be emitted (mainly due to key /// This is only called for vtables that _must_ be emitted (mainly due to key
/// functions). For weak vtables, CodeGen tracks when they are needed and /// functions). For weak vtables, CodeGen tracks when they are needed and
/// emits them as-needed. /// emits them as-needed.
void CodeGenModule::EmitVTable(CXXRecordDecl *theClass) { void CodeGenModule::EmitVTable(CXXRecordDecl *theClass) {
VTables.GenerateClassData(theClass); VTables.GenerateClassData(theClass);
} }
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/CodeGenFunction.h

Show First 20 Lines • Show All 1,447 Lines • ▼ Show 20 Linesprivate:
llvm::BasicBlock *TrapBB; llvm::BasicBlock *TrapBB;
/// Terminate funclets keyed by parent funclet pad. /// Terminate funclets keyed by parent funclet pad.
llvm::MapVector<llvm::Value *, llvm::BasicBlock *> TerminateFunclets; llvm::MapVector<llvm::Value *, llvm::BasicBlock *> TerminateFunclets;
/// True if we need emit the life-time markers. /// True if we need emit the life-time markers.
const bool ShouldEmitLifetimeMarkers; const bool ShouldEmitLifetimeMarkers;
/// Add OpenCL kernel arg metadata and the kernel attribute meatadata to /// Add OpenCL kernel arg metadata and the kernel attribute metadata to
/// the function metadata. /// the function metadata.
void EmitOpenCLKernelMetadata(const FunctionDecl *FD, void EmitOpenCLKernelMetadata(const FunctionDecl *FD,
llvm::Function *Fn); llvm::Function *Fn);
public: public:
CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext=false); CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext=false);
~CodeGenFunction(); ~CodeGenFunction();
▲ Show 20 Lines • Show All 247 Lines • ▼ Show 20 Lines llvm::Function *GenerateVarArgsThunk(llvm::Function *Fn,
const CGFunctionInfo &FnInfo, const CGFunctionInfo &FnInfo,
GlobalDecl GD, const ThunkInfo &Thunk); GlobalDecl GD, const ThunkInfo &Thunk);
void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type, void EmitCtorPrologue(const CXXConstructorDecl *CD, CXXCtorType Type,
FunctionArgList &Args); FunctionArgList &Args);
void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init); void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init);
/// Struct with all informations about dynamic [sub]class needed to set vptr. /// Struct with all information about dynamic [sub]class needed to set vptr.
struct VPtr { struct VPtr {
BaseSubobject Base; BaseSubobject Base;
const CXXRecordDecl *NearestVBase; const CXXRecordDecl *NearestVBase;
CharUnits OffsetFromNearestVBase; CharUnits OffsetFromNearestVBase;
const CXXRecordDecl *VTableClass; const CXXRecordDecl *VTableClass;
}; };
/// Initialize the vtable pointer of the given subobject. /// Initialize the vtable pointer of the given subobject.
▲ Show 20 Lines • Show All 2,481 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/CodeGenModule.h

Show First 20 Lines • Show All 771 Lines • ▼ Show 20 Linespublic:
/// ///
/// For languages without explicit address spaces, if D has default address /// For languages without explicit address spaces, if D has default address
/// space, target-specific global or constant address space may be returned. /// space, target-specific global or constant address space may be returned.
LangAS GetGlobalVarAddressSpace(const VarDecl *D); LangAS GetGlobalVarAddressSpace(const VarDecl *D);
/// Return the llvm::Constant for the address of the given global variable. /// Return the llvm::Constant for the address of the given global variable.
/// If Ty is non-null and if the global doesn't exist, then it will be created /// If Ty is non-null and if the global doesn't exist, then it will be created
/// with the specified type instead of whatever the normal requested type /// with the specified type instead of whatever the normal requested type
/// would be. If IsForDefinition is true, it is guranteed that an actual /// would be. If IsForDefinition is true, it is guaranteed that an actual
/// global with type Ty will be returned, not conversion of a variable with /// global with type Ty will be returned, not conversion of a variable with
/// the same mangled name but some other type. /// the same mangled name but some other type.
llvm::Constant *GetAddrOfGlobalVar(const VarDecl *D, llvm::Constant *GetAddrOfGlobalVar(const VarDecl *D,
llvm::Type *Ty = nullptr, llvm::Type *Ty = nullptr,
ForDefinition_t IsForDefinition ForDefinition_t IsForDefinition
= NotForDefinition); = NotForDefinition);
/// Return the address of the given function. If Ty is non-null, then this /// Return the address of the given function. If Ty is non-null, then this
▲ Show 20 Lines • Show All 384 Lines • ▼ Show 20 Linespublic:
SanitizerMetadata *getSanitizerMetadata() { SanitizerMetadata *getSanitizerMetadata() {
return SanitizerMD.get(); return SanitizerMD.get();
} }
void addDeferredVTable(const CXXRecordDecl *RD) { void addDeferredVTable(const CXXRecordDecl *RD) {
DeferredVTables.push_back(RD); DeferredVTables.push_back(RD);
} }
/// Emit code for a singal global function or var decl. Forward declarations /// Emit code for a single global function or var decl. Forward declarations
/// are emitted lazily. /// are emitted lazily.
void EmitGlobal(GlobalDecl D); void EmitGlobal(GlobalDecl D);
bool TryEmitDefinitionAsAlias(GlobalDecl Alias, GlobalDecl Target); bool TryEmitDefinitionAsAlias(GlobalDecl Alias, GlobalDecl Target);
bool TryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D); bool TryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D);
llvm::GlobalValue *GetGlobalValue(StringRef Ref); llvm::GlobalValue *GetGlobalValue(StringRef Ref);
▲ Show 20 Lines • Show All 211 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/CodeGenModule.cpp

Show First 20 Lines • Show All 2,669 Lines • ▼ Show 20 Lines
/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module, /// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
/// create and return an llvm GlobalVariable with the specified type. If there /// create and return an llvm GlobalVariable with the specified type. If there
/// is something in the module with the specified name, return it potentially /// is something in the module with the specified name, return it potentially
/// bitcasted to the right type. /// bitcasted to the right type.
/// ///
/// If D is non-null, it specifies a decl that correspond to this. This is used /// If D is non-null, it specifies a decl that correspond to this. This is used
/// to set the attributes on the global when it is first created. /// to set the attributes on the global when it is first created.
/// ///
/// If IsForDefinition is true, it is guranteed that an actual global with /// If IsForDefinition is true, it is guaranteed that an actual global with
/// type Ty will be returned, not conversion of a variable with the same /// type Ty will be returned, not conversion of a variable with the same
/// mangled name but some other type. /// mangled name but some other type.
llvm::Constant * llvm::Constant *
CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
llvm::PointerType *Ty, llvm::PointerType *Ty,
const VarDecl *D, const VarDecl *D,
ForDefinition_t IsForDefinition) { ForDefinition_t IsForDefinition) {
// Lookup the entry, lazily creating it if necessary. // Lookup the entry, lazily creating it if necessary.
▲ Show 20 Lines • Show All 242 Lines • ▼ Show 20 Lines if (supportsCOMDAT() && GV->isWeakForLinker() &&
GV->setComdat(TheModule.getOrInsertComdat(GV->getName())); GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
return GV; return GV;
} }
/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
/// given global variable. If Ty is non-null and if the global doesn't exist, /// given global variable. If Ty is non-null and if the global doesn't exist,
/// then it will be created with the specified type instead of whatever the /// then it will be created with the specified type instead of whatever the
/// normal requested type would be. If IsForDefinition is true, it is guranteed /// normal requested type would be. If IsForDefinition is true, it is guaranteed
/// that an actual global with type Ty will be returned, not conversion of a /// that an actual global with type Ty will be returned, not conversion of a
/// variable with the same mangled name but some other type. /// variable with the same mangled name but some other type.
llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D, llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
llvm::Type *Ty, llvm::Type *Ty,
ForDefinition_t IsForDefinition) { ForDefinition_t IsForDefinition) {
assert(D->hasGlobalStorage() && "Not a global variable"); assert(D->hasGlobalStorage() && "Not a global variable");
QualType ASTTy = D->getType(); QualType ASTTy = D->getType();
if (!Ty) if (!Ty)
▲ Show 20 Lines • Show All 379 Lines • ▼ Show 20 Linesstatic bool isVarDeclStrongDefinition(const ASTContext &Context,
if (D->getInit() || D->hasExternalStorage()) if (D->getInit() || D->hasExternalStorage())
return true; return true;
// A variable cannot be both common and exist in a section. // A variable cannot be both common and exist in a section.
if (D->hasAttr<SectionAttr>()) if (D->hasAttr<SectionAttr>())
return true; return true;
// A variable cannot be both common and exist in a section. // A variable cannot be both common and exist in a section.
// We dont try to determine which is the right section in the front-end. // We don't try to determine which is the right section in the front-end.
// If no specialized section name is applicable, it will resort to default. // If no specialized section name is applicable, it will resort to default.
if (D->hasAttr<PragmaClangBSSSectionAttr>() || if (D->hasAttr<PragmaClangBSSSectionAttr>() ||
D->hasAttr<PragmaClangDataSectionAttr>() || D->hasAttr<PragmaClangDataSectionAttr>() ||
D->hasAttr<PragmaClangRodataSectionAttr>()) D->hasAttr<PragmaClangRodataSectionAttr>())
return true; return true;
// Thread local vars aren't considered common linkage. // Thread local vars aren't considered common linkage.
if (D->getTLSKind()) if (D->getTLSKind())
▲ Show 20 Lines • Show All 841 Lines • ▼ Show 20 LinesConstantAddress CodeGenModule::GetAddrOfGlobalTemporary(
// Create a global variable for this lifetime-extended temporary. // Create a global variable for this lifetime-extended temporary.
llvm::GlobalValue::LinkageTypes Linkage = llvm::GlobalValue::LinkageTypes Linkage =
getLLVMLinkageVarDefinition(VD, Constant); getLLVMLinkageVarDefinition(VD, Constant);
if (Linkage == llvm::GlobalVariable::ExternalLinkage) { if (Linkage == llvm::GlobalVariable::ExternalLinkage) {
const VarDecl *InitVD; const VarDecl *InitVD;
if (VD->isStaticDataMember() && VD->getAnyInitializer(InitVD) && if (VD->isStaticDataMember() && VD->getAnyInitializer(InitVD) &&
isa<CXXRecordDecl>(InitVD->getLexicalDeclContext())) { isa<CXXRecordDecl>(InitVD->getLexicalDeclContext())) {
// Temporaries defined inside a class get linkonce_odr linkage because the // Temporaries defined inside a class get linkonce_odr linkage because the
// class can be defined in multipe translation units. // class can be defined in multiple translation units.
Linkage = llvm::GlobalVariable::LinkOnceODRLinkage; Linkage = llvm::GlobalVariable::LinkOnceODRLinkage;
} else { } else {
// There is no need for this temporary to have external linkage if the // There is no need for this temporary to have external linkage if the
// VarDecl has external linkage. // VarDecl has external linkage.
Linkage = llvm::GlobalVariable::InternalLinkage; Linkage = llvm::GlobalVariable::InternalLinkage;
} }
} }
auto TargetAS = getContext().getTargetAddressSpace(AddrSpace); auto TargetAS = getContext().getTargetAddressSpace(AddrSpace);
▲ Show 20 Lines • Show All 822 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/CoverageMappingGen.cpp

Show First 20 Lines • Show All 292 Lines • ▼ Show 20 Lines for (const auto &I : SkippedRanges) {
auto CovFileID = getCoverageFileID(LocStart); auto CovFileID = getCoverageFileID(LocStart);
if (!CovFileID) if (!CovFileID)
continue; continue;
SpellingRegion SR{SM, LocStart, LocEnd}; SpellingRegion SR{SM, LocStart, LocEnd};
auto Region = CounterMappingRegion::makeSkipped( auto Region = CounterMappingRegion::makeSkipped(
*CovFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd); *CovFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd);
// Make sure that we only collect the regions that are inside // Make sure that we only collect the regions that are inside
// the souce code of this function. // the source code of this function.
if (Region.LineStart >= FileLineRanges[*CovFileID].first && if (Region.LineStart >= FileLineRanges[*CovFileID].first &&
Region.LineEnd <= FileLineRanges[*CovFileID].second) Region.LineEnd <= FileLineRanges[*CovFileID].second)
MappingRegions.push_back(Region); MappingRegions.push_back(Region);
} }
} }
/// \brief Generate the coverage counter mapping regions from collected /// \brief Generate the coverage counter mapping regions from collected
/// source regions. /// source regions.
▲ Show 20 Lines • Show All 1,142 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp

Show First 20 Lines • Show All 1,430 Lines • ▼ Show 20 Lines
} }
void ItaniumCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) { void ItaniumCXXABI::EmitInstanceFunctionProlog(CodeGenFunction &CGF) {
// Naked functions have no prolog. // Naked functions have no prolog.
if (CGF.CurFuncDecl && CGF.CurFuncDecl->hasAttr<NakedAttr>()) if (CGF.CurFuncDecl && CGF.CurFuncDecl->hasAttr<NakedAttr>())
return; return;
/// Initialize the 'this' slot. In the Itanium C++ ABI, no prologue /// Initialize the 'this' slot. In the Itanium C++ ABI, no prologue
/// adjustments are required, becuase they are all handled by thunks. /// adjustments are required, because they are all handled by thunks.
setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF)); setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF));
/// Initialize the 'vtt' slot if needed. /// Initialize the 'vtt' slot if needed.
if (getStructorImplicitParamDecl(CGF)) { if (getStructorImplicitParamDecl(CGF)) {
getStructorImplicitParamValue(CGF) = CGF.Builder.CreateLoad( getStructorImplicitParamValue(CGF) = CGF.Builder.CreateLoad(
CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)), "vtt"); CGF.GetAddrOfLocalVar(getStructorImplicitParamDecl(CGF)), "vtt");
} }
▲ Show 20 Lines • Show All 2,599 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/MicrosoftCXXABI.cpp

Show First 20 Lines • Show All 3,357 Lines • ▼ Show 20 Lines
// //
// ClassHieararchyDescriptor: Contains information about a class hierarchy. // ClassHieararchyDescriptor: Contains information about a class hierarchy.
// Used during dynamic_cast to walk a class hierarchy. References a base // Used during dynamic_cast to walk a class hierarchy. References a base
// class array and the size of said array. // class array and the size of said array.
// //
// BaseClassArray: Contains a list of classes in a hierarchy. BaseClassArray is // BaseClassArray: Contains a list of classes in a hierarchy. BaseClassArray is
// somewhat of a misnomer because the most derived class is also in the list // somewhat of a misnomer because the most derived class is also in the list
// as well as multiple copies of virtual bases (if they occur multiple times // as well as multiple copies of virtual bases (if they occur multiple times
// in the hiearchy.) The BaseClassArray contains one BaseClassDescriptor for // in the hierarchy.) The BaseClassArray contains one BaseClassDescriptor for
// every path in the hierarchy, in pre-order depth first order. Note, we do // every path in the hierarchy, in pre-order depth first order. Note, we do
// not declare a specific llvm type for BaseClassArray, it's merely an array // not declare a specific llvm type for BaseClassArray, it's merely an array
// of BaseClassDescriptor pointers. // of BaseClassDescriptor pointers.
// //
// BaseClassDescriptor: Contains information about a class in a class hierarchy. // BaseClassDescriptor: Contains information about a class in a class hierarchy.
// BaseClassDescriptor is also somewhat of a misnomer for the same reason that // BaseClassDescriptor is also somewhat of a misnomer for the same reason that
// BaseClassArray is. It contains information about a class within a // BaseClassArray is. It contains information about a class within a
// hierarchy such as: is this base is ambiguous and what is its offset in the // hierarchy such as: is this base is ambiguous and what is its offset in the
▲ Show 20 Lines • Show All 531 Lines • ▼ Show 20 LinesMicrosoftCXXABI::getAddrOfCXXCtorClosure(const CXXConstructorDecl *CD,
// Constructors for classes which utilize virtual bases have an additional // Constructors for classes which utilize virtual bases have an additional
// parameter which indicates whether or not it is being delegated to by a more // parameter which indicates whether or not it is being delegated to by a more
// derived constructor. // derived constructor.
ImplicitParamDecl IsMostDerived(getContext(), /*DC=*/nullptr, ImplicitParamDecl IsMostDerived(getContext(), /*DC=*/nullptr,
SourceLocation(), SourceLocation(),
&getContext().Idents.get("is_most_derived"), &getContext().Idents.get("is_most_derived"),
getContext().IntTy, ImplicitParamDecl::Other); getContext().IntTy, ImplicitParamDecl::Other);
// Only add the parameter to the list if thie class has virtual bases. // Only add the parameter to the list if the class has virtual bases.
if (RD->getNumVBases() > 0) if (RD->getNumVBases() > 0)
FunctionArgs.push_back(&IsMostDerived); FunctionArgs.push_back(&IsMostDerived);
// Start defining the function. // Start defining the function.
auto NL = ApplyDebugLocation::CreateEmpty(CGF); auto NL = ApplyDebugLocation::CreateEmpty(CGF);
CGF.StartFunction(GlobalDecl(), FnInfo.getReturnType(), ThunkFn, FnInfo, CGF.StartFunction(GlobalDecl(), FnInfo.getReturnType(), ThunkFn, FnInfo,
FunctionArgs, CD->getLocation(), SourceLocation()); FunctionArgs, CD->getLocation(), SourceLocation());
// Create a scope with an artificial location for the body of this function. // Create a scope with an artificial location for the body of this function.
▲ Show 20 Lines • Show All 352 Lines • Show Last 20 Lines

cfe/trunk/lib/CodeGen/TargetInfo.h

Show First 20 Lines • Show All 260 Lines • ▼ Show 20 Lines virtual llvm::Constant *performAddrSpaceCast(CodeGenModule &CGM,
llvm::Constant *V, llvm::Constant *V,
LangAS SrcAddr, LangAS DestAddr, LangAS SrcAddr, LangAS DestAddr,
llvm::Type *DestTy) const; llvm::Type *DestTy) const;
/// Get the syncscope used in LLVM IR. /// Get the syncscope used in LLVM IR.
virtual llvm::SyncScope::ID getLLVMSyncScopeID(SyncScope S, virtual llvm::SyncScope::ID getLLVMSyncScopeID(SyncScope S,
llvm::LLVMContext &C) const; llvm::LLVMContext &C) const;
/// Inteface class for filling custom fields of a block literal for OpenCL. /// Interface class for filling custom fields of a block literal for OpenCL.
class TargetOpenCLBlockHelper { class TargetOpenCLBlockHelper {
public: public:
typedef std::pair<llvm::Value *, StringRef> ValueTy; typedef std::pair<llvm::Value *, StringRef> ValueTy;
TargetOpenCLBlockHelper() {} TargetOpenCLBlockHelper() {}
virtual ~TargetOpenCLBlockHelper() {} virtual ~TargetOpenCLBlockHelper() {}
/// Get the custom field types for OpenCL blocks. /// Get the custom field types for OpenCL blocks.
virtual llvm::SmallVector<llvm::Type *, 1> getCustomFieldTypes() = 0; virtual llvm::SmallVector<llvm::Type *, 1> getCustomFieldTypes() = 0;
/// Get the custom field values for OpenCL blocks. /// Get the custom field values for OpenCL blocks.
Show All 32 Lines

cfe/trunk/lib/CodeGen/VarBypassDetector.cpp

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 Lines for (auto *I : DS->decls())
if (!BuildScopeInformation(I, origParentScope)) if (!BuildScopeInformation(I, origParentScope))
return false; return false;
return true; return true;
} }
case Stmt::CaseStmtClass: case Stmt::CaseStmtClass:
case Stmt::DefaultStmtClass: case Stmt::DefaultStmtClass:
case Stmt::LabelStmtClass: case Stmt::LabelStmtClass:
llvm_unreachable("the loop bellow handles labels and cases"); llvm_unreachable("the loop below handles labels and cases");
break; break;
default: default:
break; break;
} }
for (const Stmt *SubStmt : S->children()) { for (const Stmt *SubStmt : S->children()) {
if (!SubStmt) if (!SubStmt)
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

cfe/trunk/lib/Driver/Driver.cpp

Show First 20 Lines • Show All 390 Lines • ▼ Show 20 Linesstatic llvm::Triple computeTargetTriple(const Driver &D,
// FIXME: Already done in Compilation *Driver::BuildCompilation // FIXME: Already done in Compilation *Driver::BuildCompilation
if (const Arg *A = Args.getLastArg(options::OPT_target)) if (const Arg *A = Args.getLastArg(options::OPT_target))
DefaultTargetTriple = A->getValue(); DefaultTargetTriple = A->getValue();
llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple)); llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple));
// Handle Apple-specific options available here. // Handle Apple-specific options available here.
if (Target.isOSBinFormatMachO()) { if (Target.isOSBinFormatMachO()) {
// If an explict Darwin arch name is given, that trumps all. // If an explicit Darwin arch name is given, that trumps all.
if (!DarwinArchName.empty()) { if (!DarwinArchName.empty()) {
tools::darwin::setTripleTypeForMachOArchName(Target, DarwinArchName); tools::darwin::setTripleTypeForMachOArchName(Target, DarwinArchName);
return Target; return Target;
} }
// Handle the Darwin '-arch' flag. // Handle the Darwin '-arch' flag.
if (Arg *A = Args.getLastArg(options::OPT_arch)) { if (Arg *A = Args.getLastArg(options::OPT_arch)) {
StringRef ArchName = A->getValue(); StringRef ArchName = A->getValue();
▲ Show 20 Lines • Show All 3,929 Lines • Show Last 20 Lines

cfe/trunk/lib/Driver/ToolChains/Arch/ARM.cpp

Show First 20 Lines • Show All 393 Lines • ▼ Show 20 Linesvoid arm::getARMTargetFeatures(const ToolChain &TC,
// Setting -msoft-float/-mfloat-abi=soft effectively disables the FPU (GCC // Setting -msoft-float/-mfloat-abi=soft effectively disables the FPU (GCC
// ignores the -mfpu options in this case). // ignores the -mfpu options in this case).
// Note that the ABI can also be set implicitly by the target selected. // Note that the ABI can also be set implicitly by the target selected.
if (ABI == arm::FloatABI::Soft) { if (ABI == arm::FloatABI::Soft) {
llvm::ARM::getFPUFeatures(llvm::ARM::FK_NONE, Features); llvm::ARM::getFPUFeatures(llvm::ARM::FK_NONE, Features);
// Disable hardware FP features which have been enabled. // Disable hardware FP features which have been enabled.
// FIXME: Disabling vfp2 and neon should be enough as all the other // FIXME: Disabling vfp2 and neon should be enough as all the other
// features are dependant on these 2 features in LLVM. However // features are dependent on these 2 features in LLVM. However
// there is currently no easy way to test this in clang, so for // there is currently no easy way to test this in clang, so for
// now just be explicit and disable all known dependent features // now just be explicit and disable all known dependent features
// as well. // as well.
for (std::string Feature : {"vfp2", "vfp3", "vfp4", "fp-armv8", "fullfp16", for (std::string Feature : {"vfp2", "vfp3", "vfp4", "fp-armv8", "fullfp16",
"neon", "crypto", "dotprod"}) "neon", "crypto", "dotprod"})
if (std::find(std::begin(Features), std::end(Features), "+" + Feature) != std::end(Features)) if (std::find(std::begin(Features), std::end(Features), "+" + Feature) != std::end(Features))
Features.push_back(Args.MakeArgString("-" + Feature)); Features.push_back(Args.MakeArgString("-" + Feature));
} }
▲ Show 20 Lines • Show All 191 Lines • Show Last 20 Lines

cfe/trunk/lib/Driver/ToolChains/Clang.cpp

Show First 20 Lines • Show All 1,687 Lines • ▼ Show 20 Lines if (ABIName) {
CmdArgs.push_back("-target-abi"); CmdArgs.push_back("-target-abi");
CmdArgs.push_back(ABIName); CmdArgs.push_back(ABIName);
} }
} }
void Clang::AddRISCVTargetArgs(const ArgList &Args, void Clang::AddRISCVTargetArgs(const ArgList &Args,
ArgStringList &CmdArgs) const { ArgStringList &CmdArgs) const {
// FIXME: currently defaults to the soft-float ABIs. Will need to be // FIXME: currently defaults to the soft-float ABIs. Will need to be
// expanded to select ilp32f, ilp32d, lp64f, lp64d when appropiate. // expanded to select ilp32f, ilp32d, lp64f, lp64d when appropriate.
const char *ABIName = nullptr; const char *ABIName = nullptr;
const llvm::Triple &Triple = getToolChain().getTriple(); const llvm::Triple &Triple = getToolChain().getTriple();
if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
ABIName = A->getValue(); ABIName = A->getValue();
else if (Triple.getArch() == llvm::Triple::riscv32) else if (Triple.getArch() == llvm::Triple::riscv32)
ABIName = "ilp32"; ABIName = "ilp32";
else if (Triple.getArch() == llvm::Triple::riscv64) else if (Triple.getArch() == llvm::Triple::riscv64)
ABIName = "lp64"; ABIName = "lp64";
▲ Show 20 Lines • Show All 377 Lines • ▼ Show 20 Lines
} }
static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D, static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
bool OFastEnabled, const ArgList &Args, bool OFastEnabled, const ArgList &Args,
ArgStringList &CmdArgs) { ArgStringList &CmdArgs) {
// Handle various floating point optimization flags, mapping them to the // Handle various floating point optimization flags, mapping them to the
// appropriate LLVM code generation flags. This is complicated by several // appropriate LLVM code generation flags. This is complicated by several
// "umbrella" flags, so we do this by stepping through the flags incrementally // "umbrella" flags, so we do this by stepping through the flags incrementally
// adjusting what we think is enabled/disabled, then at the end settting the // adjusting what we think is enabled/disabled, then at the end setting the
// LLVM flags based on the final state. // LLVM flags based on the final state.
bool HonorINFs = true; bool HonorINFs = true;
bool HonorNaNs = true; bool HonorNaNs = true;
// -fmath-errno is the default on some platforms, e.g. BSD-derived OSes. // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
bool MathErrno = TC.IsMathErrnoDefault(); bool MathErrno = TC.IsMathErrnoDefault();
bool AssociativeMath = false; bool AssociativeMath = false;
bool ReciprocalMath = false; bool ReciprocalMath = false;
bool SignedZeros = true; bool SignedZeros = true;
▲ Show 20 Lines • Show All 2,143 Lines • ▼ Show 20 Lines#endif
// -fthreadsafe-static is default, except for MSVC compatibility versions less // -fthreadsafe-static is default, except for MSVC compatibility versions less
// than 19. // than 19.
if (!Args.hasFlag(options::OPT_fthreadsafe_statics, if (!Args.hasFlag(options::OPT_fthreadsafe_statics,
options::OPT_fno_threadsafe_statics, options::OPT_fno_threadsafe_statics,
!IsWindowsMSVC || IsMSVC2015Compatible)) !IsWindowsMSVC || IsMSVC2015Compatible))
CmdArgs.push_back("-fno-threadsafe-statics"); CmdArgs.push_back("-fno-threadsafe-statics");
// -fno-delayed-template-parsing is default, except when targetting MSVC. // -fno-delayed-template-parsing is default, except when targeting MSVC.
// Many old Windows SDK versions require this to parse. // Many old Windows SDK versions require this to parse.
// FIXME: MSVC introduced /Zc:twoPhase- to disable this behavior in their // FIXME: MSVC introduced /Zc:twoPhase- to disable this behavior in their
// compiler. We should be able to disable this by default at some point. // compiler. We should be able to disable this by default at some point.
if (Args.hasFlag(options::OPT_fdelayed_template_parsing, if (Args.hasFlag(options::OPT_fdelayed_template_parsing,
options::OPT_fno_delayed_template_parsing, IsWindowsMSVC)) options::OPT_fno_delayed_template_parsing, IsWindowsMSVC))
CmdArgs.push_back("-fdelayed-template-parsing"); CmdArgs.push_back("-fdelayed-template-parsing");
// -fgnu-keywords default varies depending on language; only pass if // -fgnu-keywords default varies depending on language; only pass if
▲ Show 20 Lines • Show All 1,363 Lines • Show Last 20 Lines

cfe/trunk/lib/Driver/ToolChains/CommonArgs.cpp

Show First 20 Lines • Show All 995 Lines • ▼ Show 20 Linestools::ParsePICArgs(const ToolChain &ToolChain, const ArgList &Args) {
Arg *LastRWPIArg = Args.getLastArg(options::OPT_frwpi, options::OPT_fno_rwpi); Arg *LastRWPIArg = Args.getLastArg(options::OPT_frwpi, options::OPT_fno_rwpi);
if (LastRWPIArg && LastRWPIArg->getOption().matches(options::OPT_frwpi)) { if (LastRWPIArg && LastRWPIArg->getOption().matches(options::OPT_frwpi)) {
if (!EmbeddedPISupported) if (!EmbeddedPISupported)
ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target) ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
<< LastRWPIArg->getSpelling() << Triple.str(); << LastRWPIArg->getSpelling() << Triple.str();
RWPI = true; RWPI = true;
} }
// ROPI and RWPI are not comaptible with PIC or PIE. // ROPI and RWPI are not compatible with PIC or PIE.
if ((ROPI || RWPI) && (PIC || PIE)) if ((ROPI || RWPI) && (PIC || PIE))
ToolChain.getDriver().Diag(diag::err_drv_ropi_rwpi_incompatible_with_pic); ToolChain.getDriver().Diag(diag::err_drv_ropi_rwpi_incompatible_with_pic);
// When targettng MIPS64 with N64, the default is PIC, unless -mno-abicalls is // When targettng MIPS64 with N64, the default is PIC, unless -mno-abicalls is
// used. // used.
if ((Triple.getArch() == llvm::Triple::mips64 || if ((Triple.getArch() == llvm::Triple::mips64 ||
Triple.getArch() == llvm::Triple::mips64el) && Triple.getArch() == llvm::Triple::mips64el) &&
Args.hasArg(options::OPT_mno_abicalls)) Args.hasArg(options::OPT_mno_abicalls))
▲ Show 20 Lines • Show All 216 Lines • Show Last 20 Lines

cfe/trunk/lib/Driver/ToolChains/Cuda.cpp

Show First 20 Lines • Show All 178 Lines • ▼ Show 20 Lines if (Version >= CudaVersion::CUDA_90) {
// Process all bitcode filenames that look like // Process all bitcode filenames that look like
// libdevice.compute_XX.YY.bc // libdevice.compute_XX.YY.bc
const StringRef LibDeviceName = "libdevice."; const StringRef LibDeviceName = "libdevice.";
if (!(FileName.startswith(LibDeviceName) && FileName.endswith(".bc"))) if (!(FileName.startswith(LibDeviceName) && FileName.endswith(".bc")))
continue; continue;
StringRef GpuArch = FileName.slice( StringRef GpuArch = FileName.slice(
LibDeviceName.size(), FileName.find('.', LibDeviceName.size())); LibDeviceName.size(), FileName.find('.', LibDeviceName.size()));
LibDeviceMap[GpuArch] = FilePath.str(); LibDeviceMap[GpuArch] = FilePath.str();
// Insert map entries for specifc devices with this compute // Insert map entries for specific devices with this compute
// capability. NVCC's choice of the libdevice library version is // capability. NVCC's choice of the libdevice library version is
// rather peculiar and depends on the CUDA version. // rather peculiar and depends on the CUDA version.
if (GpuArch == "compute_20") { if (GpuArch == "compute_20") {
LibDeviceMap["sm_20"] = FilePath; LibDeviceMap["sm_20"] = FilePath;
LibDeviceMap["sm_21"] = FilePath; LibDeviceMap["sm_21"] = FilePath;
LibDeviceMap["sm_32"] = FilePath; LibDeviceMap["sm_32"] = FilePath;
} else if (GpuArch == "compute_30") { } else if (GpuArch == "compute_30") {
LibDeviceMap["sm_30"] = FilePath; LibDeviceMap["sm_30"] = FilePath;
▲ Show 20 Lines • Show All 567 Lines • Show Last 20 Lines

cfe/trunk/lib/Format/UnwrappedLineParser.h

Show First 20 Lines • Show All 135 Lines • ▼ Show 20 Linesprivate:
// Decides which comment tokens should be added to the current line and which // Decides which comment tokens should be added to the current line and which
// should be added as comments before the next token. // should be added as comments before the next token.
// //
// Comments specifies the sequence of comment tokens to analyze. They get // Comments specifies the sequence of comment tokens to analyze. They get
// either pushed to the current line or added to the comments before the next // either pushed to the current line or added to the comments before the next
// token. // token.
// //
// NextTok specifies the next token. A null pointer NextTok is supported, and // NextTok specifies the next token. A null pointer NextTok is supported, and
// signifies either the absense of a next token, or that the next token // signifies either the absence of a next token, or that the next token
// shouldn't be taken into accunt for the analysis. // shouldn't be taken into accunt for the analysis.
void distributeComments(const SmallVectorImpl<FormatToken *> &Comments, void distributeComments(const SmallVectorImpl<FormatToken *> &Comments,
const FormatToken *NextTok); const FormatToken *NextTok);
// Adds the comment preceding the next token to unwrapped lines. // Adds the comment preceding the next token to unwrapped lines.
void flushComments(bool NewlineBeforeNext); void flushComments(bool NewlineBeforeNext);
void pushToken(FormatToken *Tok); void pushToken(FormatToken *Tok);
void calculateBraceTypes(bool ExpectClassBody = false); void calculateBraceTypes(bool ExpectClassBody = false);
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

cfe/trunk/lib/Frontend/ASTMerge.cpp

//===-- ASTMerge.cpp - AST Merging Frontent Action --------------*- C++ -*-===// //===-- ASTMerge.cpp - AST Merging Frontend Action --------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "clang/Frontend/ASTUnit.h" #include "clang/Frontend/ASTUnit.h"
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

cfe/trunk/lib/Frontend/CompilerInstance.cpp

Show First 20 Lines • Show All 1,294 Lines • ▼ Show 20 Lines case llvm::LockFileManager::LFS_Shared:
case llvm::LockFileManager::Res_OwnerDied: case llvm::LockFileManager::Res_OwnerDied:
continue; // try again to get the lock. continue; // try again to get the lock.
case llvm::LockFileManager::Res_Timeout: case llvm::LockFileManager::Res_Timeout:
// Since PCMCache takes care of correctness, we try waiting for another // Since PCMCache takes care of correctness, we try waiting for another
// process to complete the build so clang does not do it done twice. If // process to complete the build so clang does not do it done twice. If
// case of timeout, build it ourselves. // case of timeout, build it ourselves.
Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout) Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout)
<< Module->Name; << Module->Name;
// Clear the lock file so that future invokations can make progress. // Clear the lock file so that future invocations can make progress.
Locked.unsafeRemoveLockFile(); Locked.unsafeRemoveLockFile();
continue; continue;
} }
break; break;
} }
// Try to read the module file, now that we've compiled it. // Try to read the module file, now that we've compiled it.
ASTReader::ASTReadResult ReadResult = ASTReader::ASTReadResult ReadResult =
▲ Show 20 Lines • Show All 827 Lines • Show Last 20 Lines

cfe/trunk/lib/Frontend/DiagnosticRenderer.cpp

Show First 20 Lines • Show All 180 Lines • ▼ Show 20 Linesvoid DiagnosticRenderer::emitIncludeStack(FullSourceLoc Loc, PresumedLoc PLoc,
if (IncludeLoc.isValid()) if (IncludeLoc.isValid())
emitIncludeStackRecursively(IncludeLoc); emitIncludeStackRecursively(IncludeLoc);
else { else {
emitModuleBuildStack(Loc.getManager()); emitModuleBuildStack(Loc.getManager());
emitImportStack(Loc); emitImportStack(Loc);
} }
} }
/// \brief Helper to recursivly walk up the include stack and print each layer /// \brief Helper to recursively walk up the include stack and print each layer
/// on the way back down. /// on the way back down.
void DiagnosticRenderer::emitIncludeStackRecursively(FullSourceLoc Loc) { void DiagnosticRenderer::emitIncludeStackRecursively(FullSourceLoc Loc) {
if (Loc.isInvalid()) { if (Loc.isInvalid()) {
emitModuleBuildStack(Loc.getManager()); emitModuleBuildStack(Loc.getManager());
return; return;
} }
PresumedLoc PLoc = Loc.getPresumedLoc(DiagOpts->ShowPresumedLoc); PresumedLoc PLoc = Loc.getPresumedLoc(DiagOpts->ShowPresumedLoc);
Show All 24 Lines if (Loc.isInvalid()) {
emitModuleBuildStack(Loc.getManager()); emitModuleBuildStack(Loc.getManager());
return; return;
} }
std::pair<FullSourceLoc, StringRef> NextImportLoc = Loc.getModuleImportLoc(); std::pair<FullSourceLoc, StringRef> NextImportLoc = Loc.getModuleImportLoc();
emitImportStackRecursively(NextImportLoc.first, NextImportLoc.second); emitImportStackRecursively(NextImportLoc.first, NextImportLoc.second);
} }
/// \brief Helper to recursivly walk up the import stack and print each layer /// \brief Helper to recursively walk up the import stack and print each layer
/// on the way back down. /// on the way back down.
void DiagnosticRenderer::emitImportStackRecursively(FullSourceLoc Loc, void DiagnosticRenderer::emitImportStackRecursively(FullSourceLoc Loc,
StringRef ModuleName) { StringRef ModuleName) {
if (ModuleName.empty()) { if (ModuleName.empty()) {
return; return;
} }
PresumedLoc PLoc = Loc.getPresumedLoc(DiagOpts->ShowPresumedLoc); PresumedLoc PLoc = Loc.getPresumedLoc(DiagOpts->ShowPresumedLoc);
▲ Show 20 Lines • Show All 204 Lines • ▼ Show 20 Linesstatic bool checkLocForMacroArgExpansion(SourceLocation Loc,
if (SM.isMacroArgExpansion(Loc, &MacroLoc)) { if (SM.isMacroArgExpansion(Loc, &MacroLoc)) {
if (ArgumentLoc == MacroLoc) return true; if (ArgumentLoc == MacroLoc) return true;
} }
return false; return false;
} }
/// Check if all the locations in the range have the same macro argument /// Check if all the locations in the range have the same macro argument
/// expansion, and that that expansion starts with ArgumentLoc. /// expansion, and that the expansion starts with ArgumentLoc.
static bool checkRangeForMacroArgExpansion(CharSourceRange Range, static bool checkRangeForMacroArgExpansion(CharSourceRange Range,
const SourceManager &SM, const SourceManager &SM,
SourceLocation ArgumentLoc) { SourceLocation ArgumentLoc) {
SourceLocation BegLoc = Range.getBegin(), EndLoc = Range.getEnd(); SourceLocation BegLoc = Range.getBegin(), EndLoc = Range.getEnd();
while (BegLoc != EndLoc) { while (BegLoc != EndLoc) {
if (!checkLocForMacroArgExpansion(BegLoc, SM, ArgumentLoc)) if (!checkLocForMacroArgExpansion(BegLoc, SM, ArgumentLoc))
return false; return false;
BegLoc.getLocWithOffset(1); BegLoc.getLocWithOffset(1);
▲ Show 20 Lines • Show All 151 Lines • Show Last 20 Lines

cfe/trunk/lib/Frontend/ModuleDependencyCollector.cpp

Show First 20 Lines • Show All 129 Lines • ▼ Show 20 Linesstatic bool isCaseSensitivePath(StringRef Path) {
SmallString<256> TmpDest = Path, UpperDest, RealDest; SmallString<256> TmpDest = Path, UpperDest, RealDest;
// Remove component traversals, links, etc. // Remove component traversals, links, etc.
if (!real_path(Path, TmpDest)) if (!real_path(Path, TmpDest))
return true; // Current default value in vfs.yaml return true; // Current default value in vfs.yaml
Path = TmpDest; Path = TmpDest;
// Change path to all upper case and ask for its real path, if the latter // Change path to all upper case and ask for its real path, if the latter
// exists and is equal to Path, it's not case sensitive. Default to case // exists and is equal to Path, it's not case sensitive. Default to case
// sensitive in the absense of realpath, since this is what the VFSWriter // sensitive in the absence of realpath, since this is what the VFSWriter
// already expects when sensitivity isn't setup. // already expects when sensitivity isn't setup.
for (auto &C : Path) for (auto &C : Path)
UpperDest.push_back(toUppercase(C)); UpperDest.push_back(toUppercase(C));
if (real_path(UpperDest, RealDest) && Path.equals(RealDest)) if (real_path(UpperDest, RealDest) && Path.equals(RealDest))
return false; return false;
return true; return true;
} }
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

cfe/trunk/lib/Frontend/Rewrite/RewriteModernObjC.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 6,741 Lines • ▼ Show 20 Linesstatic void Write_IvarOffsetVar(RewriteModernObjC &RewriteObj,
ArrayRef<ObjCIvarDecl *> Ivars, ArrayRef<ObjCIvarDecl *> Ivars,
ObjCInterfaceDecl *CDecl) { ObjCInterfaceDecl *CDecl) {
// FIXME. visibilty of offset symbols may have to be set; for Darwin // FIXME. visibilty of offset symbols may have to be set; for Darwin
// this is what happens: // this is what happens:
/** /**
if (Ivar->getAccessControl() == ObjCIvarDecl::Private || if (Ivar->getAccessControl() == ObjCIvarDecl::Private ||
Ivar->getAccessControl() == ObjCIvarDecl::Package || Ivar->getAccessControl() == ObjCIvarDecl::Package ||
Class->getVisibility() == HiddenVisibility) Class->getVisibility() == HiddenVisibility)
Visibility shoud be: HiddenVisibility; Visibility should be: HiddenVisibility;
else else
Visibility shoud be: DefaultVisibility; Visibility should be: DefaultVisibility;
*/ */
Result += "\n"; Result += "\n";
for (unsigned i =0, e = Ivars.size(); i < e; i++) { for (unsigned i =0, e = Ivars.size(); i < e; i++) {
ObjCIvarDecl *IvarDecl = Ivars[i]; ObjCIvarDecl *IvarDecl = Ivars[i];
if (Context->getLangOpts().MicrosoftExt) if (Context->getLangOpts().MicrosoftExt)
Result += "__declspec(allocate(\".objc_ivar$B\")) "; Result += "__declspec(allocate(\".objc_ivar$B\")) ";
▲ Show 20 Lines • Show All 830 Lines • Show Last 20 Lines

cfe/trunk/lib/Frontend/SerializedDiagnosticPrinter.cpp

Show First 20 Lines • Show All 456 Lines • ▼ Show 20 Linesvoid SDiagsWriter::EmitBlockInfoBlock() {
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Diag level. Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Diag level.
AddSourceLocationAbbrev(*Abbrev); AddSourceLocationAbbrev(*Abbrev);
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Category. Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Category.
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID. Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 10)); // Mapped Diag ID.
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // Text size. Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // Text size.
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Diagnostc text. Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Diagnostc text.
Abbrevs.set(RECORD_DIAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev)); Abbrevs.set(RECORD_DIAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
// Emit abbrevation for RECORD_CATEGORY. // Emit abbreviation for RECORD_CATEGORY.
Abbrev = std::make_shared<BitCodeAbbrev>(); Abbrev = std::make_shared<BitCodeAbbrev>();
Abbrev->Add(BitCodeAbbrevOp(RECORD_CATEGORY)); Abbrev->Add(BitCodeAbbrevOp(RECORD_CATEGORY));
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Category ID. Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Category ID.
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); // Text size. Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8)); // Text size.
Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Category text. Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Category text.
Abbrevs.set(RECORD_CATEGORY, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev)); Abbrevs.set(RECORD_CATEGORY, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
// Emit abbrevation for RECORD_SOURCE_RANGE. // Emit abbreviation for RECORD_SOURCE_RANGE.
Abbrev = std::make_shared<BitCodeAbbrev>(); Abbrev = std::make_shared<BitCodeAbbrev>();
Abbrev->Add(BitCodeAbbrevOp(RECORD_SOURCE_RANGE)); Abbrev->Add(BitCodeAbbrevOp(RECORD_SOURCE_RANGE));
AddRangeLocationAbbrev(*Abbrev); AddRangeLocationAbbrev(*Abbrev);
Abbrevs.set(RECORD_SOURCE_RANGE, Abbrevs.set(RECORD_SOURCE_RANGE,
Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev)); Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
// Emit the abbreviation for RECORD_DIAG_FLAG. // Emit the abbreviation for RECORD_DIAG_FLAG.
Abbrev = std::make_shared<BitCodeAbbrev>(); Abbrev = std::make_shared<BitCodeAbbrev>();
▲ Show 20 Lines • Show All 377 Lines • Show Last 20 Lines

cfe/trunk/lib/Headers/__clang_cuda_builtin_vars.h

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines#define __CUDA_DEVICE_BUILTIN(FIELD, INTRINSIC) \
} }
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
#define __DELETE =delete #define __DELETE =delete
#else #else
#define __DELETE #define __DELETE
#endif #endif
// Make sure nobody can create instances of the special varible types. nvcc // Make sure nobody can create instances of the special variable types. nvcc
// also disallows taking address of special variables, so we disable address-of // also disallows taking address of special variables, so we disable address-of
// operator as well. // operator as well.
#define __CUDA_DISALLOW_BUILTINVAR_ACCESS(TypeName) \ #define __CUDA_DISALLOW_BUILTINVAR_ACCESS(TypeName) \
__attribute__((device)) TypeName() __DELETE; \ __attribute__((device)) TypeName() __DELETE; \
__attribute__((device)) TypeName(const TypeName &) __DELETE; \ __attribute__((device)) TypeName(const TypeName &) __DELETE; \
__attribute__((device)) void operator=(const TypeName &) const __DELETE; \ __attribute__((device)) void operator=(const TypeName &) const __DELETE; \
__attribute__((device)) TypeName *operator&() const __DELETE __attribute__((device)) TypeName *operator&() const __DELETE
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

cfe/trunk/lib/Headers/__wmmintrin_aes.h

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Lines
/// A 128-bit integer vector containing the expanded key. /// A 128-bit integer vector containing the expanded key.
/// \returns A 128-bit integer vector containing the transformed value. /// \returns A 128-bit integer vector containing the transformed value.
static __inline__ __m128i __DEFAULT_FN_ATTRS static __inline__ __m128i __DEFAULT_FN_ATTRS
_mm_aesimc_si128(__m128i __V) _mm_aesimc_si128(__m128i __V)
{ {
return (__m128i)__builtin_ia32_aesimc128((__v2di)__V); return (__m128i)__builtin_ia32_aesimc128((__v2di)__V);
} }
/// \brief Generates a round key for AES encyption, operating on 128-bit data /// \brief Generates a round key for AES encryption, operating on 128-bit data
/// specified in the first source operand and using an 8-bit round constant /// specified in the first source operand and using an 8-bit round constant
/// specified by the second source operand, and writes the result to the /// specified by the second source operand, and writes the result to the
/// destination. /// destination.
/// ///
/// \headerfile <x86intrin.h> /// \headerfile <x86intrin.h>
/// ///
/// \code /// \code
/// __m128i _mm_aeskeygenassist_si128(__m128i C, const int R); /// __m128i _mm_aeskeygenassist_si128(__m128i C, const int R);
Show All 15 Lines

cfe/trunk/lib/Headers/htmxlintrin.h

Show First 20 Lines • Show All 208 Lines • ▼ Show 20 Lines
#endif /* __powerpc__ */ #endif /* __powerpc__ */
#ifdef __s390__ #ifdef __s390__
#include <stdint.h> #include <stdint.h>
/* These intrinsics are being made available for compatibility with /* These intrinsics are being made available for compatibility with
the IBM XL compiler. For documentation please see the "z/OS XL the IBM XL compiler. For documentation please see the "z/OS XL
C/C++ Programming Guide" publically available on the web. */ C/C++ Programming Guide" publicly available on the web. */
static __inline long __attribute__((__always_inline__, __nodebug__)) static __inline long __attribute__((__always_inline__, __nodebug__))
__TM_simple_begin () __TM_simple_begin ()
{ {
return __builtin_tbegin_nofloat (0); return __builtin_tbegin_nofloat (0);
} }
static __inline long __attribute__((__always_inline__, __nodebug__)) static __inline long __attribute__((__always_inline__, __nodebug__))
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

cfe/trunk/lib/Headers/stdint.h

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
* that is represented in the standard integer types. * that is represented in the standard integer types.
* *
* The standard also requires minimum-width types be defined for 8-, 16-, 32-, * The standard also requires minimum-width types be defined for 8-, 16-, 32-,
* and 64-bit widths regardless of whether there are corresponding exact-width * and 64-bit widths regardless of whether there are corresponding exact-width
* types. * types.
* *
* To accommodate targets that are missing types that are exactly 8, 16, 32, or * To accommodate targets that are missing types that are exactly 8, 16, 32, or
* 64 bits wide, this implementation takes an approach of cascading * 64 bits wide, this implementation takes an approach of cascading
* redefintions, redefining __int_leastN_t to successively smaller exact-width * redefinitions, redefining __int_leastN_t to successively smaller exact-width
* types. It is therefore important that the types are defined in order of * types. It is therefore important that the types are defined in order of
* descending widths. * descending widths.
* *
* We currently assume that the minimum-width types and the fastest * We currently assume that the minimum-width types and the fastest
* minimum-width types are the same. This is allowed by the standard, but is * minimum-width types are the same. This is allowed by the standard, but is
* suboptimal. * suboptimal.
* *
* In violation of the standard, some targets do not implement a type that is * In violation of the standard, some targets do not implement a type that is
▲ Show 20 Lines • Show All 356 Lines • ▼ Show 20 Lines
* The presence of limit macros are completely optional in C99. This * The presence of limit macros are completely optional in C99. This
* implementation defines limits for all of the types (exact- and * implementation defines limits for all of the types (exact- and
* minimum-width) that it defines above, using the limits of the minimum-width * minimum-width) that it defines above, using the limits of the minimum-width
* type for any types that do not have exact-width representations. * type for any types that do not have exact-width representations.
* *
* As in the type definitions, this section takes an approach of * As in the type definitions, this section takes an approach of
* successive-shrinking to determine which limits to use for the standard (8, * successive-shrinking to determine which limits to use for the standard (8,
* 16, 32, 64) bit widths when they don't have exact representations. It is * 16, 32, 64) bit widths when they don't have exact representations. It is
* therefore important that the defintions be kept in order of decending * therefore important that the definitions be kept in order of decending
* widths. * widths.
* *
* Note that C++ should not check __STDC_LIMIT_MACROS here, contrary to the * Note that C++ should not check __STDC_LIMIT_MACROS here, contrary to the
* claims of the C standard (see C++ 18.3.1p2, [cstdint.syn]). * claims of the C standard (see C++ 18.3.1p2, [cstdint.syn]).
*/ */
#ifdef __INT64_TYPE__ #ifdef __INT64_TYPE__
# define INT64_MAX INT64_C( 9223372036854775807) # define INT64_MAX INT64_C( 9223372036854775807)
▲ Show 20 Lines • Show All 232 Lines • Show Last 20 Lines

cfe/trunk/lib/Lex/HeaderSearch.cpp

Show First 20 Lines • Show All 205 Lines • ▼ Show 20 LinesModule *HeaderSearch::lookupModule(StringRef ModuleName, bool AllowSearch) {
StringRef SearchName = ModuleName; StringRef SearchName = ModuleName;
Module = lookupModule(ModuleName, SearchName); Module = lookupModule(ModuleName, SearchName);
// The facility for "private modules" -- adjacent, optional module maps named // The facility for "private modules" -- adjacent, optional module maps named
// module.private.modulemap that are supposed to define private submodules -- // module.private.modulemap that are supposed to define private submodules --
// may have different flavors of names: FooPrivate, Foo_Private and Foo.Private. // may have different flavors of names: FooPrivate, Foo_Private and Foo.Private.
// //
// Foo.Private is now depracated in favor of Foo_Private. Users of FooPrivate // Foo.Private is now deprecated in favor of Foo_Private. Users of FooPrivate
// should also rename to Foo_Private. Representing private as submodules // should also rename to Foo_Private. Representing private as submodules
// could force building unwanted dependencies into the parent module and cause // could force building unwanted dependencies into the parent module and cause
// dependency cycles. // dependency cycles.
if (!Module && SearchName.consume_back("_Private")) if (!Module && SearchName.consume_back("_Private"))
Module = lookupModule(ModuleName, SearchName); Module = lookupModule(ModuleName, SearchName);
if (!Module && SearchName.consume_back("Private")) if (!Module && SearchName.consume_back("Private"))
Module = lookupModule(ModuleName, SearchName); Module = lookupModule(ModuleName, SearchName);
return Module; return Module;
▲ Show 20 Lines • Show All 1,418 Lines • Show Last 20 Lines

cfe/trunk/lib/Lex/Lexer.cpp

Show First 20 Lines • Show All 965 Lines • ▼ Show 20 LinesStringRef Lexer::getSourceText(CharSourceRange Range,
if (Invalid) *Invalid = false; if (Invalid) *Invalid = false;
return file.substr(beginInfo.second, EndOffs - beginInfo.second); return file.substr(beginInfo.second, EndOffs - beginInfo.second);
} }
StringRef Lexer::getImmediateMacroName(SourceLocation Loc, StringRef Lexer::getImmediateMacroName(SourceLocation Loc,
const SourceManager &SM, const SourceManager &SM,
const LangOptions &LangOpts) { const LangOptions &LangOpts) {
assert(Loc.isMacroID() && "Only reasonble to call this on macros"); assert(Loc.isMacroID() && "Only reasonable to call this on macros");
// Find the location of the immediate macro expansion. // Find the location of the immediate macro expansion.
while (true) { while (true) {
FileID FID = SM.getFileID(Loc); FileID FID = SM.getFileID(Loc);
const SrcMgr::SLocEntry *E = &SM.getSLocEntry(FID); const SrcMgr::SLocEntry *E = &SM.getSLocEntry(FID);
const SrcMgr::ExpansionInfo &Expansion = E->getExpansion(); const SrcMgr::ExpansionInfo &Expansion = E->getExpansion();
Loc = Expansion.getExpansionLocStart(); Loc = Expansion.getExpansionLocStart();
if (!Expansion.isMacroArgExpansion()) if (!Expansion.isMacroArgExpansion())
Show All 29 LinesStringRef Lexer::getImmediateMacroName(SourceLocation Loc,
std::pair<FileID, unsigned> ExpansionInfo = SM.getDecomposedLoc(Loc); std::pair<FileID, unsigned> ExpansionInfo = SM.getDecomposedLoc(Loc);
unsigned MacroTokenLength = Lexer::MeasureTokenLength(Loc, SM, LangOpts); unsigned MacroTokenLength = Lexer::MeasureTokenLength(Loc, SM, LangOpts);
StringRef ExpansionBuffer = SM.getBufferData(ExpansionInfo.first); StringRef ExpansionBuffer = SM.getBufferData(ExpansionInfo.first);
return ExpansionBuffer.substr(ExpansionInfo.second, MacroTokenLength); return ExpansionBuffer.substr(ExpansionInfo.second, MacroTokenLength);
} }
StringRef Lexer::getImmediateMacroNameForDiagnostics( StringRef Lexer::getImmediateMacroNameForDiagnostics(
SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts) { SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts) {
assert(Loc.isMacroID() && "Only reasonble to call this on macros"); assert(Loc.isMacroID() && "Only reasonable to call this on macros");
// Walk past macro argument expanions. // Walk past macro argument expanions.
while (SM.isMacroArgExpansion(Loc)) while (SM.isMacroArgExpansion(Loc))
Loc = SM.getImmediateExpansionRange(Loc).first; Loc = SM.getImmediateExpansionRange(Loc).first;
// If the macro's spelling has no FileID, then it's actually a token paste // If the macro's spelling has no FileID, then it's actually a token paste
// or stringization (or similar) and not a macro at all. // or stringization (or similar) and not a macro at all.
if (!SM.getFileEntryForID(SM.getFileID(SM.getSpellingLoc(Loc)))) if (!SM.getFileEntryForID(SM.getFileID(SM.getSpellingLoc(Loc))))
return {}; return {};
▲ Show 20 Lines • Show All 1,129 Lines • ▼ Show 20 Lines if (SawNewline) {
TokAtPhysicalStartOfLine = true; TokAtPhysicalStartOfLine = true;
} }
BufferPtr = CurPtr; BufferPtr = CurPtr;
return false; return false;
} }
/// We have just read the // characters from input. Skip until we find the /// We have just read the // characters from input. Skip until we find the
/// newline character thats terminate the comment. Then update BufferPtr and /// newline character that terminates the comment. Then update BufferPtr and
/// return. /// return.
/// ///
/// If we're in KeepCommentMode or any CommentHandler has inserted /// If we're in KeepCommentMode or any CommentHandler has inserted
/// some tokens, this will store the first token and return true. /// some tokens, this will store the first token and return true.
bool Lexer::SkipLineComment(Token &Result, const char *CurPtr, bool Lexer::SkipLineComment(Token &Result, const char *CurPtr,
bool &TokAtPhysicalStartOfLine) { bool &TokAtPhysicalStartOfLine) {
// If Line comments aren't explicitly enabled for this language, emit an // If Line comments aren't explicitly enabled for this language, emit an
// extension warning. // extension warning.
▲ Show 20 Lines • Show All 1,332 Lines • ▼ Show 20 LinesLexNextToken:
case '/': case '/':
// 6.4.9: Comments // 6.4.9: Comments
Char = getCharAndSize(CurPtr, SizeTmp); Char = getCharAndSize(CurPtr, SizeTmp);
if (Char == '/') { // Line comment. if (Char == '/') { // Line comment.
// Even if Line comments are disabled (e.g. in C89 mode), we generally // Even if Line comments are disabled (e.g. in C89 mode), we generally
// want to lex this as a comment. There is one problem with this though, // want to lex this as a comment. There is one problem with this though,
// that in one particular corner case, this can change the behavior of the // that in one particular corner case, this can change the behavior of the
// resultant program. For example, In "foo //**/ bar", C89 would lex // resultant program. For example, In "foo //**/ bar", C89 would lex
// this as "foo / bar" and langauges with Line comments would lex it as // this as "foo / bar" and languages with Line comments would lex it as
// "foo". Check to see if the character after the second slash is a '*'. // "foo". Check to see if the character after the second slash is a '*'.
// If so, we will lex that as a "/" instead of the start of a comment. // If so, we will lex that as a "/" instead of the start of a comment.
// However, we never do this if we are just preprocessing. // However, we never do this if we are just preprocessing.
bool TreatAsComment = LangOpts.LineComment && bool TreatAsComment = LangOpts.LineComment &&
(LangOpts.CPlusPlus || !LangOpts.TraditionalCPP); (LangOpts.CPlusPlus || !LangOpts.TraditionalCPP);
if (!TreatAsComment) if (!TreatAsComment)
if (!(PP && PP->isPreprocessedOutput())) if (!(PP && PP->isPreprocessedOutput()))
TreatAsComment = getCharAndSize(CurPtr+SizeTmp, SizeTmp2) != '*'; TreatAsComment = getCharAndSize(CurPtr+SizeTmp, SizeTmp2) != '*';
▲ Show 20 Lines • Show All 355 Lines • Show Last 20 Lines

cfe/trunk/lib/Lex/MacroArgs.cpp

Show First 20 Lines • Show All 267 Lines • ▼ Show 20 Lines if (tok::isStringLiteral(Tok.getKind()) || // "foo", u8R"x(foo)x"_bar, etc.
Result.resize(CurStrLen+ActualTokLen); Result.resize(CurStrLen+ActualTokLen);
} }
} }
} }
// If the last character of the string is a \, and if it isn't escaped, this // If the last character of the string is a \, and if it isn't escaped, this
// is an invalid string literal, diagnose it as specified in C99. // is an invalid string literal, diagnose it as specified in C99.
if (Result.back() == '\\') { if (Result.back() == '\\') {
// Count the number of consequtive \ characters. If even, then they are // Count the number of consecutive \ characters. If even, then they are
// just escaped backslashes, otherwise it's an error. // just escaped backslashes, otherwise it's an error.
unsigned FirstNonSlash = Result.size()-2; unsigned FirstNonSlash = Result.size()-2;
// Guaranteed to find the starting " if nothing else. // Guaranteed to find the starting " if nothing else.
while (Result[FirstNonSlash] == '\\') while (Result[FirstNonSlash] == '\\')
--FirstNonSlash; --FirstNonSlash;
if ((Result.size()-1-FirstNonSlash) & 1) { if ((Result.size()-1-FirstNonSlash) & 1) {
// Diagnose errors for things like: #define F(X) #X / F(\) // Diagnose errors for things like: #define F(X) #X / F(\)
PP.Diag(ArgToks[-1], diag::pp_invalid_string_literal); PP.Diag(ArgToks[-1], diag::pp_invalid_string_literal);
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

cfe/trunk/lib/Lex/PPDirectives.cpp

Show First 20 Lines • Show All 1,358 Lines • ▼ Show 20 Linesvoid Preprocessor::HandleUserDiagnosticDirective(Token &Tok,
bool isWarning) { bool isWarning) {
// PTH doesn't emit #warning or #error directives. // PTH doesn't emit #warning or #error directives.
if (CurPTHLexer) if (CurPTHLexer)
return CurPTHLexer->DiscardToEndOfLine(); return CurPTHLexer->DiscardToEndOfLine();
// Read the rest of the line raw. We do this because we don't want macros // Read the rest of the line raw. We do this because we don't want macros
// to be expanded and we don't require that the tokens be valid preprocessing // to be expanded and we don't require that the tokens be valid preprocessing
// tokens. For example, this is allowed: "#warning ` 'foo". GCC does // tokens. For example, this is allowed: "#warning ` 'foo". GCC does
// collapse multiple consequtive white space between tokens, but this isn't // collapse multiple consecutive white space between tokens, but this isn't
// specified by the standard. // specified by the standard.
SmallString<128> Message; SmallString<128> Message;
CurLexer->ReadToEndOfLine(&Message); CurLexer->ReadToEndOfLine(&Message);
// Find the first non-whitespace character, so that we can make the // Find the first non-whitespace character, so that we can make the
// diagnostic more succinct. // diagnostic more succinct.
StringRef Msg = StringRef(Message).ltrim(' '); StringRef Msg = StringRef(Message).ltrim(' ');
▲ Show 20 Lines • Show All 1,560 Lines • Show Last 20 Lines

cfe/trunk/lib/Lex/PTHLexer.cpp

Show First 20 Lines • Show All 209 Lines • ▼ Show 20 Lines do {
uint32_t Offset = endian::readNext<uint32_t, little, aligned>(CurPPCondPtr); uint32_t Offset = endian::readNext<uint32_t, little, aligned>(CurPPCondPtr);
// Read the target table index from the side-table. // Read the target table index from the side-table.
TableIdx = endian::readNext<uint32_t, little, aligned>(CurPPCondPtr); TableIdx = endian::readNext<uint32_t, little, aligned>(CurPPCondPtr);
// Compute the actual memory address of the '#' token data for this entry. // Compute the actual memory address of the '#' token data for this entry.
HashEntryI = TokBuf + Offset; HashEntryI = TokBuf + Offset;
// Optmization: "Sibling jumping". #if...#else...#endif blocks can // Optimization: "Sibling jumping". #if...#else...#endif blocks can
// contain nested blocks. In the side-table we can jump over these // contain nested blocks. In the side-table we can jump over these
// nested blocks instead of doing a linear search if the next "sibling" // nested blocks instead of doing a linear search if the next "sibling"
// entry is not at a location greater than LastHashTokPtr. // entry is not at a location greater than LastHashTokPtr.
if (HashEntryI < LastHashTokPtr && TableIdx) { if (HashEntryI < LastHashTokPtr && TableIdx) {
// In the side-table we are still at an entry for a '#' token that // In the side-table we are still at an entry for a '#' token that
// is earlier than the last one we saw. Check if the location we would // is earlier than the last one we saw. Check if the location we would
// stride gets us closer. // stride gets us closer.
const unsigned char* NextPPCondPtr = const unsigned char* NextPPCondPtr =
▲ Show 20 Lines • Show All 522 Lines • Show Last 20 Lines

cfe/trunk/lib/Lex/TokenLexer.cpp

Show First 20 Lines • Show All 477 Lines • ▼ Show 20 Lines for (unsigned I = 0, E = NumTokens; I != E; ++I) {
// Okay, we have a token that is either the LHS or RHS of a paste (##) // Okay, we have a token that is either the LHS or RHS of a paste (##)
// argument. It gets substituted as its non-pre-expanded tokens. // argument. It gets substituted as its non-pre-expanded tokens.
const Token *ArgToks = ActualArgs->getUnexpArgument(ArgNo); const Token *ArgToks = ActualArgs->getUnexpArgument(ArgNo);
unsigned NumToks = MacroArgs::getArgLength(ArgToks); unsigned NumToks = MacroArgs::getArgLength(ArgToks);
if (NumToks) { // Not an empty argument? if (NumToks) { // Not an empty argument?
bool VaArgsPseudoPaste = false; bool VaArgsPseudoPaste = false;
// If this is the GNU ", ## __VA_ARGS__" extension, and we just learned // If this is the GNU ", ## __VA_ARGS__" extension, and we just learned
// that __VA_ARGS__ expands to multiple tokens, avoid a pasting error when // that __VA_ARGS__ expands to multiple tokens, avoid a pasting error when
// the expander trys to paste ',' with the first token of the __VA_ARGS__ // the expander tries to paste ',' with the first token of the __VA_ARGS__
// expansion. // expansion.
if (NonEmptyPasteBefore && ResultToks.size() >= 2 && if (NonEmptyPasteBefore && ResultToks.size() >= 2 &&
ResultToks[ResultToks.size()-2].is(tok::comma) && ResultToks[ResultToks.size()-2].is(tok::comma) &&
(unsigned)ArgNo == Macro->getNumParams()-1 && (unsigned)ArgNo == Macro->getNumParams()-1 &&
Macro->isVariadic()) { Macro->isVariadic()) {
VaArgsPseudoPaste = true; VaArgsPseudoPaste = true;
// Remove the paste operator, report use of the extension. // Remove the paste operator, report use of the extension.
PP.Diag(ResultToks.pop_back_val().getLocation(), diag::ext_paste_comma); PP.Diag(ResultToks.pop_back_val().getLocation(), diag::ext_paste_comma);
▲ Show 20 Lines • Show All 546 Lines • Show Last 20 Lines

cfe/trunk/lib/Parse/ParseDecl.cpp

Show First 20 Lines • Show All 2,462 Lines • ▼ Show 20 Lines
bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS, bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
const ParsedTemplateInfo &TemplateInfo, const ParsedTemplateInfo &TemplateInfo,
AccessSpecifier AS, DeclSpecContext DSC, AccessSpecifier AS, DeclSpecContext DSC,
ParsedAttributesWithRange &Attrs) { ParsedAttributesWithRange &Attrs) {
assert(Tok.is(tok::identifier) && "should have identifier"); assert(Tok.is(tok::identifier) && "should have identifier");
SourceLocation Loc = Tok.getLocation(); SourceLocation Loc = Tok.getLocation();
// If we see an identifier that is not a type name, we normally would // If we see an identifier that is not a type name, we normally would
// parse it as the identifer being declared. However, when a typename // parse it as the identifier being declared. However, when a typename
// is typo'd or the definition is not included, this will incorrectly // is typo'd or the definition is not included, this will incorrectly
// parse the typename as the identifier name and fall over misparsing // parse the typename as the identifier name and fall over misparsing
// later parts of the diagnostic. // later parts of the diagnostic.
// //
// As such, we try to do some look-ahead in cases where this would // As such, we try to do some look-ahead in cases where this would
// otherwise be an "implicit-int" case to see if this is invalid. For // otherwise be an "implicit-int" case to see if this is invalid. For
// example: "static foo_t x = 4;" In this case, if we parsed foo_t as // example: "static foo_t x = 4;" In this case, if we parsed foo_t as
// an identifier with implicit int, we'd get a parse error because the // an identifier with implicit int, we'd get a parse error because the
▲ Show 20 Lines • Show All 2,639 Lines • ▼ Show 20 Lines case tok::kw___read_write:
ParseOpenCLQualifiers(DS.getAttributes()); ParseOpenCLQualifiers(DS.getAttributes());
break; break;
case tok::kw___unaligned: case tok::kw___unaligned:
isInvalid = DS.SetTypeQual(DeclSpec::TQ_unaligned, Loc, PrevSpec, DiagID, isInvalid = DS.SetTypeQual(DeclSpec::TQ_unaligned, Loc, PrevSpec, DiagID,
getLangOpts()); getLangOpts());
break; break;
case tok::kw___uptr: case tok::kw___uptr:
// GNU libc headers in C mode use '__uptr' as an identifer which conflicts // GNU libc headers in C mode use '__uptr' as an identifier which conflicts
// with the MS modifier keyword. // with the MS modifier keyword.
if ((AttrReqs & AR_DeclspecAttributesParsed) && !getLangOpts().CPlusPlus && if ((AttrReqs & AR_DeclspecAttributesParsed) && !getLangOpts().CPlusPlus &&
IdentifierRequired && DS.isEmpty() && NextToken().is(tok::semi)) { IdentifierRequired && DS.isEmpty() && NextToken().is(tok::semi)) {
if (TryKeywordIdentFallback(false)) if (TryKeywordIdentFallback(false))
continue; continue;
} }
LLVM_FALLTHROUGH; LLVM_FALLTHROUGH;
case tok::kw___sptr: case tok::kw___sptr:
▲ Show 20 Lines • Show All 1,753 Lines • Show Last 20 Lines

cfe/trunk/lib/Parse/ParsePragma.cpp

Show First 20 Lines • Show All 1,239 Lines • ▼ Show 20 Lines if (IsAny)
if (AnyParens.consumeClose()) if (AnyParens.consumeClose())
return true; return true;
return false; return false;
} }
namespace { namespace {
/// Describes the stage at which attribute subject rule parsing was interruped. /// Describes the stage at which attribute subject rule parsing was interrupted.
enum class MissingAttributeSubjectRulesRecoveryPoint { enum class MissingAttributeSubjectRulesRecoveryPoint {
Comma, Comma,
ApplyTo, ApplyTo,
Equals, Equals,
Any, Any,
None, None,
}; };
▲ Show 20 Lines • Show All 1,102 Lines • ▼ Show 20 Linesvoid PragmaMSPragma::HandlePragma(Preprocessor &PP,
AnnotTok.setLocation(Tok.getLocation()); AnnotTok.setLocation(Tok.getLocation());
AnnotTok.setAnnotationEndLoc(Tok.getLocation()); AnnotTok.setAnnotationEndLoc(Tok.getLocation());
SmallVector<Token, 8> TokenVector; SmallVector<Token, 8> TokenVector;
// Suck up all of the tokens before the eod. // Suck up all of the tokens before the eod.
for (; Tok.isNot(tok::eod); PP.Lex(Tok)) { for (; Tok.isNot(tok::eod); PP.Lex(Tok)) {
TokenVector.push_back(Tok); TokenVector.push_back(Tok);
AnnotTok.setAnnotationEndLoc(Tok.getLocation()); AnnotTok.setAnnotationEndLoc(Tok.getLocation());
} }
// Add a sentinal EoF token to the end of the list. // Add a sentinel EoF token to the end of the list.
TokenVector.push_back(EoF); TokenVector.push_back(EoF);
// We must allocate this array with new because EnterTokenStream is going to // We must allocate this array with new because EnterTokenStream is going to
// delete it later. // delete it later.
auto TokenArray = llvm::make_unique<Token[]>(TokenVector.size()); auto TokenArray = llvm::make_unique<Token[]>(TokenVector.size());
std::copy(TokenVector.begin(), TokenVector.end(), TokenArray.get()); std::copy(TokenVector.begin(), TokenVector.end(), TokenArray.get());
auto Value = new (PP.getPreprocessorAllocator()) auto Value = new (PP.getPreprocessorAllocator())
std::pair<std::unique_ptr<Token[]>, size_t>(std::move(TokenArray), std::pair<std::unique_ptr<Token[]>, size_t>(std::move(TokenArray),
TokenVector.size()); TokenVector.size());
▲ Show 20 Lines • Show All 765 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/SemaAttr.cpp

Show First 20 Lines • Show All 199 Lines • ▼ Show 20 Lines if (AlignmentVal == Sema::kMac68kAlignmentSentinel)
Diag(PragmaLoc, diag::warn_pragma_pack_show) << "mac68k"; Diag(PragmaLoc, diag::warn_pragma_pack_show) << "mac68k";
else else
Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal; Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal;
} }
// MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack: // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack:
// "#pragma pack(pop, identifier, n) is undefined" // "#pragma pack(pop, identifier, n) is undefined"
if (Action & Sema::PSK_Pop) { if (Action & Sema::PSK_Pop) {
if (Alignment && !SlotLabel.empty()) if (Alignment && !SlotLabel.empty())
Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifer_and_alignment); Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifier_and_alignment);
if (PackStack.Stack.empty()) if (PackStack.Stack.empty())
Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "pack" << "stack empty"; Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "pack" << "stack empty";
} }
PackStack.Act(PragmaLoc, Action, SlotLabel, AlignmentVal); PackStack.Act(PragmaLoc, Action, SlotLabel, AlignmentVal);
} }
void Sema::DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind, void Sema::DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind,
▲ Show 20 Lines • Show All 599 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/SemaCast.cpp

Show First 20 Lines • Show All 1,139 Lines • ▼ Show 20 Lines if (SrcPointee->isVoidType()) {
} }
else if (CStyle && DestType->isBlockPointerType()) { else if (CStyle && DestType->isBlockPointerType()) {
// allow c-style cast of void * to block pointers. // allow c-style cast of void * to block pointers.
Kind = CK_AnyPointerToBlockPointerCast; Kind = CK_AnyPointerToBlockPointerCast;
return TC_Success; return TC_Success;
} }
} }
} }
// Allow arbitray objective-c pointer conversion with static casts. // Allow arbitrary objective-c pointer conversion with static casts.
if (SrcType->isObjCObjectPointerType() && if (SrcType->isObjCObjectPointerType() &&
DestType->isObjCObjectPointerType()) { DestType->isObjCObjectPointerType()) {
Kind = CK_BitCast; Kind = CK_BitCast;
return TC_Success; return TC_Success;
} }
// Allow ns-pointer to cf-pointer conversion in either direction // Allow ns-pointer to cf-pointer conversion in either direction
// with static casts. // with static casts.
if (!CStyle && if (!CStyle &&
▲ Show 20 Lines • Show All 1,545 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/SemaChecking.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,655 Lines • ▼ Show 20 Linesbool Sema::CheckMipsBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
case Mips::BI__builtin_msa_sat_u_h: case Mips::BI__builtin_msa_sat_u_h:
case Mips::BI__builtin_msa_slli_h: case Mips::BI__builtin_msa_slli_h:
case Mips::BI__builtin_msa_srai_h: case Mips::BI__builtin_msa_srai_h:
case Mips::BI__builtin_msa_srari_h: case Mips::BI__builtin_msa_srari_h:
case Mips::BI__builtin_msa_srli_h: case Mips::BI__builtin_msa_srli_h:
case Mips::BI__builtin_msa_srlri_h: i = 1; l = 0; u = 15; break; case Mips::BI__builtin_msa_srlri_h: i = 1; l = 0; u = 15; break;
case Mips::BI__builtin_msa_binsli_h: case Mips::BI__builtin_msa_binsli_h:
case Mips::BI__builtin_msa_binsri_h: i = 2; l = 0; u = 15; break; case Mips::BI__builtin_msa_binsri_h: i = 2; l = 0; u = 15; break;
// These intrinsics take an unsigned 5 bit immedate. // These intrinsics take an unsigned 5 bit immediate.
// The first block of intrinsics actually have an unsigned 5 bit field, // The first block of intrinsics actually have an unsigned 5 bit field,
// not a df/n field. // not a df/n field.
case Mips::BI__builtin_msa_clei_u_b: case Mips::BI__builtin_msa_clei_u_b:
case Mips::BI__builtin_msa_clei_u_h: case Mips::BI__builtin_msa_clei_u_h:
case Mips::BI__builtin_msa_clei_u_w: case Mips::BI__builtin_msa_clei_u_w:
case Mips::BI__builtin_msa_clei_u_d: case Mips::BI__builtin_msa_clei_u_d:
case Mips::BI__builtin_msa_clti_u_b: case Mips::BI__builtin_msa_clti_u_b:
case Mips::BI__builtin_msa_clti_u_h: case Mips::BI__builtin_msa_clti_u_h:
▲ Show 20 Lines • Show All 3,947 Lines • ▼ Show 20 Linesvoid CheckFormatHandler::EmitFormatDiagnostic(PartialDiagnostic PDiag,
SourceLocation Loc, SourceLocation Loc,
bool IsStringLocation, bool IsStringLocation,
Range StringRange, Range StringRange,
ArrayRef<FixItHint> FixIt) { ArrayRef<FixItHint> FixIt) {
EmitFormatDiagnostic(S, inFunctionCall, Args[FormatIdx], PDiag, EmitFormatDiagnostic(S, inFunctionCall, Args[FormatIdx], PDiag,
Loc, IsStringLocation, StringRange, FixIt); Loc, IsStringLocation, StringRange, FixIt);
} }
/// \brief If the format string is not within the funcion call, emit a note /// \brief If the format string is not within the function call, emit a note
/// so that the function call and string are in diagnostic messages. /// so that the function call and string are in diagnostic messages.
/// ///
/// \param InFunctionCall if true, the format string is within the function /// \param InFunctionCall if true, the format string is within the function
/// call and only one diagnostic message will be produced. Otherwise, an /// call and only one diagnostic message will be produced. Otherwise, an
/// extra note will be emitted pointing to location of the format string. /// extra note will be emitted pointing to location of the format string.
/// ///
/// \param ArgumentExpr the expression that is passed as the format string /// \param ArgumentExpr the expression that is passed as the format string
/// argument in the function call. Used for getting locations when two /// argument in the function call. Used for getting locations when two
▲ Show 20 Lines • Show All 4,294 Lines • ▼ Show 20 Lines if (!IsLogicalAndOperator || !isa<StringLiteral>(SubExpr))
::CheckBoolLikeConversion(S, SubExpr, BO->getExprLoc()); ::CheckBoolLikeConversion(S, SubExpr, BO->getExprLoc());
} }
if (const UnaryOperator *U = dyn_cast<UnaryOperator>(E)) if (const UnaryOperator *U = dyn_cast<UnaryOperator>(E))
if (U->getOpcode() == UO_LNot) if (U->getOpcode() == UO_LNot)
::CheckBoolLikeConversion(S, U->getSubExpr(), CC); ::CheckBoolLikeConversion(S, U->getSubExpr(), CC);
} }
/// Diagnose integer type and any valid implicit convertion to it. /// Diagnose integer type and any valid implicit conversion to it.
static bool checkOpenCLEnqueueIntType(Sema &S, Expr *E, const QualType &IntT) { static bool checkOpenCLEnqueueIntType(Sema &S, Expr *E, const QualType &IntT) {
// Taking into account implicit conversions, // Taking into account implicit conversions,
// allow any integer. // allow any integer.
if (!E->getType()->isIntegerType()) { if (!E->getType()->isIntegerType()) {
S.Diag(E->getLocStart(), S.Diag(E->getLocStart(),
diag::err_opencl_enqueue_kernel_invalid_local_size_type); diag::err_opencl_enqueue_kernel_invalid_local_size_type);
return true; return true;
} }
▲ Show 20 Lines • Show All 891 Lines • ▼ Show 20 Lines for (ParmVarDecl *Param : Parameters) {
// variable length array types. // variable length array types.
QualType PType = Param->getOriginalType(); QualType PType = Param->getOriginalType();
// FIXME: This diagnostic should point the '[*]' if source-location // FIXME: This diagnostic should point the '[*]' if source-location
// information is added for it. // information is added for it.
diagnoseArrayStarInParamType(*this, PType, Param->getLocation()); diagnoseArrayStarInParamType(*this, PType, Param->getLocation());
// If the parameter is a c++ class type and it has to be destructed in the // If the parameter is a c++ class type and it has to be destructed in the
// callee function, declare the destructor so that it can be called by the // callee function, declare the destructor so that it can be called by the
// callee function. Do not perfom any direct access check on the dtor here. // callee function. Do not perform any direct access check on the dtor here.
if (!Param->isInvalidDecl()) { if (!Param->isInvalidDecl()) {
if (CXXRecordDecl *ClassDecl = Param->getType()->getAsCXXRecordDecl()) { if (CXXRecordDecl *ClassDecl = Param->getType()->getAsCXXRecordDecl()) {
if (!ClassDecl->isInvalidDecl() && if (!ClassDecl->isInvalidDecl() &&
!ClassDecl->hasIrrelevantDestructor() && !ClassDecl->hasIrrelevantDestructor() &&
!ClassDecl->isDependentContext() && !ClassDecl->isDependentContext() &&
Context.isParamDestroyedInCallee(Param->getType())) { Context.isParamDestroyedInCallee(Param->getType())) {
CXXDestructorDecl *Destructor = LookupDestructor(ClassDecl); CXXDestructorDecl *Destructor = LookupDestructor(ClassDecl);
MarkFunctionReferenced(Param->getLocation(), Destructor); MarkFunctionReferenced(Param->getLocation(), Destructor);
▲ Show 20 Lines • Show All 1,651 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/SemaCodeComplete.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,373 Lines • ▼ Show 20 Lines
/// \brief Returns a placeholder string that corresponds to an Objective-C block /// \brief Returns a placeholder string that corresponds to an Objective-C block
/// declaration. /// declaration.
/// ///
/// \param BlockDecl A declaration with an Objective-C block type. /// \param BlockDecl A declaration with an Objective-C block type.
/// ///
/// \param Block The most relevant type location for that block type. /// \param Block The most relevant type location for that block type.
/// ///
/// \param SuppressBlockName Determines wether or not the name of the block /// \param SuppressBlockName Determines whether or not the name of the block
/// declaration is included in the resulting string. /// declaration is included in the resulting string.
static std::string static std::string
formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl, formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto, FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
bool SuppressBlockName, bool SuppressBlock, bool SuppressBlockName, bool SuppressBlock,
Optional<ArrayRef<QualType>> ObjCSubsts) { Optional<ArrayRef<QualType>> ObjCSubsts) {
std::string Result; std::string Result;
QualType ResultType = Block.getTypePtr()->getReturnType(); QualType ResultType = Block.getTypePtr()->getReturnType();
▲ Show 20 Lines • Show All 5,597 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/SemaCoroutine.cpp

Show First 20 Lines • Show All 370 Lines • ▼ Show 20 Lines if (auto *TE = dyn_cast<TypoExpr>(Result.get())) {
return ExprError(); return ExprError();
} }
return S.ActOnCallExpr(nullptr, Result.get(), Loc, Args, Loc, nullptr); return S.ActOnCallExpr(nullptr, Result.get(), Loc, Args, Loc, nullptr);
} }
// See if return type is coroutine-handle and if so, invoke builtin coro-resume // See if return type is coroutine-handle and if so, invoke builtin coro-resume
// on its address. This is to enable experimental support for coroutine-handle // on its address. This is to enable experimental support for coroutine-handle
// returning await_suspend that results in a guranteed tail call to the target // returning await_suspend that results in a guaranteed tail call to the target
// coroutine. // coroutine.
static Expr *maybeTailCall(Sema &S, QualType RetType, Expr *E, static Expr *maybeTailCall(Sema &S, QualType RetType, Expr *E,
SourceLocation Loc) { SourceLocation Loc) {
if (RetType->isReferenceType()) if (RetType->isReferenceType())
return nullptr; return nullptr;
Type const *T = RetType.getTypePtr(); Type const *T = RetType.getTypePtr();
if (!T->isClassType() && !T->isStructureType()) if (!T->isClassType() && !T->isStructureType())
return nullptr; return nullptr;
▲ Show 20 Lines • Show All 1,109 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/SemaDecl.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 7,552 Lines • ▼ Show 20 Lines bool operator()(const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
return false; return false;
} }
}; };
enum OverrideErrorKind { OEK_All, OEK_NonDeleted, OEK_Deleted }; enum OverrideErrorKind { OEK_All, OEK_NonDeleted, OEK_Deleted };
} // end anonymous namespace } // end anonymous namespace
/// \brief Report an error regarding overriding, along with any relevant /// \brief Report an error regarding overriding, along with any relevant
/// overriden methods. /// overridden methods.
/// ///
/// \param DiagID the primary error to report. /// \param DiagID the primary error to report.
/// \param MD the overriding method. /// \param MD the overriding method.
/// \param OEK which overrides to include as notes. /// \param OEK which overrides to include as notes.
static void ReportOverrides(Sema& S, unsigned DiagID, const CXXMethodDecl *MD, static void ReportOverrides(Sema& S, unsigned DiagID, const CXXMethodDecl *MD,
OverrideErrorKind OEK = OEK_All) { OverrideErrorKind OEK = OEK_All) {
S.Diag(MD->getLocation(), DiagID) << MD->getDeclName(); S.Diag(MD->getLocation(), DiagID) << MD->getDeclName();
for (const CXXMethodDecl *O : MD->overridden_methods()) { for (const CXXMethodDecl *O : MD->overridden_methods()) {
▲ Show 20 Lines • Show All 3,342 Lines • ▼ Show 20 Lines if (VDecl->isLocalVarDecl()) {
} else { } else {
Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type) Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type)
<< DclT << Init->getSourceRange(); << DclT << Init->getSourceRange();
VDecl->setInvalidDecl(); VDecl->setInvalidDecl();
} }
} else if (VDecl->isFileVarDecl()) { } else if (VDecl->isFileVarDecl()) {
// In C, extern is typically used to avoid tentative definitions when // In C, extern is typically used to avoid tentative definitions when
// declaring variables in headers, but adding an intializer makes it a // declaring variables in headers, but adding an intializer makes it a
// defintion. This is somewhat confusing, so GCC and Clang both warn on it. // definition. This is somewhat confusing, so GCC and Clang both warn on it.
// In C++, extern is often used to give implictly static const variables // In C++, extern is often used to give implictly static const variables
// external linkage, so don't warn in that case. If selectany is present, // external linkage, so don't warn in that case. If selectany is present,
// this might be header code intended for C and C++ inclusion, so apply the // this might be header code intended for C and C++ inclusion, so apply the
// C++ rules. // C++ rules.
if (VDecl->getStorageClass() == SC_Extern && if (VDecl->getStorageClass() == SC_Extern &&
((!getLangOpts().CPlusPlus && !VDecl->hasAttr<SelectAnyAttr>()) || ((!getLangOpts().CPlusPlus && !VDecl->hasAttr<SelectAnyAttr>()) ||
!Context.getBaseElementType(VDecl->getType()).isConstQualified()) && !Context.getBaseElementType(VDecl->getType()).isConstQualified()) &&
!(getLangOpts().CPlusPlus && VDecl->isExternC()) && !(getLangOpts().CPlusPlus && VDecl->isExternC()) &&
▲ Show 20 Lines • Show All 4,580 Lines • ▼ Show 20 Lines if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) {
for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(), for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
MEnd = FinalOverriders.end(); MEnd = FinalOverriders.end();
M != MEnd; ++M) { M != MEnd; ++M) {
for (OverridingMethods::iterator SO = M->second.begin(), for (OverridingMethods::iterator SO = M->second.begin(),
SOEnd = M->second.end(); SOEnd = M->second.end();
SO != SOEnd; ++SO) { SO != SOEnd; ++SO) {
assert(SO->second.size() > 0 && assert(SO->second.size() > 0 &&
"Virtual function without overridding functions?"); "Virtual function without overriding functions?");
if (SO->second.size() == 1) if (SO->second.size() == 1)
continue; continue;
// C++ [class.virtual]p2: // C++ [class.virtual]p2:
// In a derived class, if a virtual member function of a base // In a derived class, if a virtual member function of a base
// class subobject has more than one final overrider the // class subobject has more than one final overrider the
// program is ill-formed. // program is ill-formed.
Diag(Record->getLocation(), diag::err_multiple_final_overriders) Diag(Record->getLocation(), diag::err_multiple_final_overriders)
▲ Show 20 Lines • Show All 1,320 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/SemaDeclAttr.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 6,971 Lines • ▼ Show 20 Lines
} }
/// Actually emit an availability diagnostic for a reference to an unavailable /// Actually emit an availability diagnostic for a reference to an unavailable
/// decl. /// decl.
/// ///
/// \param Ctx The context that the reference occurred in /// \param Ctx The context that the reference occurred in
/// \param ReferringDecl The exact declaration that was referenced. /// \param ReferringDecl The exact declaration that was referenced.
/// \param OffendingDecl A related decl to \c ReferringDecl that has an /// \param OffendingDecl A related decl to \c ReferringDecl that has an
/// availability attribute corrisponding to \c K attached to it. Note that this /// availability attribute corresponding to \c K attached to it. Note that this
/// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and /// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and
/// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl /// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl
/// and OffendingDecl is the EnumDecl. /// and OffendingDecl is the EnumDecl.
static void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K, static void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K,
Decl *Ctx, const NamedDecl *ReferringDecl, Decl *Ctx, const NamedDecl *ReferringDecl,
const NamedDecl *OffendingDecl, const NamedDecl *OffendingDecl,
StringRef Message, StringRef Message,
ArrayRef<SourceLocation> Locs, ArrayRef<SourceLocation> Locs,
▲ Show 20 Lines • Show All 690 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/SemaDeclObjC.cpp

Show First 20 Lines • Show All 2,717 Lines • ▼ Show 20 Lines for (auto *method : PDecl->instance_methods()) {
true /* followsSuper */, true /* followsSuper */,
nullptr /* category */))) { nullptr /* category */))) {
// If a method is not implemented in the category implementation but // If a method is not implemented in the category implementation but
// has been declared in its primary class, superclass, // has been declared in its primary class, superclass,
// or in one of their protocols, no need to issue the warning. // or in one of their protocols, no need to issue the warning.
// This is because method will be implemented in the primary class // This is because method will be implemented in the primary class
// or one of its super class implementation. // or one of its super class implementation.
// Ugly, but necessary. Method declared in protcol might have // Ugly, but necessary. Method declared in protocol might have
// have been synthesized due to a property declared in the class which // have been synthesized due to a property declared in the class which
// uses the protocol. // uses the protocol.
if (ObjCMethodDecl *MethodInClass = if (ObjCMethodDecl *MethodInClass =
IDecl->lookupMethod(method->getSelector(), IDecl->lookupMethod(method->getSelector(),
true /* instance */, true /* instance */,
true /* shallowCategoryLookup */, true /* shallowCategoryLookup */,
false /* followSuper */)) false /* followSuper */))
if (C || MethodInClass->isPropertyAccessor()) if (C || MethodInClass->isPropertyAccessor())
▲ Show 20 Lines • Show All 693 Lines • ▼ Show 20 Linesstatic bool FilterMethodsByTypeBound(ObjCMethodDecl *Method,
if (ObjCInterfaceDecl *MethodInterface = Method->getClassInterface()) { if (ObjCInterfaceDecl *MethodInterface = Method->getClassInterface()) {
// We allow methods declared within classes that are part of the hierarchy // We allow methods declared within classes that are part of the hierarchy
// of the class bound (superclass of, subclass of, or the same as the class // of the class bound (superclass of, subclass of, or the same as the class
// bound). // bound).
return MethodInterface == BoundInterface || return MethodInterface == BoundInterface ||
MethodInterface->isSuperClassOf(BoundInterface) || MethodInterface->isSuperClassOf(BoundInterface) ||
BoundInterface->isSuperClassOf(MethodInterface); BoundInterface->isSuperClassOf(MethodInterface);
} }
llvm_unreachable("unknow method context"); llvm_unreachable("unknown method context");
} }
/// We first select the type of the method: Instance or Factory, then collect /// We first select the type of the method: Instance or Factory, then collect
/// all methods with that type. /// all methods with that type.
bool Sema::CollectMultipleMethodsInGlobalPool( bool Sema::CollectMultipleMethodsInGlobalPool(
Selector Sel, SmallVectorImpl<ObjCMethodDecl *> &Methods, Selector Sel, SmallVectorImpl<ObjCMethodDecl *> &Methods,
bool InstanceFirst, bool CheckTheOther, bool InstanceFirst, bool CheckTheOther,
const ObjCObjectType *TypeBound) { const ObjCObjectType *TypeBound) {
▲ Show 20 Lines • Show All 1,575 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/SemaExpr.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 5,715 Lines • ▼ Show 20 Lines if (InitArgList[I]->getType()->isNonOverloadPlaceholderType()) {
// of one failure would be terrible for indexing/etc. // of one failure would be terrible for indexing/etc.
if (result.isInvalid()) continue; if (result.isInvalid()) continue;
InitArgList[I] = result.get(); InitArgList[I] = result.get();
} }
} }
// Semantic analysis for initializers is done by ActOnDeclarator() and // Semantic analysis for initializers is done by ActOnDeclarator() and
// CheckInitializer() - it requires knowledge of the object being intialized. // CheckInitializer() - it requires knowledge of the object being initialized.
InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitArgList, InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitArgList,
RBraceLoc); RBraceLoc);
E->setType(Context.VoidTy); // FIXME: just a place holder for now. E->setType(Context.VoidTy); // FIXME: just a place holder for now.
return E; return E;
} }
/// Do an explicit extend of the given block pointer if we're in ARC. /// Do an explicit extend of the given block pointer if we're in ARC.
▲ Show 20 Lines • Show All 2,494 Lines • ▼ Show 20 Lines
/// Test if a (constant) integer Int can be casted to floating point type /// Test if a (constant) integer Int can be casted to floating point type
/// FloatTy without losing precision. /// FloatTy without losing precision.
static bool canConvertIntTyToFloatTy(Sema &S, ExprResult *Int, static bool canConvertIntTyToFloatTy(Sema &S, ExprResult *Int,
QualType FloatTy) { QualType FloatTy) {
QualType IntTy = Int->get()->getType().getUnqualifiedType(); QualType IntTy = Int->get()->getType().getUnqualifiedType();
// Determine if the integer constant can be expressed as a floating point // Determine if the integer constant can be expressed as a floating point
// number of the appropiate type. // number of the appropriate type.
llvm::APSInt Result; llvm::APSInt Result;
bool CstInt = Int->get()->EvaluateAsInt(Result, S.Context); bool CstInt = Int->get()->EvaluateAsInt(Result, S.Context);
uint64_t Bits = 0; uint64_t Bits = 0;
if (CstInt) { if (CstInt) {
// Reject constants that would be truncated if they were converted to // Reject constants that would be truncated if they were converted to
// the floating point type. Test by simple to/from conversion. // the floating point type. Test by simple to/from conversion.
// FIXME: Ideally the conversion to an APFloat and from an APFloat // FIXME: Ideally the conversion to an APFloat and from an APFloat
// could be avoided if there was a convertFromAPInt method // could be avoided if there was a convertFromAPInt method
▲ Show 20 Lines • Show All 4,146 Lines • ▼ Show 20 Lines case UO_Imag:
} }
break; break;
case UO_Extension: case UO_Extension:
resultType = Input.get()->getType(); resultType = Input.get()->getType();
VK = Input.get()->getValueKind(); VK = Input.get()->getValueKind();
OK = Input.get()->getObjectKind(); OK = Input.get()->getObjectKind();
break; break;
case UO_Coawait: case UO_Coawait:
// It's unnessesary to represent the pass-through operator co_await in the // It's unnecessary to represent the pass-through operator co_await in the
// AST; just return the input expression instead. // AST; just return the input expression instead.
assert(!Input.get()->getType()->isDependentType() && assert(!Input.get()->getType()->isDependentType() &&
"the co_await expression must be non-dependant before " "the co_await expression must be non-dependant before "
"building operator co_await"); "building operator co_await");
return Input; return Input;
} }
if (resultType.isNull() || Input.isInvalid()) if (resultType.isNull() || Input.isInvalid())
return ExprError(); return ExprError();
▲ Show 20 Lines • Show All 3,751 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/SemaExprCXX.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 5,470 Lines • ▼ Show 20 Linesstatic bool TryClassUnification(Sema &Self, Expr *From, Expr *To,
// The process for determining whether an operand expression E1 of type T1 // The process for determining whether an operand expression E1 of type T1
// can be converted to match an operand expression E2 of type T2 is defined // can be converted to match an operand expression E2 of type T2 is defined
// as follows: // as follows:
// -- If E2 is an lvalue: E1 can be converted to match E2 if E1 can be // -- If E2 is an lvalue: E1 can be converted to match E2 if E1 can be
// implicitly converted to type "lvalue reference to T2", subject to the // implicitly converted to type "lvalue reference to T2", subject to the
// constraint that in the conversion the reference must bind directly to // constraint that in the conversion the reference must bind directly to
// an lvalue. // an lvalue.
// -- If E2 is an xvalue: E1 can be converted to match E2 if E1 can be // -- If E2 is an xvalue: E1 can be converted to match E2 if E1 can be
// implicitly conveted to the type "rvalue reference to R2", subject to // implicitly converted to the type "rvalue reference to R2", subject to
// the constraint that the reference must bind directly. // the constraint that the reference must bind directly.
if (To->isLValue() || To->isXValue()) { if (To->isLValue() || To->isXValue()) {
QualType T = To->isLValue() ? Self.Context.getLValueReferenceType(ToType) QualType T = To->isLValue() ? Self.Context.getLValueReferenceType(ToType)
: Self.Context.getRValueReferenceType(ToType); : Self.Context.getRValueReferenceType(ToType);
InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); InitializedEntity Entity = InitializedEntity::InitializeTemporary(T);
InitializationSequence InitSeq(Self, Entity, Kind, From); InitializationSequence InitSeq(Self, Entity, Kind, From);
▲ Show 20 Lines • Show All 2,377 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/SemaExprObjC.cpp

Show First 20 Lines • Show All 2,793 Lines • ▼ Show 20 Lines if (receiverIsIdLike || ReceiverType->isBlockPointerType() ||
CollectMultipleMethodsInGlobalPool(Sel, Methods, CollectMultipleMethodsInGlobalPool(Sel, Methods,
false/*InstanceFirst*/, false/*InstanceFirst*/,
true/*CheckTheOther*/); true/*CheckTheOther*/);
if (!Methods.empty()) { if (!Methods.empty()) {
// We choose the first method as the initial candidate, then try // We choose the first method as the initial candidate, then try
// to select a better one. // to select a better one.
Method = Methods[0]; Method = Methods[0];
// If we find an instance method, emit waring. // If we find an instance method, emit warning.
if (Method->isInstanceMethod()) { if (Method->isInstanceMethod()) {
if (const ObjCInterfaceDecl *ID = if (const ObjCInterfaceDecl *ID =
dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) { dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) {
if (ID->getSuperClass()) if (ID->getSuperClass())
Diag(SelLoc, diag::warn_root_inst_method_not_found) Diag(SelLoc, diag::warn_root_inst_method_not_found)
<< Sel << SourceRange(LBracLoc, RBracLoc); << Sel << SourceRange(LBracLoc, RBracLoc);
} }
} }
▲ Show 20 Lines • Show All 1,686 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/SemaInit.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 4,390 Lines • ▼ Show 20 Lines if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
return; return;
// Delegate everything else to a subfunction. // Delegate everything else to a subfunction.
TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1, TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
T1Quals, cv2T2, T2, T2Quals, Sequence); T1Quals, cv2T2, T2, T2Quals, Sequence);
} }
/// Determine whether an expression is a non-referenceable glvalue (one to /// Determine whether an expression is a non-referenceable glvalue (one to
/// which a reference can never bind). Attemting to bind a reference to /// which a reference can never bind). Attempting to bind a reference to
/// such a glvalue will always create a temporary. /// such a glvalue will always create a temporary.
static bool isNonReferenceableGLValue(Expr *E) { static bool isNonReferenceableGLValue(Expr *E) {
return E->refersToBitField() || E->refersToVectorElement(); return E->refersToBitField() || E->refersToVectorElement();
} }
/// \brief Reference initialization without resolving overloaded functions. /// \brief Reference initialization without resolving overloaded functions.
static void TryReferenceInitializationCore(Sema &S, static void TryReferenceInitializationCore(Sema &S,
const InitializedEntity &Entity, const InitializedEntity &Entity,
▲ Show 20 Lines • Show All 4,292 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/SemaOverload.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 6,378 Lines • ▼ Show 20 Lines for (UnresolvedSetIterator F = Fns.begin(), E = Fns.end(); F != E; ++F) {
NamedDecl *D = F.getDecl()->getUnderlyingDecl(); NamedDecl *D = F.getDecl()->getUnderlyingDecl();
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
ArrayRef<Expr *> FunctionArgs = Args; ArrayRef<Expr *> FunctionArgs = Args;
if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic()) { if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic()) {
QualType ObjectType; QualType ObjectType;
Expr::Classification ObjectClassification; Expr::Classification ObjectClassification;
if (Args.size() > 0) { if (Args.size() > 0) {
if (Expr *E = Args[0]) { if (Expr *E = Args[0]) {
// Use the explit base to restrict the lookup: // Use the explicit base to restrict the lookup:
ObjectType = E->getType(); ObjectType = E->getType();
ObjectClassification = E->Classify(Context); ObjectClassification = E->Classify(Context);
} // .. else there is an implit base. } // .. else there is an implit base.
FunctionArgs = Args.slice(1); FunctionArgs = Args.slice(1);
} }
AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getPair(), AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getPair(),
cast<CXXMethodDecl>(FD)->getParent(), ObjectType, cast<CXXMethodDecl>(FD)->getParent(), ObjectType,
ObjectClassification, FunctionArgs, CandidateSet, ObjectClassification, FunctionArgs, CandidateSet,
Show All 11 Lines if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
} }
} else { } else {
FunctionTemplateDecl *FunTmpl = cast<FunctionTemplateDecl>(D); FunctionTemplateDecl *FunTmpl = cast<FunctionTemplateDecl>(D);
if (isa<CXXMethodDecl>(FunTmpl->getTemplatedDecl()) && if (isa<CXXMethodDecl>(FunTmpl->getTemplatedDecl()) &&
!cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl())->isStatic()) { !cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl())->isStatic()) {
QualType ObjectType; QualType ObjectType;
Expr::Classification ObjectClassification; Expr::Classification ObjectClassification;
if (Expr *E = Args[0]) { if (Expr *E = Args[0]) {
// Use the explit base to restrict the lookup: // Use the explicit base to restrict the lookup:
ObjectType = E->getType(); ObjectType = E->getType();
ObjectClassification = E->Classify(Context); ObjectClassification = E->Classify(Context);
} // .. else there is an implit base. } // .. else there is an implit base.
AddMethodTemplateCandidate( AddMethodTemplateCandidate(
FunTmpl, F.getPair(), FunTmpl, F.getPair(),
cast<CXXRecordDecl>(FunTmpl->getDeclContext()), cast<CXXRecordDecl>(FunTmpl->getDeclContext()),
ExplicitTemplateArgs, ObjectType, ObjectClassification, ExplicitTemplateArgs, ObjectType, ObjectClassification,
Args.slice(1), CandidateSet, SuppressUserConversions, Args.slice(1), CandidateSet, SuppressUserConversions,
▲ Show 20 Lines • Show All 5,486 Lines • ▼ Show 20 Linesstatic ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn,
case OR_Deleted: { case OR_Deleted: {
SemaRef.Diag(Fn->getLocStart(), diag::err_ovl_deleted_call) SemaRef.Diag(Fn->getLocStart(), diag::err_ovl_deleted_call)
<< (*Best)->Function->isDeleted() << (*Best)->Function->isDeleted()
<< ULE->getName() << ULE->getName()
<< SemaRef.getDeletedOrUnavailableSuffix((*Best)->Function) << SemaRef.getDeletedOrUnavailableSuffix((*Best)->Function)
<< Fn->getSourceRange(); << Fn->getSourceRange();
CandidateSet->NoteCandidates(SemaRef, OCD_AllCandidates, Args); CandidateSet->NoteCandidates(SemaRef, OCD_AllCandidates, Args);
// We emitted an error for the unvailable/deleted function call but keep // We emitted an error for the unavailable/deleted function call but keep
// the call in the AST. // the call in the AST.
FunctionDecl *FDecl = (*Best)->Function; FunctionDecl *FDecl = (*Best)->Function;
Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl); Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc, return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
ExecConfig); ExecConfig);
} }
} }
▲ Show 20 Lines • Show All 463 Lines • ▼ Show 20 Lines switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
case OR_No_Viable_Function: { case OR_No_Viable_Function: {
// C++ [over.match.oper]p9: // C++ [over.match.oper]p9:
// If the operator is the operator , [...] and there are no // If the operator is the operator , [...] and there are no
// viable functions, then the operator is assumed to be the // viable functions, then the operator is assumed to be the
// built-in operator and interpreted according to clause 5. // built-in operator and interpreted according to clause 5.
if (Opc == BO_Comma) if (Opc == BO_Comma)
break; break;
// For class as left operand for assignment or compound assigment // For class as left operand for assignment or compound assignment
// operator do not fall through to handling in built-in, but report that // operator do not fall through to handling in built-in, but report that
// no overloaded assignment operator found // no overloaded assignment operator found
ExprResult Result = ExprError(); ExprResult Result = ExprError();
if (Args[0]->getType()->isRecordType() && if (Args[0]->getType()->isRecordType() &&
Opc >= BO_Assign && Opc <= BO_OrAssign) { Opc >= BO_Assign && Opc <= BO_OrAssign) {
Diag(OpLoc, diag::err_ovl_no_viable_oper) Diag(OpLoc, diag::err_ovl_no_viable_oper)
<< BinaryOperator::getOpcodeStr(Opc) << BinaryOperator::getOpcodeStr(Opc)
<< Args[0]->getSourceRange() << Args[1]->getSourceRange(); << Args[0]->getSourceRange() << Args[1]->getSourceRange();
▲ Show 20 Lines • Show All 1,264 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/SemaStmt.cpp

Show First 20 Lines • Show All 2,385 Lines • ▼ Show 20 Lines if (const ArrayType *UnqAT = RangeType->getAsArrayTypeUnsafe()) {
// int vla[b]; // int vla[b];
// b = -1; <-- This should not affect the num of iterations below // b = -1; <-- This should not affect the num of iterations below
// for (int &c : vla) { .. } // for (int &c : vla) { .. }
// } // }
// FIXME: This results in codegen generating IR that recalculates the // FIXME: This results in codegen generating IR that recalculates the
// run-time number of elements (as opposed to just using the IR Value // run-time number of elements (as opposed to just using the IR Value
// that corresponds to the run-time value of each bound that was // that corresponds to the run-time value of each bound that was
// generated when the array was created.) If this proves too embarassing // generated when the array was created.) If this proves too embarrassing
// even for unoptimized IR, consider passing a magic-value/cookie to // even for unoptimized IR, consider passing a magic-value/cookie to
// codegen that then knows to simply use that initial llvm::Value (that // codegen that then knows to simply use that initial llvm::Value (that
// corresponds to the bound at time of array creation) within // corresponds to the bound at time of array creation) within
// getelementptr. But be prepared to pay the price of increasing a // getelementptr. But be prepared to pay the price of increasing a
// customized form of coupling between the two components - which could // customized form of coupling between the two components - which could
// be hard to maintain as the codebase evolves. // be hard to maintain as the codebase evolves.
ExprResult SizeOfVLAExprR = ActOnUnaryExprOrTypeTraitExpr( ExprResult SizeOfVLAExprR = ActOnUnaryExprOrTypeTraitExpr(
▲ Show 20 Lines • Show All 253 Lines • ▼ Show 20 Lines if (isa<UnaryOperator>(E)) {
const CXXOperatorCallExpr *Call = cast<CXXOperatorCallExpr>(E); const CXXOperatorCallExpr *Call = cast<CXXOperatorCallExpr>(E);
const FunctionDecl *FD = Call->getDirectCallee(); const FunctionDecl *FD = Call->getDirectCallee();
QualType ReturnType = FD->getReturnType(); QualType ReturnType = FD->getReturnType();
ReturnsReference = ReturnType->isReferenceType(); ReturnsReference = ReturnType->isReferenceType();
} }
if (ReturnsReference) { if (ReturnsReference) {
// Loop variable creates a temporary. Suggest either to go with // Loop variable creates a temporary. Suggest either to go with
// non-reference loop variable to indiciate a copy is made, or // non-reference loop variable to indicate a copy is made, or
// the correct time to bind a const reference. // the correct time to bind a const reference.
SemaRef.Diag(VD->getLocation(), diag::warn_for_range_const_reference_copy) SemaRef.Diag(VD->getLocation(), diag::warn_for_range_const_reference_copy)
<< VD << VariableType << E->getType(); << VD << VariableType << E->getType();
QualType NonReferenceType = VariableType.getNonReferenceType(); QualType NonReferenceType = VariableType.getNonReferenceType();
NonReferenceType.removeLocalConst(); NonReferenceType.removeLocalConst();
QualType NewReferenceType = QualType NewReferenceType =
SemaRef.Context.getLValueReferenceType(E->getType().withConst()); SemaRef.Context.getLValueReferenceType(E->getType().withConst());
SemaRef.Diag(VD->getLocStart(), diag::note_use_type_or_non_reference) SemaRef.Diag(VD->getLocStart(), diag::note_use_type_or_non_reference)
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Linesstatic void DiagnoseForRangeConstVariableCopies(Sema &SemaRef,
SemaRef.Diag(VD->getLocStart(), diag::note_use_reference_type) SemaRef.Diag(VD->getLocStart(), diag::note_use_reference_type)
<< SemaRef.Context.getLValueReferenceType(VariableType) << SemaRef.Context.getLValueReferenceType(VariableType)
<< VD->getSourceRange(); << VD->getSourceRange();
} }
/// DiagnoseForRangeVariableCopies - Diagnose three cases and fixes for them. /// DiagnoseForRangeVariableCopies - Diagnose three cases and fixes for them.
/// 1) for (const foo &x : foos) where foos only returns a copy. Suggest /// 1) for (const foo &x : foos) where foos only returns a copy. Suggest
/// using "const foo x" to show that a copy is made /// using "const foo x" to show that a copy is made
/// 2) for (const bar &x : foos) where bar is a temporary intialized by bar. /// 2) for (const bar &x : foos) where bar is a temporary initialized by bar.
/// Suggest either "const bar x" to keep the copying or "const foo& x" to /// Suggest either "const bar x" to keep the copying or "const foo& x" to
/// prevent the copy. /// prevent the copy.
/// 3) for (const foo x : foos) where x is constructed from a reference foo. /// 3) for (const foo x : foos) where x is constructed from a reference foo.
/// Suggest "const foo &x" to prevent the copy. /// Suggest "const foo &x" to prevent the copy.
static void DiagnoseForRangeVariableCopies(Sema &SemaRef, static void DiagnoseForRangeVariableCopies(Sema &SemaRef,
const CXXForRangeStmt *ForStmt) { const CXXForRangeStmt *ForStmt) {
if (SemaRef.Diags.isIgnored(diag::warn_for_range_const_reference_copy, if (SemaRef.Diags.isIgnored(diag::warn_for_range_const_reference_copy,
ForStmt->getLocStart()) && ForStmt->getLocStart()) &&
▲ Show 20 Lines • Show All 1,484 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/SemaTemplate.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 7,859 Lines • ▼ Show 20 Lines case TSK_ExplicitSpecialization:
Diag(NewLoc, diag::warn_explicit_instantiation_after_specialization) Diag(NewLoc, diag::warn_explicit_instantiation_after_specialization)
<< PrevDecl; << PrevDecl;
Diag(PrevDecl->getLocation(), Diag(PrevDecl->getLocation(),
diag::note_previous_template_specialization); diag::note_previous_template_specialization);
HasNoEffect = true; HasNoEffect = true;
return false; return false;
case TSK_ExplicitInstantiationDeclaration: case TSK_ExplicitInstantiationDeclaration:
// We're explicity instantiating a definition for something for which we // We're explicitly instantiating a definition for something for which we
// were previously asked to suppress instantiations. That's fine. // were previously asked to suppress instantiations. That's fine.
// C++0x [temp.explicit]p4: // C++0x [temp.explicit]p4:
// For a given set of template parameters, if an explicit instantiation // For a given set of template parameters, if an explicit instantiation
// of a template appears after a declaration of an explicit // of a template appears after a declaration of an explicit
// specialization for that template, the explicit instantiation has no // specialization for that template, the explicit instantiation has no
// effect. // effect.
for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) { for (Decl *Prev = PrevDecl; Prev; Prev = Prev->getPreviousDecl()) {
▲ Show 20 Lines • Show All 2,137 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/SemaTemplateDeduction.cpp

Show First 20 Lines • Show All 302 Lines • ▼ Show 20 Lines case TemplateArgument::Declaration:
// bound. // bound.
if (Y.getKind() == TemplateArgument::Integral) { if (Y.getKind() == TemplateArgument::Integral) {
if (Y.wasDeducedFromArrayBound()) if (Y.wasDeducedFromArrayBound())
return TemplateArgument(Context, Y.getAsIntegral(), return TemplateArgument(Context, Y.getAsIntegral(),
X.getParamTypeForDecl()); X.getParamTypeForDecl());
return Y; return Y;
} }
// If we deduced two declarations, make sure they they refer to the // If we deduced two declarations, make sure that they refer to the
// same declaration. // same declaration.
if (Y.getKind() == TemplateArgument::Declaration && if (Y.getKind() == TemplateArgument::Declaration &&
isSameDeclaration(X.getAsDecl(), Y.getAsDecl())) isSameDeclaration(X.getAsDecl(), Y.getAsDecl()))
return X; return X;
// All other combinations are incompatible. // All other combinations are incompatible.
return DeducedTemplateArgument(); return DeducedTemplateArgument();
▲ Show 20 Lines • Show All 5,179 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/SemaType.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 7,074 Lines • ▼ Show 20 Lines
} }
static void deduceOpenCLImplicitAddrSpace(TypeProcessingState &State, static void deduceOpenCLImplicitAddrSpace(TypeProcessingState &State,
QualType &T, TypeAttrLocation TAL) { QualType &T, TypeAttrLocation TAL) {
Declarator &D = State.getDeclarator(); Declarator &D = State.getDeclarator();
// Handle the cases where address space should not be deduced. // Handle the cases where address space should not be deduced.
// //
// The pointee type of a pointer type is alwasy deduced since a pointer always // The pointee type of a pointer type is always deduced since a pointer always
// points to some memory location which should has an address space. // points to some memory location which should has an address space.
// //
// There are situations that at the point of certain declarations, the address // There are situations that at the point of certain declarations, the address
// space may be unknown and better to be left as default. For example, when // space may be unknown and better to be left as default. For example, when
// definining a typedef or struct type, they are not associated with any // defining a typedef or struct type, they are not associated with any
// specific address space. Later on, they may be used with any address space // specific address space. Later on, they may be used with any address space
// to declare a variable. // to declare a variable.
// //
// The return value of a function is r-value, therefore should not have // The return value of a function is r-value, therefore should not have
// address space. // address space.
// //
// The void type does not occupy memory, therefore should not have address // The void type does not occupy memory, therefore should not have address
// space, except when it is used as a pointee type. // space, except when it is used as a pointee type.
▲ Show 20 Lines • Show All 944 Lines • Show Last 20 Lines

cfe/trunk/lib/Sema/TreeTransform.h

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
/// template arguments for their corresponding template parameters; a similar /// template arguments for their corresponding template parameters; a similar
/// transformation is performed for non-type template parameters and /// transformation is performed for non-type template parameters and
/// template template parameters. /// template template parameters.
/// ///
/// This tree-transformation template uses static polymorphism to allow /// This tree-transformation template uses static polymorphism to allow
/// subclasses to customize any of its operations. Thus, a subclass can /// subclasses to customize any of its operations. Thus, a subclass can
/// override any of the transformation or rebuild operators by providing an /// override any of the transformation or rebuild operators by providing an
/// operation with the same signature as the default implementation. The /// operation with the same signature as the default implementation. The
/// overridding function should not be virtual. /// overriding function should not be virtual.
/// ///
/// Semantic tree transformations are split into two stages, either of which /// Semantic tree transformations are split into two stages, either of which
/// can be replaced by a subclass. The "transform" step transforms an AST node /// can be replaced by a subclass. The "transform" step transforms an AST node
/// or the parts of an AST node using the various transformation functions, /// or the parts of an AST node using the various transformation functions,
/// then passes the pieces on to the "rebuild" step, which constructs a new AST /// then passes the pieces on to the "rebuild" step, which constructs a new AST
/// node of the appropriate kind from the pieces. The default transformation /// node of the appropriate kind from the pieces. The default transformation
/// routines recursively transform the operands to composite AST nodes (e.g., /// routines recursively transform the operands to composite AST nodes (e.g.,
/// the pointee type of a PointerType node) and, if any of those operand nodes /// the pointee type of a PointerType node) and, if any of those operand nodes
▲ Show 20 Lines • Show All 12,702 Lines • Show Last 20 Lines

cfe/trunk/lib/Serialization/ASTReader.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,131 Lines • ▼ Show 20 Lines if (Complain) {
Error(ErrorStr); Error(ErrorStr);
} }
// Record that we didn't find the file. // Record that we didn't find the file.
F.InputFilesLoaded[ID-1] = InputFile::getNotFound(); F.InputFilesLoaded[ID-1] = InputFile::getNotFound();
return InputFile(); return InputFile();
} }
// Check if there was a request to override the contents of the file // Check if there was a request to override the contents of the file
// that was part of the precompiled header. Overridding such a file // that was part of the precompiled header. Overriding such a file
// can lead to problems when lexing using the source locations from the // can lead to problems when lexing using the source locations from the
// PCH. // PCH.
SourceManager &SM = getSourceManager(); SourceManager &SM = getSourceManager();
// FIXME: Reject if the overrides are different. // FIXME: Reject if the overrides are different.
if ((!Overridden && !Transient) && SM.isFileOverridden(File)) { if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
if (Complain) if (Complain)
Error(diag::err_fe_pch_file_overridden, Filename); Error(diag::err_fe_pch_file_overridden, Filename);
// After emitting the diagnostic, recover by disabling the override so // After emitting the diagnostic, recover by disabling the override so
▲ Show 20 Lines • Show All 8,678 Lines • Show Last 20 Lines

cfe/trunk/lib/Serialization/ASTWriter.cpp

Show First 20 Lines • Show All 3,155 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Declaration Serialization // Declaration Serialization
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// \brief Write the block containing all of the declaration IDs /// \brief Write the block containing all of the declaration IDs
/// lexically declared within the given DeclContext. /// lexically declared within the given DeclContext.
/// ///
/// \returns the offset of the DECL_CONTEXT_LEXICAL block within the /// \returns the offset of the DECL_CONTEXT_LEXICAL block within the
/// bistream, or 0 if no block was written. /// bitstream, or 0 if no block was written.
uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context, uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context,
DeclContext *DC) { DeclContext *DC) {
if (DC->decls_empty()) if (DC->decls_empty())
return 0; return 0;
uint64_t Offset = Stream.GetCurrentBitNo(); uint64_t Offset = Stream.GetCurrentBitNo();
SmallVector<uint32_t, 128> KindDeclPairs; SmallVector<uint32_t, 128> KindDeclPairs;
for (const auto *D : DC->decls()) { for (const auto *D : DC->decls()) {
▲ Show 20 Lines • Show All 3,273 Lines • Show Last 20 Lines

cfe/trunk/lib/StaticAnalyzer/Checkers/ChrootChecker.cpp

Show First 20 Lines • Show All 126 Lines • ▼ Show 20 Lines if (!FD)
return; return;
ASTContext &Ctx = C.getASTContext(); ASTContext &Ctx = C.getASTContext();
if (!II_chroot) if (!II_chroot)
II_chroot = &Ctx.Idents.get("chroot"); II_chroot = &Ctx.Idents.get("chroot");
if (!II_chdir) if (!II_chdir)
II_chdir = &Ctx.Idents.get("chdir"); II_chdir = &Ctx.Idents.get("chdir");
// Ingnore chroot and chdir. // Ignore chroot and chdir.
if (FD->getIdentifier() == II_chroot || FD->getIdentifier() == II_chdir) if (FD->getIdentifier() == II_chroot || FD->getIdentifier() == II_chdir)
return; return;
// If jail state is ROOT_CHANGED, generate BugReport. // If jail state is ROOT_CHANGED, generate BugReport.
void *const* k = C.getState()->FindGDM(ChrootChecker::getTag()); void *const* k = C.getState()->FindGDM(ChrootChecker::getTag());
if (k) if (k)
if (isRootChanged((intptr_t) *k)) if (isRootChanged((intptr_t) *k))
if (ExplodedNode *N = C.generateNonFatalErrorNode()) { if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
Show All 12 Lines

cfe/trunk/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp

Show First 20 Lines • Show All 625 Lines • ▼ Show 20 Linesstatic const Expr *stripCastsAndSugar(const Expr *E) {
if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E)) if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E))
E = POE->getSyntacticForm()->IgnoreParenImpCasts(); E = POE->getSyntacticForm()->IgnoreParenImpCasts();
if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E))
E = OVE->getSourceExpr()->IgnoreParenImpCasts(); E = OVE->getSourceExpr()->IgnoreParenImpCasts();
return E; return E;
} }
static bool isObjCTypeParamDependent(QualType Type) { static bool isObjCTypeParamDependent(QualType Type) {
// It is illegal to typedef parameterized types inside an interface. Therfore // It is illegal to typedef parameterized types inside an interface. Therefore
// an Objective-C type can only be dependent on a type parameter when the type // an Objective-C type can only be dependent on a type parameter when the type
// parameter structurally present in the type itself. // parameter structurally present in the type itself.
class IsObjCTypeParamDependentTypeVisitor class IsObjCTypeParamDependentTypeVisitor
: public RecursiveASTVisitor<IsObjCTypeParamDependentTypeVisitor> { : public RecursiveASTVisitor<IsObjCTypeParamDependentTypeVisitor> {
public: public:
IsObjCTypeParamDependentTypeVisitor() : Result(false) {} IsObjCTypeParamDependentTypeVisitor() : Result(false) {}
bool VisitObjCTypeParamType(const ObjCTypeParamType *Type) { bool VisitObjCTypeParamType(const ObjCTypeParamType *Type) {
if (isa<ObjCTypeParamDecl>(Type->getDecl())) { if (isa<ObjCTypeParamDecl>(Type->getDecl())) {
▲ Show 20 Lines • Show All 363 Lines • Show Last 20 Lines

cfe/trunk/lib/StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp

Show All 14 Lines
// invalidated. We call an instance variable ivalidatable if it is an object of // invalidated. We call an instance variable ivalidatable if it is an object of
// a class which contains an invalidation method. There could be multiple // a class which contains an invalidation method. There could be multiple
// methods annotated with such annotations per class, either one can be used // methods annotated with such annotations per class, either one can be used
// to invalidate the ivar. An ivar or property are considered to be // to invalidate the ivar. An ivar or property are considered to be
// invalidated if they are being assigned 'nil' or an invalidation method has // invalidated if they are being assigned 'nil' or an invalidation method has
// been called on them. An invalidation method should either invalidate all // been called on them. An invalidation method should either invalidate all
// the ivars or call another invalidation method (on self). // the ivars or call another invalidation method (on self).
// //
// Partial invalidor annotation allows to addess cases when ivars are // Partial invalidor annotation allows to address cases when ivars are
// invalidated by other methods, which might or might not be called from // invalidated by other methods, which might or might not be called from
// the invalidation method. The checker checks that each invalidation // the invalidation method. The checker checks that each invalidation
// method and all the partial methods cumulatively invalidate all ivars. // method and all the partial methods cumulatively invalidate all ivars.
// __attribute__((annotate("objc_instance_variable_invalidator_partial"))); // __attribute__((annotate("objc_instance_variable_invalidator_partial")));
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ClangSACheckers.h" #include "ClangSACheckers.h"
▲ Show 20 Lines • Show All 717 Lines • Show Last 20 Lines

cfe/trunk/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp

Show First 20 Lines • Show All 1,101 Lines • ▼ Show 20 Lines
/// ///
/// We cannot use the path sensitive check because the macro argument we are /// We cannot use the path sensitive check because the macro argument we are
/// checking for (comment) is not used and thus not present in the AST, /// checking for (comment) is not used and thus not present in the AST,
/// so we use Lexer on the original macro call and retrieve the value of /// so we use Lexer on the original macro call and retrieve the value of
/// the comment. If it's empty or nil, we raise a warning. /// the comment. If it's empty or nil, we raise a warning.
void EmptyLocalizationContextChecker::MethodCrawler::VisitObjCMessageExpr( void EmptyLocalizationContextChecker::MethodCrawler::VisitObjCMessageExpr(
const ObjCMessageExpr *ME) { const ObjCMessageExpr *ME) {
// FIXME: We may be able to use PPCallbacks to check for empy context // FIXME: We may be able to use PPCallbacks to check for empty context
// comments as part of preprocessing and avoid this re-lexing hack. // comments as part of preprocessing and avoid this re-lexing hack.
const ObjCInterfaceDecl *OD = ME->getReceiverInterface(); const ObjCInterfaceDecl *OD = ME->getReceiverInterface();
if (!OD) if (!OD)
return; return;
const IdentifierInfo *odInfo = OD->getIdentifier(); const IdentifierInfo *odInfo = OD->getIdentifier();
if (!(odInfo->isStr("NSBundle") && if (!(odInfo->isStr("NSBundle") &&
▲ Show 20 Lines • Show All 264 Lines • ▼ Show 20 Linesbool PluralMisuseChecker::MethodCrawler::VisitConditionalOperator(
return true; return true;
} }
void PluralMisuseChecker::MethodCrawler::reportPluralMisuseError( void PluralMisuseChecker::MethodCrawler::reportPluralMisuseError(
const Stmt *S) const { const Stmt *S) const {
// Generate the bug report. // Generate the bug report.
BR.EmitBasicReport(AC->getDecl(), Checker, "Plural Misuse", BR.EmitBasicReport(AC->getDecl(), Checker, "Plural Misuse",
"Localizability Issue (Apple)", "Localizability Issue (Apple)",
"Plural cases are not supported accross all languages. " "Plural cases are not supported across all languages. "
"Use a .stringsdict file instead", "Use a .stringsdict file instead",
PathDiagnosticLocation(S, BR.getSourceManager(), AC)); PathDiagnosticLocation(S, BR.getSourceManager(), AC));
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Checker registration. // Checker registration.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 14 Lines

cfe/trunk/lib/StaticAnalyzer/Checkers/NonnullGlobalConstantsChecker.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linesprivate:
bool isGlobalConstString(SVal V) const; bool isGlobalConstString(SVal V) const;
bool isNonnullType(QualType Ty) const; bool isNonnullType(QualType Ty) const;
}; };
} // namespace } // namespace
/// Lazily initialize cache for required identifier informations. /// Lazily initialize cache for required identifier information.
void NonnullGlobalConstantsChecker::initIdentifierInfo(ASTContext &Ctx) const { void NonnullGlobalConstantsChecker::initIdentifierInfo(ASTContext &Ctx) const {
if (NSStringII) if (NSStringII)
return; return;
NSStringII = &Ctx.Idents.get("NSString"); NSStringII = &Ctx.Idents.get("NSString");
CFStringRefII = &Ctx.Idents.get("CFStringRef"); CFStringRefII = &Ctx.Idents.get("CFStringRef");
CFBooleanRefII = &Ctx.Idents.get("CFBooleanRef"); CFBooleanRefII = &Ctx.Idents.get("CFBooleanRef");
} }
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

cfe/trunk/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp

Show First 20 Lines • Show All 245 Lines • ▼ Show 20 Lines
// heuristics to suppress warnings in some cases) but will not warn if the // heuristics to suppress warnings in some cases) but will not warn if the
// invariant has already been violated along the path (either directly or // invariant has already been violated along the path (either directly or
// indirectly). As a practical matter, this prevents the analyzer from // indirectly). As a practical matter, this prevents the analyzer from
// (1) warning on defensive code paths where a nullability precondition is // (1) warning on defensive code paths where a nullability precondition is
// determined to have been violated, (2) warning additional times after an // determined to have been violated, (2) warning additional times after an
// initial direct violation has been discovered, and (3) warning after a direct // initial direct violation has been discovered, and (3) warning after a direct
// violation that has been implicitly or explicitly suppressed (for // violation that has been implicitly or explicitly suppressed (for
// example, with a cast of NULL to _Nonnull). In essence, once an invariant // example, with a cast of NULL to _Nonnull). In essence, once an invariant
// violation is detected on a path, this checker will be esentially turned off // violation is detected on a path, this checker will be essentially turned off
// for the rest of the analysis // for the rest of the analysis
// //
// The analyzer takes this approach (rather than generating a sink node) to // The analyzer takes this approach (rather than generating a sink node) to
// ensure coverage of defensive paths, which may be important for backwards // ensure coverage of defensive paths, which may be important for backwards
// compatibility in codebases that were developed without nullability in mind. // compatibility in codebases that were developed without nullability in mind.
REGISTER_TRAIT_WITH_PROGRAMSTATE(InvariantViolated, bool) REGISTER_TRAIT_WITH_PROGRAMSTATE(InvariantViolated, bool)
enum class NullConstraint { IsNull, IsNotNull, Unknown }; enum class NullConstraint { IsNull, IsNotNull, Unknown };
▲ Show 20 Lines • Show All 949 Lines • Show Last 20 Lines

cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp

Show First 20 Lines • Show All 549 Lines • ▼ Show 20 Lines const RetainSummary * find(const ObjCInterfaceDecl *D, Selector S) {
// Cache the summary with original key to make the next lookup faster // Cache the summary with original key to make the next lookup faster
// and return the iterator. // and return the iterator.
const RetainSummary *Summ = I->second; const RetainSummary *Summ = I->second;
M[K] = Summ; M[K] = Summ;
return Summ; return Summ;
} }
const RetainSummary *find(IdentifierInfo* II, Selector S) { const RetainSummary *find(IdentifierInfo* II, Selector S) {
// FIXME: Class method lookup. Right now we dont' have a good way // FIXME: Class method lookup. Right now we don't have a good way
// of going between IdentifierInfo* and the class hierarchy. // of going between IdentifierInfo* and the class hierarchy.
MapTy::iterator I = M.find(ObjCSummaryKey(II, S)); MapTy::iterator I = M.find(ObjCSummaryKey(II, S));
if (I == M.end()) if (I == M.end())
I = M.find(ObjCSummaryKey(S)); I = M.find(ObjCSummaryKey(S));
return I == M.end() ? nullptr : I->second; return I == M.end() ? nullptr : I->second;
} }
▲ Show 20 Lines • Show All 3,598 Lines • Show Last 20 Lines

cfe/trunk/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp

Show First 20 Lines • Show All 404 Lines • ▼ Show 20 Lines for (ExplodedNodeSet::iterator I = DstPreCall.begin(), E = DstPreCall.end();
performTrivialCopy(Bldr, *I, *Call); performTrivialCopy(Bldr, *I, *Call);
} else { } else {
for (ExplodedNodeSet::iterator I = DstPreCall.begin(), E = DstPreCall.end(); for (ExplodedNodeSet::iterator I = DstPreCall.begin(), E = DstPreCall.end();
I != E; ++I) I != E; ++I)
defaultEvalCall(Bldr, *I, *Call, CallOpts); defaultEvalCall(Bldr, *I, *Call, CallOpts);
} }
// If the CFG was contructed without elements for temporary destructors // If the CFG was constructed without elements for temporary destructors
// and the just-called constructor created a temporary object then // and the just-called constructor created a temporary object then
// stop exploration if the temporary object has a noreturn constructor. // stop exploration if the temporary object has a noreturn constructor.
// This can lose coverage because the destructor, if it were present // This can lose coverage because the destructor, if it were present
// in the CFG, would be called at the end of the full expression or // in the CFG, would be called at the end of the full expression or
// later (for life-time extended temporaries) -- but avoids infeasible // later (for life-time extended temporaries) -- but avoids infeasible
// paths when no-return temporary destructors are used for assertions. // paths when no-return temporary destructors are used for assertions.
const AnalysisDeclContext *ADC = LCtx->getAnalysisDeclContext(); const AnalysisDeclContext *ADC = LCtx->getAnalysisDeclContext();
if (!ADC->getCFGBuildOptions().AddTemporaryDtors) { if (!ADC->getCFGBuildOptions().AddTemporaryDtors) {
▲ Show 20 Lines • Show All 339 Lines • Show Last 20 Lines

cfe/trunk/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp

Show First 20 Lines • Show All 115 Lines • ▼ Show 20 Lines while (Node) {
Node = *Node->pred_begin(); Node = *Node->pred_begin();
} }
return std::make_pair(S, Blk); return std::make_pair(S, Blk);
} }
/// Adjusts a return value when the called function's return type does not /// Adjusts a return value when the called function's return type does not
/// match the caller's expression type. This can happen when a dynamic call /// match the caller's expression type. This can happen when a dynamic call
/// is devirtualized, and the overridding method has a covariant (more specific) /// is devirtualized, and the overriding method has a covariant (more specific)
/// return type than the parent's method. For C++ objects, this means we need /// return type than the parent's method. For C++ objects, this means we need
/// to add base casts. /// to add base casts.
static SVal adjustReturnValue(SVal V, QualType ExpectedTy, QualType ActualTy, static SVal adjustReturnValue(SVal V, QualType ExpectedTy, QualType ActualTy,
StoreManager &StoreMgr) { StoreManager &StoreMgr) {
// For now, the only adjustments we handle apply only to locations. // For now, the only adjustments we handle apply only to locations.
if (!V.getAs<Loc>()) if (!V.getAs<Loc>())
return V; return V;
▲ Show 20 Lines • Show All 928 Lines • Show Last 20 Lines

cfe/trunk/lib/StaticAnalyzer/Core/Store.cpp

Show First 20 Lines • Show All 355 Lines • ▼ Show 20 Lines while (const CXXRecordDecl *MRClass = getCXXRecordType(MR)) {
// derived class has a zero offset from the base class), then it's safe // derived class has a zero offset from the base class), then it's safe
// to strip the cast; if it's invalid, -Wreinterpret-base-class should // to strip the cast; if it's invalid, -Wreinterpret-base-class should
// catch it. In the interest of performance, the analyzer will silently // catch it. In the interest of performance, the analyzer will silently
// do the wrong thing in the invalid case (because offsets for subregions // do the wrong thing in the invalid case (because offsets for subregions
// will be wrong). // will be wrong).
const MemRegion *Uncasted = MR->StripCasts(/*IncludeBaseCasts=*/false); const MemRegion *Uncasted = MR->StripCasts(/*IncludeBaseCasts=*/false);
if (Uncasted == MR) { if (Uncasted == MR) {
// We reached the bottom of the hierarchy and did not find the derived // We reached the bottom of the hierarchy and did not find the derived
// class. We we must be casting the base to derived, so the cast should // class. We must be casting the base to derived, so the cast should
// fail. // fail.
break; break;
} }
MR = Uncasted; MR = Uncasted;
} }
// We failed if the region we ended up with has perfect type info. // We failed if the region we ended up with has perfect type info.
▲ Show 20 Lines • Show All 156 Lines • Show Last 20 Lines

cfe/trunk/lib/StaticAnalyzer/Frontend/ModelInjector.cpp

Show First 20 Lines • Show All 103 Lines • ▼ Show 20 Linesvoid ModelInjector::onBodySynthesis(const NamedDecl *D) {
Instance.getPreprocessor().FinalizeForModelFile(); Instance.getPreprocessor().FinalizeForModelFile();
Instance.resetAndLeakSourceManager(); Instance.resetAndLeakSourceManager();
Instance.resetAndLeakFileManager(); Instance.resetAndLeakFileManager();
Instance.resetAndLeakPreprocessor(); Instance.resetAndLeakPreprocessor();
// The preprocessor enters to the main file id when parsing is started, so // The preprocessor enters to the main file id when parsing is started, so
// the main file id is changed to the model file during parsing and it needs // the main file id is changed to the model file during parsing and it needs
// to be reseted to the former main file id after parsing of the model file // to be reset to the former main file id after parsing of the model file
// is done. // is done.
SM.setMainFileID(mainFileID); SM.setMainFileID(mainFileID);
} }

cfe/trunk/lib/Tooling/ASTDiff/ASTDiff.cpp

Show First 20 Lines • Show All 363 Lines • ▼ Show 20 Lines if (!Context)
return Val; return Val;
if (auto *Namespace = dyn_cast<NamespaceDecl>(Context)) if (auto *Namespace = dyn_cast<NamespaceDecl>(Context))
ContextPrefix = Namespace->getQualifiedNameAsString(); ContextPrefix = Namespace->getQualifiedNameAsString();
else if (auto *Record = dyn_cast<RecordDecl>(Context)) else if (auto *Record = dyn_cast<RecordDecl>(Context))
ContextPrefix = Record->getQualifiedNameAsString(); ContextPrefix = Record->getQualifiedNameAsString();
else if (AST.getLangOpts().CPlusPlus11) else if (AST.getLangOpts().CPlusPlus11)
if (auto *Tag = dyn_cast<TagDecl>(Context)) if (auto *Tag = dyn_cast<TagDecl>(Context))
ContextPrefix = Tag->getQualifiedNameAsString(); ContextPrefix = Tag->getQualifiedNameAsString();
// Strip the qualifier, if Val refers to somthing in the current scope. // Strip the qualifier, if Val refers to something in the current scope.
// But leave one leading ':' in place, so that we know that this is a // But leave one leading ':' in place, so that we know that this is a
// relative path. // relative path.
if (!ContextPrefix.empty() && StringRef(Val).startswith(ContextPrefix)) if (!ContextPrefix.empty() && StringRef(Val).startswith(ContextPrefix))
Val = Val.substr(ContextPrefix.size() + 1); Val = Val.substr(ContextPrefix.size() + 1);
return Val; return Val;
} }
std::string SyntaxTree::Impl::getRelativeName(const NamedDecl *ND) const { std::string SyntaxTree::Impl::getRelativeName(const NamedDecl *ND) const {
▲ Show 20 Lines • Show All 641 Lines • Show Last 20 Lines

cfe/trunk/lib/Tooling/Core/Replacement.cpp

Show First 20 Lines • Show All 214 Lines • ▼ Show 20 Lines
} }
// `R` and `Replaces` are order-independent if applying them in either order // `R` and `Replaces` are order-independent if applying them in either order
// has the same effect, so we need to compare replacements associated to // has the same effect, so we need to compare replacements associated to
// applying them in either order. // applying them in either order.
llvm::Expected<Replacements> llvm::Expected<Replacements>
Replacements::mergeIfOrderIndependent(const Replacement &R) const { Replacements::mergeIfOrderIndependent(const Replacement &R) const {
Replacements Rs(R); Replacements Rs(R);
// A Replacements set containg a single replacement that is `R` referring to // A Replacements set containing a single replacement that is `R` referring to
// the code after the existing replacements `Replaces` are applied. // the code after the existing replacements `Replaces` are applied.
Replacements RsShiftedByReplaces(getReplacementInChangedCode(R)); Replacements RsShiftedByReplaces(getReplacementInChangedCode(R));
// A Replacements set that is `Replaces` referring to the code after `R` is // A Replacements set that is `Replaces` referring to the code after `R` is
// applied. // applied.
Replacements ReplacesShiftedByRs; Replacements ReplacesShiftedByRs;
for (const auto &Replace : Replaces) for (const auto &Replace : Replaces)
ReplacesShiftedByRs.Replaces.insert( ReplacesShiftedByRs.Replaces.insert(
Rs.getReplacementInChangedCode(Replace)); Rs.getReplacementInChangedCode(Replace));
▲ Show 20 Lines • Show All 398 Lines • Show Last 20 Lines

cfe/trunk/lib/Tooling/FileMatchTrie.cpp

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Linespublic:
/// ///
/// If multiple paths fit 'FileName' equally well, \c IsAmbiguous is set to /// If multiple paths fit 'FileName' equally well, \c IsAmbiguous is set to
/// \c true and an empty string is returned. If no path fits 'FileName', an /// \c true and an empty string is returned. If no path fits 'FileName', an
/// empty string is returned. \c ConsumedLength denotes the number of /// empty string is returned. \c ConsumedLength denotes the number of
/// \c Filename's trailing characters already consumed during recursion. /// \c Filename's trailing characters already consumed during recursion.
/// ///
/// To find the best matching node for a given path 'p', the /// To find the best matching node for a given path 'p', the
/// \c findEquivalent() function is called recursively for each path segment /// \c findEquivalent() function is called recursively for each path segment
/// (back to fron) of 'p' until a node 'n' is reached that does not .. /// (back to front) of 'p' until a node 'n' is reached that does not ..
/// - .. have children. In this case it is checked /// - .. have children. In this case it is checked
/// whether the stored path is equivalent to 'p'. If yes, the best match is /// whether the stored path is equivalent to 'p'. If yes, the best match is
/// found. Otherwise continue with the parent node as if this node did not /// found. Otherwise continue with the parent node as if this node did not
/// exist. /// exist.
/// - .. a child matching the next path segment. In this case, all children of /// - .. a child matching the next path segment. In this case, all children of
/// 'n' are an equally good match for 'p'. All children are of 'n' are found /// 'n' are an equally good match for 'p'. All children are of 'n' are found
/// recursively and their equivalence to 'p' is determined. If none are /// recursively and their equivalence to 'p' is determined. If none are
/// equivalent, continue with the parent node as if 'n' didn't exist. If one /// equivalent, continue with the parent node as if 'n' didn't exist. If one
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

cfe/trunk/lib/Tooling/Refactoring/Rename/USRLocFinder.cpp

Show First 20 Lines • Show All 518 Lines • ▼ Show 20 LinescreateRenameAtomicChanges(llvm::ArrayRef<std::string> USRs,
std::vector<tooling::AtomicChange> AtomicChanges; std::vector<tooling::AtomicChange> AtomicChanges;
auto Replace = [&](SourceLocation Start, SourceLocation End, auto Replace = [&](SourceLocation Start, SourceLocation End,
llvm::StringRef Text) { llvm::StringRef Text) {
tooling::AtomicChange ReplaceChange = tooling::AtomicChange(SM, Start); tooling::AtomicChange ReplaceChange = tooling::AtomicChange(SM, Start);
llvm::Error Err = ReplaceChange.replace( llvm::Error Err = ReplaceChange.replace(
SM, CharSourceRange::getTokenRange(Start, End), Text); SM, CharSourceRange::getTokenRange(Start, End), Text);
if (Err) { if (Err) {
llvm::errs() << "Faile to add replacement to AtomicChange: " llvm::errs() << "Failed to add replacement to AtomicChange: "
<< llvm::toString(std::move(Err)) << "\n"; << llvm::toString(std::move(Err)) << "\n";
return; return;
} }
AtomicChanges.push_back(std::move(ReplaceChange)); AtomicChanges.push_back(std::move(ReplaceChange));
}; };
for (const auto &RenameInfo : Finder.getRenameInfos()) { for (const auto &RenameInfo : Finder.getRenameInfos()) {
std::string ReplacedName = NewName.str(); std::string ReplacedName = NewName.str();
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

cfe/trunk/test/ASTMerge/namespace/test.cpp

// RUN: %clang_cc1 -emit-pch -std=c++1z -o %t.1.ast %S/Inputs/namespace1.cpp // RUN: %clang_cc1 -emit-pch -std=c++1z -o %t.1.ast %S/Inputs/namespace1.cpp
// RUN: %clang_cc1 -emit-pch -std=c++1z -o %t.2.ast %S/Inputs/namespace2.cpp // RUN: %clang_cc1 -emit-pch -std=c++1z -o %t.2.ast %S/Inputs/namespace2.cpp
// RUN: not %clang_cc1 -std=c++1z -ast-merge %t.1.ast -ast-merge %t.2.ast -fsyntax-only %s 2>&1 | FileCheck %s // RUN: not %clang_cc1 -std=c++1z -ast-merge %t.1.ast -ast-merge %t.2.ast -fsyntax-only %s 2>&1 | FileCheck %s
static_assert(TestAliasName::z == 4); static_assert(TestAliasName::z == 4);
static_assert(ContainsInline::z == 10); static_assert(ContainsInline::z == 10);
void testImport() { void testImport() {
typedef TestUnresolvedTypenameAndValueDecls::Derived<int> Imported; typedef TestUnresolvedTypenameAndValueDecls::Derived<int> Imported;
Imported a; // Successfull instantiation Imported a; // Successful instantiation
static_assert(sizeof(Imported::foo) == sizeof(int)); static_assert(sizeof(Imported::foo) == sizeof(int));
static_assert(sizeof(TestUnresolvedTypenameAndValueDecls::Derived<double>::NewUnresolvedUsingType) == sizeof(double)); static_assert(sizeof(TestUnresolvedTypenameAndValueDecls::Derived<double>::NewUnresolvedUsingType) == sizeof(double));
} }
// CHECK: namespace2.cpp:16:17: error: external variable 'z' declared with incompatible types in different translation units ('double' vs. 'float') // CHECK: namespace2.cpp:16:17: error: external variable 'z' declared with incompatible types in different translation units ('double' vs. 'float')
// CHECK: namespace1.cpp:16:16: note: declared here with type 'float' // CHECK: namespace1.cpp:16:16: note: declared here with type 'float'

cfe/trunk/test/Analysis/analyzeOneFunction.m

Show All 32 Lines
@implementation Test1 @implementation Test1
@synthesize text; @synthesize text;
-(id)myMethod { -(id)myMethod {
Test1 *cell = [[[Test1 alloc] init] autorelease]; Test1 *cell = [[[Test1 alloc] init] autorelease];
NSString *string1 = [[NSString alloc] initWithFormat:@"test %f", 0.0]; // No warning: this function is not analized. NSString *string1 = [[NSString alloc] initWithFormat:@"test %f", 0.0]; // No warning: this function is not analyzed.
cell.text = string1; cell.text = string1;
return cell; return cell;
} }
-(id)myMethodWithY:(int)Y withX:(int)X { -(id)myMethodWithY:(int)Y withX:(int)X {
Test1 *cell = [[[Test1 alloc] init] autorelease]; Test1 *cell = [[[Test1 alloc] init] autorelease];
NSString *string1 = [[NSString alloc] initWithFormat:@"test %f %d", 0.0, X+Y]; // expected-warning {{Potential leak}} NSString *string1 = [[NSString alloc] initWithFormat:@"test %f %d", 0.0, X+Y]; // expected-warning {{Potential leak}}
cell.text = string1; cell.text = string1;
return cell; return cell;
} }
@end @end

cfe/trunk/test/Analysis/copypaste/macro-complexity.cpp

Show All 14 Linesint manualMacro(int a, int b) { // expected-warning{{Duplicate code detected}}
return a > b ? -a * a : -b * b; return a > b ? -a * a : -b * b;
} }
int manualMacroClone(int a, int b) { // expected-note{{Similar code here}} int manualMacroClone(int a, int b) { // expected-note{{Similar code here}}
return a > b ? -a * a : -b * b; return a > b ? -a * a : -b * b;
} }
// Now we actually use the macro to generate the same AST as above. They // Now we actually use the macro to generate the same AST as above. They
// shouldn't be reported because the macros only slighly increase the complexity // shouldn't be reported because the macros only slightly increase the complexity
// value and the resulting code will never pass the MinimumCloneComplexity // value and the resulting code will never pass the MinimumCloneComplexity
// constraint. // constraint.
int macro(int a, int b) { int macro(int a, int b) {
return MACRO_FOO(a, b); return MACRO_FOO(a, b);
} }
int macroClone(int a, int b) { int macroClone(int a, int b) {
Show All 19 Lines

cfe/trunk/test/Analysis/dead-stores.c

Show First 20 Lines • Show All 519 Lines • ▼ Show 20 Linesvoid rdar8405222() {
if (show) if (show)
i = 5; // no-warning i = 5; // no-warning
if (show) if (show)
rdar8405222_aux(i); rdar8405222_aux(i);
} }
// Look through chains of assignements, e.g.: int x = y = 0, when employing // Look through chains of assignments, e.g.: int x = y = 0, when employing
// silencing heuristics. // silencing heuristics.
int radar11185138_foo() { int radar11185138_foo() {
int x, y; int x, y;
x = y = 0; // expected-warning {{never read}} x = y = 0; // expected-warning {{never read}}
return y; return y;
} }
int rdar11185138_bar() { int rdar11185138_bar() {
Show All 39 Lines

cfe/trunk/test/Analysis/dynamic_type_check.m

Show All 30 Lines
void testTypeCheck(NSString* str) { void testTypeCheck(NSString* str) {
id obj = str; id obj = str;
NSNumber *num = obj; // expected-warning {{}} NSNumber *num = obj; // expected-warning {{}}
(void)num; (void)num;
} }
void testForwardDeclarations(NSString* str) { void testForwardDeclarations(NSString* str) {
id obj = str; id obj = str;
// Do not warn, since no information is available wether MyType is a sub or // Do not warn, since no information is available whether MyType is a sub or
// super class of any other type. // super class of any other type.
MyType *num = obj; // no warning MyType *num = obj; // no warning
(void)num; (void)num;
} }

cfe/trunk/test/Analysis/localization.m

Show First 20 Lines • Show All 112 Lines • ▼ Show 20 Lines
} }
// Plural Misuse Checker Tests // Plural Misuse Checker Tests
// These tests are modeled off incorrect uses of the many-one pattern // These tests are modeled off incorrect uses of the many-one pattern
// from real projects. // from real projects.
- (NSString *)test1:(int)plural { - (NSString *)test1:(int)plural {
if (plural) { if (plural) {
return MCLocalizedString(@"TYPE_PLURAL"); // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}} return MCLocalizedString(@"TYPE_PLURAL"); // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
} }
return MCLocalizedString(@"TYPE"); return MCLocalizedString(@"TYPE");
} }
- (NSString *)test2:(int)numOfReminders { - (NSString *)test2:(int)numOfReminders {
if (numOfReminders > 0) { if (numOfReminders > 0) {
return [NSString stringWithFormat:@"%@, %@", @"Test", (numOfReminders != 1) ? [NSString stringWithFormat:NSLocalizedString(@"%@ Reminders", @"Plural count of reminders"), numOfReminders] : [NSString stringWithFormat:NSLocalizedString(@"1 reminder", @"One reminder")]]; // expected-warning 2 {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note 2 {{Plural}} return [NSString stringWithFormat:@"%@, %@", @"Test", (numOfReminders != 1) ? [NSString stringWithFormat:NSLocalizedString(@"%@ Reminders", @"Plural count of reminders"), numOfReminders] : [NSString stringWithFormat:NSLocalizedString(@"1 reminder", @"One reminder")]]; // expected-warning 2 {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note 2 {{Plural}}
} }
return nil; return nil;
} }
- (void)test3 { - (void)test3 {
NSString *count; NSString *count;
if (self.unreadArticlesCount > 1) if (self.unreadArticlesCount > 1)
{ {
count = [count stringByAppendingFormat:@"%@", KHLocalizedString(@"New Stories", @"Plural count for new stories")]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}} count = [count stringByAppendingFormat:@"%@", KHLocalizedString(@"New Stories", @"Plural count for new stories")]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
} else { } else {
count = [count stringByAppendingFormat:@"%@", KHLocalizedString(@"New Story", @"One new story")]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}} count = [count stringByAppendingFormat:@"%@", KHLocalizedString(@"New Story", @"One new story")]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
} }
} }
- (NSString *)test4:(int)count { - (NSString *)test4:(int)count {
if ( count == 1 ) if ( count == 1 )
{ {
return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}} return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
} else { } else {
return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}} return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
} }
} }
- (NSString *)test5:(int)count { - (NSString *)test5:(int)count {
int test = count == 1; int test = count == 1;
if (test) if (test)
{ {
return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}} return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
} else { } else {
return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}} return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
} }
} }
// This tests the heuristic that the direct parent IfStmt must match the isCheckingPlurality confition to avoid false positives generated from complex code (generally the pattern we're looking for is simple If-Else) // This tests the heuristic that the direct parent IfStmt must match the isCheckingPlurality confition to avoid false positives generated from complex code (generally the pattern we're looking for is simple If-Else)
- (NSString *)test6:(int)sectionIndex { - (NSString *)test6:(int)sectionIndex {
int someOtherVariable = 0; int someOtherVariable = 0;
if (sectionIndex == 1) if (sectionIndex == 1)
{ {
// Do some other crazy stuff // Do some other crazy stuff
if (someOtherVariable) if (someOtherVariable)
return KHLocalizedString(@"OK",nil); // no-warning return KHLocalizedString(@"OK",nil); // no-warning
} else { } else {
return KHLocalizedString(@"value.plural",nil); // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}} return KHLocalizedString(@"value.plural",nil); // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
} }
return nil; return nil;
} }
// False positives that we are not accounting for involve matching the heuristic // False positives that we are not accounting for involve matching the heuristic
// of having 1 or 2 in the RHS of a BinaryOperator and having a localized string // of having 1 or 2 in the RHS of a BinaryOperator and having a localized string
// in the body of the IfStmt. This is seen a lot when checking for the section // in the body of the IfStmt. This is seen a lot when checking for the section
// indexpath of something like a UITableView // indexpath of something like a UITableView
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/misc-ps-region-store.m

Show First 20 Lines • Show All 1,103 Lines • ▼ Show 20 Linesvoid pr8015_C() {
int number = pr8015_A(); int number = pr8015_A();
const char *numbers[] = { "zero" }; const char *numbers[] = { "zero" };
if (number == 0) { if (number == 0) {
pr8015_B(numbers[number]); // no-warning pr8015_B(numbers[number]); // no-warning
} }
} }
// Tests that we correctly handle that 'number' is perfectly constrained // Tests that we correctly handle that 'number' is perfectly constrained
// after 'if (nunber == 0)', allowing us to resolve that // after 'if (number == 0)', allowing us to resolve that
// numbers[number] == numbers[0]. // numbers[number] == numbers[0].
void pr8015_D_FIXME() { void pr8015_D_FIXME() {
int number = pr8015_A(); int number = pr8015_A();
const char *numbers[] = { "zero" }; const char *numbers[] = { "zero" };
if (number == 0) { if (number == 0) {
if (numbers[number] == numbers[0]) if (numbers[number] == numbers[0])
return; return;
// Unreachable. // Unreachable.
▲ Show 20 Lines • Show All 246 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/new.cpp

Show First 20 Lines • Show All 132 Lines • ▼ Show 20 Linesvoid testNewDeleteNoWarn() {
delete p2; // no-warning delete p2; // no-warning
int *p3 = new int; // no-warning int *p3 = new int; // no-warning
} }
// unix.Malloc does not know about operators new/delete. // unix.Malloc does not know about operators new/delete.
void testDeleteMallocked() { void testDeleteMallocked() {
int *x = (int *)malloc(sizeof(int)); int *x = (int *)malloc(sizeof(int));
delete x; // FIXME: Shoud detect pointer escape and keep silent after 'delete' is modeled properly. delete x; // FIXME: Should detect pointer escape and keep silent after 'delete' is modeled properly.
} // expected-warning{{Potential leak of memory pointed to by 'x'}} } // expected-warning{{Potential leak of memory pointed to by 'x'}}
void testDeleteOpAfterFree() { void testDeleteOpAfterFree() {
int *p = (int *)malloc(sizeof(int)); int *p = (int *)malloc(sizeof(int));
free(p); free(p);
operator delete(p); // expected-warning{{Use of memory after it is freed}} operator delete(p); // expected-warning{{Use of memory after it is freed}}
} }
▲ Show 20 Lines • Show All 204 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/nullability.mm

Show First 20 Lines • Show All 412 Lines • ▼ Show 20 Lines- (instancetype _Nonnull)initWithNonnullReturnAndNilReturnViaLocal {
return other; return other;
} }
@end @end
@interface SubClassWithInitializers : ClassWithInitializers @interface SubClassWithInitializers : ClassWithInitializers
@end @end
@implementation SubClassWithInitializers @implementation SubClassWithInitializers
// Note: Because this is overridding // Note: Because this is overriding
// -[ClassWithInitializers initWithNonnullReturnAndSelfCheckingIdiom], // -[ClassWithInitializers initWithNonnullReturnAndSelfCheckingIdiom],
// the return type of this method becomes implicitly id _Nonnull. // the return type of this method becomes implicitly id _Nonnull.
- (id)initWithNonnullReturnAndSelfCheckingIdiom { - (id)initWithNonnullReturnAndSelfCheckingIdiom {
if (self = [super initWithNonnullReturnAndSelfCheckingIdiom]) { if (self = [super initWithNonnullReturnAndSelfCheckingIdiom]) {
} }
return self; // no-warning return self; // no-warning
} }
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/objc-properties.m

Show All 11 Lines
@interface MyClass; @interface MyClass;
@end @end
@interface TestProperty :NSObject { @interface TestProperty :NSObject {
MyClass *_Z; MyClass *_Z;
id _nonSynth; id _nonSynth;
} }
@property (assign, nonatomic) MyClass* A; // explicitely synthesized, not implemented, non-default ivar name @property (assign, nonatomic) MyClass* A; // explicitly synthesized, not implemented, non-default ivar name
@property (assign) MyClass* X; // automatically synthesized, not implemented @property (assign) MyClass* X; // automatically synthesized, not implemented
@property (assign, nonatomic) MyClass* Y; // automatically synthesized, implemented @property (assign, nonatomic) MyClass* Y; // automatically synthesized, implemented
@property (assign, nonatomic) MyClass* Z; // non-synthesized ivar, implemented setter @property (assign, nonatomic) MyClass* Z; // non-synthesized ivar, implemented setter
@property (readonly) id nonSynth; // non-synthesized, explicitly implemented to return ivar with expected name @property (readonly) id nonSynth; // non-synthesized, explicitly implemented to return ivar with expected name
Show All 36 Lines@implementation TestProperty
- (void) someMethod: (MyClass*)In { - (void) someMethod: (MyClass*)In {
(__A) = In; // expected-warning {{Direct assignment to an instance variable backing a property; use the setter instead}} (__A) = In; // expected-warning {{Direct assignment to an instance variable backing a property; use the setter instead}}
_X = In; // expected-warning {{Direct assignment to an instance variable backing a property; use the setter instead}} _X = In; // expected-warning {{Direct assignment to an instance variable backing a property; use the setter instead}}
_Y = In; // expected-warning {{Direct assignment to an instance variable backing a property; use the setter instead}} _Y = In; // expected-warning {{Direct assignment to an instance variable backing a property; use the setter instead}}
_Z = In; // expected-warning {{Direct assignment to an instance variable backing a property; use the setter instead}} _Z = In; // expected-warning {{Direct assignment to an instance variable backing a property; use the setter instead}}
_nonSynth = 0; // expected-warning {{Direct assignment to an instance variable backing a property; use the setter instead}} _nonSynth = 0; // expected-warning {{Direct assignment to an instance variable backing a property; use the setter instead}}
} }
@end @end
No newline at end of file No newline at end of file

cfe/trunk/test/Analysis/objc/direct-ivar-assignment-in-annotated-functions.m

Show All 20 Lines
@interface TestProperty : AnnotatedClass { @interface TestProperty : AnnotatedClass {
MyClass *_Z; MyClass *_Z;
id _nonSynth; id _nonSynth;
MyClass* _NotA __attribute__((annotate("objc_allow_direct_instance_variable_assignment"))); MyClass* _NotA __attribute__((annotate("objc_allow_direct_instance_variable_assignment")));
} }
@property (assign, nonatomic) MyClass* A; // explicitely synthesized, not implemented, non-default ivar name @property (assign, nonatomic) MyClass* A; // explicitly synthesized, not implemented, non-default ivar name
@property (assign) MyClass* X; // automatically synthesized, not implemented @property (assign) MyClass* X; // automatically synthesized, not implemented
@property (assign, nonatomic) MyClass* Y; // automatically synthesized, implemented @property (assign, nonatomic) MyClass* Y; // automatically synthesized, implemented
@property (assign, nonatomic) MyClass* Z; // non-synthesized ivar, implemented setter @property (assign, nonatomic) MyClass* Z; // non-synthesized ivar, implemented setter
@property (readonly) id nonSynth; // non-synthesized, explicitly implemented to return ivar with expected name @property (readonly) id nonSynth; // non-synthesized, explicitly implemented to return ivar with expected name
Show All 18 Lines - (void) someMethodNotAnnaotated: (MyClass*)In {
(__A) = In; (__A) = In;
_X = In; // no-warning _X = In; // no-warning
_Y = In; // no-warning _Y = In; // no-warning
_Z = In; // no-warning _Z = In; // no-warning
_nonSynth = 0; // no-warning _nonSynth = 0; // no-warning
} }
@end @end
No newline at end of file No newline at end of file

cfe/trunk/test/Analysis/retain-release-path-notes.m

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 216 Lines • ▼ Show 20 Lines
} }
-(id)initZ { -(id)initZ {
self = [super init]; self = [super init];
return self; return self;
} }
+(void)test { +(void)test {
// initX is inlined since we explicitely mark it as interesting // initX is inlined since we explicitly mark it as interesting
id x = [[MyObj alloc] initX]; // expected-warning {{Potential leak of an object}} id x = [[MyObj alloc] initX]; // expected-warning {{Potential leak of an object}}
// expected-note@-1 {{Method returns an instance of MyObj with a +1 retain count}} // expected-note@-1 {{Method returns an instance of MyObj with a +1 retain count}}
// expected-note@-2 {{Calling 'initX'}} // expected-note@-2 {{Calling 'initX'}}
// expected-note@-3 {{Returning from 'initX'}} // expected-note@-3 {{Returning from 'initX'}}
// expected-note@-4 {{Object leaked: allocated object is not referenced later in this execution path and has a retain count of +1}} // expected-note@-4 {{Object leaked: allocated object is not referenced later in this execution path and has a retain count of +1}}
// initI is inlined because the allocation happens within initY // initI is inlined because the allocation happens within initY
id y = [[MyObj alloc] initY]; id y = [[MyObj alloc] initY];
// expected-note@-1 {{Calling 'initY'}} // expected-note@-1 {{Calling 'initY'}}
▲ Show 20 Lines • Show All 6,084 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/string.c

Show First 20 Lines • Show All 1,157 Lines • ▼ Show 20 Linesvoid strsep_changes_input_string() {
// character. For now, we just model the invalidation. // character. For now, we just model the invalidation.
clang_analyzer_eval(str[1] == 'b'); // expected-warning{{UNKNOWN}} clang_analyzer_eval(str[1] == 'b'); // expected-warning{{UNKNOWN}}
} }
//===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===
// FIXMEs // FIXMEs
//===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===
// The analyzer_eval call below should evaluate to true. We are being too // The analyzer_eval call below should evaluate to true. We are being too
// aggressive in marking the (length of) src symbol dead. The length of dst // aggressive in marking the (length of) src symbol dead. The length of dst
// depends on src. This could be explicitely specified in the checker or the // depends on src. This could be explicitly specified in the checker or the
// logic for handling MetadataSymbol in SymbolManager needs to change. // logic for handling MetadataSymbol in SymbolManager needs to change.
void strcat_symbolic_src_length(char *src) { void strcat_symbolic_src_length(char *src) {
char dst[8] = "1234"; char dst[8] = "1234";
strcat(dst, src); strcat(dst, src);
clang_analyzer_eval(strlen(dst) >= 4); // expected-warning{{UNKNOWN}} clang_analyzer_eval(strlen(dst) >= 4); // expected-warning{{UNKNOWN}}
} }
Show All 12 Lines

cfe/trunk/test/CXX/special/class.init/class.inhctor.init/p1.cpp

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Lines struct Param {
int n; int n;
}; };
constexpr A::A(Param p) : a(p.n) {} constexpr A::A(Param p) : a(p.n) {}
constexpr B b(1); constexpr B b(1);
constexpr B c(1); constexpr B c(1);
static_assert(b.a == 1, "p should be initialized before B() is executed"); static_assert(b.a == 1, "p should be initialized before B() is executed");
static_assert(c.a == 7, "b not initialzed properly"); static_assert(c.a == 7, "b not initialized properly");
} }
namespace default_args { namespace default_args {
// We work around a defect in P0136R1 where it would reject reasonable // We work around a defect in P0136R1 where it would reject reasonable
// code like the following: // code like the following:
struct Base { struct Base {
Base(int = 0); Base(int = 0);
}; };
struct Derived : Base { struct Derived : Base {
using Base::Base; using Base::Base;
}; };
Derived d; Derived d;
// FIXME: Once a fix is standardized, implement it. // FIXME: Once a fix is standardized, implement it.
} }

cfe/trunk/test/CodeGen/arm64_vdup.c

Show All 24 Linesfloat64x1_t test_vdup_n_f64(float64_t a1) {
// CHECK@ insertelement {{.*, i32 0 *$}} // CHECK@ insertelement {{.*, i32 0 *$}}
} }
*/ */
float16x8_t test_vdupq_n_f16(float16_t *a1) { float16x8_t test_vdupq_n_f16(float16_t *a1) {
// CHECK-LABEL: test_vdupq_n_f16 // CHECK-LABEL: test_vdupq_n_f16
return vdupq_n_f16(*a1); return vdupq_n_f16(*a1);
// match that an element is inserted into parts 0-7. The backend better // match that an element is inserted into parts 0-7. The backend better
// turn that into a single dup intruction // turn that into a single dup instruction
// CHECK: insertelement {{.*, i32 0 *$}} // CHECK: insertelement {{.*, i32 0 *$}}
// CHECK: insertelement {{.*, i32 1 *$}} // CHECK: insertelement {{.*, i32 1 *$}}
// CHECK: insertelement {{.*, i32 2 *$}} // CHECK: insertelement {{.*, i32 2 *$}}
// CHECK: insertelement {{.*, i32 3 *$}} // CHECK: insertelement {{.*, i32 3 *$}}
// CHECK: insertelement {{.*, i32 4 *$}} // CHECK: insertelement {{.*, i32 4 *$}}
// CHECK: insertelement {{.*, i32 5 *$}} // CHECK: insertelement {{.*, i32 5 *$}}
// CHECK: insertelement {{.*, i32 6 *$}} // CHECK: insertelement {{.*, i32 6 *$}}
// CHECK: insertelement {{.*, i32 7 *$}} // CHECK: insertelement {{.*, i32 7 *$}}
} }

cfe/trunk/test/CodeGen/debug-info-block-out-return.c

// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -debug-info-kind=limited -fblocks -emit-llvm -o - %s | FileCheck %s // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -debug-info-kind=limited -fblocks -emit-llvm -o - %s | FileCheck %s
// Check that arg numbering is not affected by LLVM IR argument numbering - // Check that arg numbering is not affected by LLVM IR argument numbering -
// since the latter is affected by return-by-out-parameter ABI requirements // since the latter is affected by return-by-out-parameter ABI requirements
// 1 for the argument number (1 indexed), 2 for the line number // 1 for the argument number (1 indexed), 2 for the line number
// 16777218 == 1 << 24 | 2 // 16777218 == 1 << 24 | 2
// 33554434 == 2 << 24 | 2 // 33554434 == 2 << 24 | 2
// This explains the two magic numbers below, testing that these two arguments // This explains the two magic numbers below, testing that these two arguments
// are numbered correctly. If they are not numbered correctly they may appear // are numbered correctly. If they are not numbered correctly they may appear
// out of order or not at all (the latter would occur if they were both assigned // out of order or not at all (the latter would occur if they were both assigned
// the same argument number by mistake). // the same argument number by mistake).
// CHECK: !DILocalVariable(name: ".block_descriptor", arg: 1,{{.*}}line: 2, // CHECK: !DILocalVariable(name: ".block_descriptor", arg: 1,{{.*}}line: 2,
// CHECK: !DILocalVariable(name: "param", arg: 2,{{.*}}line: 2, // CHECK: !DILocalVariable(name: "param", arg: 2,{{.*}}line: 2,
// Line directive so we don't have to worry about how many lines preceed the // Line directive so we don't have to worry about how many lines precede the
// test code (as the line number is mangled in with the argument number as shown // test code (as the line number is mangled in with the argument number as shown
// above) // above)
#line 1 #line 1
typedef struct { int array[12]; } BigStruct_t; typedef struct { int array[12]; } BigStruct_t;
BigStruct_t (^a)() = ^(int param) { BigStruct_t (^a)() = ^(int param) {
BigStruct_t b; BigStruct_t b;
return b; return b;
}; };

cfe/trunk/test/CodeGen/pr3518.c

// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
// PR 3518 // PR 3518
// Some of the objects were coming out as unintialized (external) before 3518 // Some of the objects were coming out as uninitialized (external) before 3518
// was fixed. Internal names are different between llvm-gcc and clang so they // was fixed. Internal names are different between llvm-gcc and clang so they
// are not tested. // are not tested.
extern void abort (void); extern void abort (void);
// CHECK: @.compoundliteral = internal global %struct.A { i32 1, i32 2 } // CHECK: @.compoundliteral = internal global %struct.A { i32 1, i32 2 }
// CHECK: @.compoundliteral.1 = internal global %struct.A { i32 3, i32 4 } // CHECK: @.compoundliteral.1 = internal global %struct.A { i32 3, i32 4 }
// CHECK: @.compoundliteral.2 = internal global %struct.B { %struct.A* @.compoundliteral, %struct.A* @.compoundliteral.1 } // CHECK: @.compoundliteral.2 = internal global %struct.B { %struct.A* @.compoundliteral, %struct.A* @.compoundliteral.1 }
Show All 18 Lines

cfe/trunk/test/CodeGenCUDA/device-stub.cu

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines
// CHECK: define internal void @__cuda_register_globals // CHECK: define internal void @__cuda_register_globals
// CHECK: call{{.*}}cudaRegisterFunction(i8** %0, {{.*}}kernelfunc // CHECK: call{{.*}}cudaRegisterFunction(i8** %0, {{.*}}kernelfunc
// CHECK-DAG: call{{.*}}cudaRegisterVar(i8** %0, {{.*}}device_var{{.*}}i32 0, i32 4, i32 0, i32 0 // CHECK-DAG: call{{.*}}cudaRegisterVar(i8** %0, {{.*}}device_var{{.*}}i32 0, i32 4, i32 0, i32 0
// CHECK-DAG: call{{.*}}cudaRegisterVar(i8** %0, {{.*}}constant_var{{.*}}i32 0, i32 4, i32 1, i32 0 // CHECK-DAG: call{{.*}}cudaRegisterVar(i8** %0, {{.*}}constant_var{{.*}}i32 0, i32 4, i32 1, i32 0
// CHECK-DAG: call{{.*}}cudaRegisterVar(i8** %0, {{.*}}ext_device_var{{.*}}i32 1, i32 4, i32 0, i32 0 // CHECK-DAG: call{{.*}}cudaRegisterVar(i8** %0, {{.*}}ext_device_var{{.*}}i32 1, i32 4, i32 0, i32 0
// CHECK-DAG: call{{.*}}cudaRegisterVar(i8** %0, {{.*}}ext_constant_var{{.*}}i32 1, i32 4, i32 1, i32 0 // CHECK-DAG: call{{.*}}cudaRegisterVar(i8** %0, {{.*}}ext_constant_var{{.*}}i32 1, i32 4, i32 1, i32 0
// CHECK: ret void // CHECK: ret void
// Test that we've built contructor.. // Test that we've built constructor..
// CHECK: define internal void @__cuda_module_ctor // CHECK: define internal void @__cuda_module_ctor
// .. that calls __cudaRegisterFatBinary(&__cuda_fatbin_wrapper) // .. that calls __cudaRegisterFatBinary(&__cuda_fatbin_wrapper)
// CHECK: call{{.*}}cudaRegisterFatBinary{{.*}}__cuda_fatbin_wrapper // CHECK: call{{.*}}cudaRegisterFatBinary{{.*}}__cuda_fatbin_wrapper
// .. stores return value in __cuda_gpubin_handle // .. stores return value in __cuda_gpubin_handle
// CHECK-NEXT: store{{.*}}__cuda_gpubin_handle // CHECK-NEXT: store{{.*}}__cuda_gpubin_handle
// .. and then calls __cuda_register_globals // .. and then calls __cuda_register_globals
// CHECK-NEXT: call void @__cuda_register_globals // CHECK-NEXT: call void @__cuda_register_globals
Show All 20 Lines

cfe/trunk/test/CodeGenCUDA/propagate-metadata.cu

Show All 23 Lines
// RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=FTZ \ // RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=FTZ \
// RUN: --check-prefix=NOFAST // RUN: --check-prefix=NOFAST
// RUN: %clang_cc1 -x cuda %s -emit-llvm -mlink-cuda-bitcode %t.bc \ // RUN: %clang_cc1 -x cuda %s -emit-llvm -mlink-cuda-bitcode %t.bc \
// RUN: -fno-trapping-math -fcuda-flush-denormals-to-zero -o - \ // RUN: -fno-trapping-math -fcuda-flush-denormals-to-zero -o - \
// RUN: -fcuda-is-device -menable-unsafe-fp-math -triple nvptx-unknown-unknown \ // RUN: -fcuda-is-device -menable-unsafe-fp-math -triple nvptx-unknown-unknown \
// RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=FAST // RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=FAST
// Wrap everything in extern "C" so we don't ahve to worry about name mangling // Wrap everything in extern "C" so we don't have to worry about name mangling
// in the IR. // in the IR.
extern "C" { extern "C" {
#ifdef LIB #ifdef LIB
// This function is defined in the library and only declared in the main // This function is defined in the library and only declared in the main
// compilation. // compilation.
void lib_fn() {} void lib_fn() {}
Show All 22 Lines

cfe/trunk/test/CodeGenCXX/abstract-class-ctors-dtors.cpp

// RUN: %clang_cc1 %s -triple x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 %s -triple x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
// Check that we dont emit the complete constructor/destructor for this class. // Check that we don't emit the complete constructor/destructor for this class.
struct A { struct A {
virtual void f() = 0; virtual void f() = 0;
A(); A();
~A(); ~A();
}; };
// CHECK-NOT: define void @_ZN1AC1Ev // CHECK-NOT: define void @_ZN1AC1Ev
// CHECK-LABEL: define void @_ZN1AC2Ev // CHECK-LABEL: define void @_ZN1AC2Ev
// CHECK-LABEL: define void @_ZN1AD2Ev // CHECK-LABEL: define void @_ZN1AD2Ev
// CHECK-LABEL: define void @_ZN1AD1Ev // CHECK-LABEL: define void @_ZN1AD1Ev
A::A() { } A::A() { }
A::~A() { } A::~A() { }

cfe/trunk/test/CodeGenCXX/ctor-dtor-alias.cpp

// RUN: %clang_cc1 %s -triple i686-linux -emit-llvm -o - -mconstructor-aliases | FileCheck --check-prefix=NOOPT %s // RUN: %clang_cc1 %s -triple i686-linux -emit-llvm -o - -mconstructor-aliases | FileCheck --check-prefix=NOOPT %s
// RUN: %clang_cc1 %s -triple i686-linux -emit-llvm -o - -mconstructor-aliases -O1 -disable-llvm-passes > %t // RUN: %clang_cc1 %s -triple i686-linux -emit-llvm -o - -mconstructor-aliases -O1 -disable-llvm-passes > %t
// RUN: FileCheck --check-prefix=CHECK1 --input-file=%t %s // RUN: FileCheck --check-prefix=CHECK1 --input-file=%t %s
// RUN: FileCheck --check-prefix=CHECK2 --input-file=%t %s // RUN: FileCheck --check-prefix=CHECK2 --input-file=%t %s
// RUN: FileCheck --check-prefix=CHECK3 --input-file=%t %s // RUN: FileCheck --check-prefix=CHECK3 --input-file=%t %s
// RUN: FileCheck --check-prefix=CHECK4 --input-file=%t %s // RUN: FileCheck --check-prefix=CHECK4 --input-file=%t %s
// RUN: FileCheck --check-prefix=CHECK5 --input-file=%t %s // RUN: FileCheck --check-prefix=CHECK5 --input-file=%t %s
// RUN: FileCheck --check-prefix=CHECK6 --input-file=%t %s // RUN: FileCheck --check-prefix=CHECK6 --input-file=%t %s
// RUN: %clang_cc1 %s -triple i686-pc-windows-gnu -emit-llvm -o - -mconstructor-aliases -O1 -disable-llvm-passes | FileCheck --check-prefix=COFF %s // RUN: %clang_cc1 %s -triple i686-pc-windows-gnu -emit-llvm -o - -mconstructor-aliases -O1 -disable-llvm-passes | FileCheck --check-prefix=COFF %s
namespace test1 { namespace test1 {
// Test that we produce the apropriate comdats when creating aliases to // Test that we produce the appropriate comdats when creating aliases to
// weak_odr constructors and destructors. // weak_odr constructors and destructors.
// CHECK1: @_ZN5test16foobarIvEC1Ev = weak_odr alias void {{.*}} @_ZN5test16foobarIvEC2Ev // CHECK1: @_ZN5test16foobarIvEC1Ev = weak_odr alias void {{.*}} @_ZN5test16foobarIvEC2Ev
// CHECK1: @_ZN5test16foobarIvED1Ev = weak_odr alias void (%"struct.test1::foobar"*), void (%"struct.test1::foobar"*)* @_ZN5test16foobarIvED2Ev // CHECK1: @_ZN5test16foobarIvED1Ev = weak_odr alias void (%"struct.test1::foobar"*), void (%"struct.test1::foobar"*)* @_ZN5test16foobarIvED2Ev
// CHECK1: define weak_odr void @_ZN5test16foobarIvEC2Ev({{.*}} comdat($_ZN5test16foobarIvEC5Ev) // CHECK1: define weak_odr void @_ZN5test16foobarIvEC2Ev({{.*}} comdat($_ZN5test16foobarIvEC5Ev)
// CHECK1: define weak_odr void @_ZN5test16foobarIvED2Ev({{.*}} comdat($_ZN5test16foobarIvED5Ev) // CHECK1: define weak_odr void @_ZN5test16foobarIvED2Ev({{.*}} comdat($_ZN5test16foobarIvED5Ev)
// CHECK1: define weak_odr void @_ZN5test16foobarIvED0Ev({{.*}} comdat($_ZN5test16foobarIvED5Ev) // CHECK1: define weak_odr void @_ZN5test16foobarIvED0Ev({{.*}} comdat($_ZN5test16foobarIvED5Ev)
// CHECK1-NOT: comdat // CHECK1-NOT: comdat
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

cfe/trunk/test/CodeGenCXX/debug-info-class-nolimit.cpp

// RUN: %clang_cc1 -triple x86_64-apple-darwin -debug-info-kind=standalone -o - -emit-llvm %s | FileCheck %s // RUN: %clang_cc1 -triple x86_64-apple-darwin -debug-info-kind=standalone -o - -emit-llvm %s | FileCheck %s
// We had a bug in -fstandalone-debug where UnicodeString would not be completed // We had a bug in -fstandalone-debug where UnicodeString would not be completed
// when it was required to be complete. This orginally manifested as an // when it was required to be complete. This originally manifested as an
// assertion in CodeView emission on Windows with some dllexport stuff, but it's // assertion in CodeView emission on Windows with some dllexport stuff, but it's
// more general than that. // more general than that.
struct UnicodeString; struct UnicodeString;
UnicodeString *force_fwd_decl; UnicodeString *force_fwd_decl;
struct UnicodeString { struct UnicodeString {
private: private:
virtual ~UnicodeString(); virtual ~UnicodeString();
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

cfe/trunk/test/CodeGenCXX/duplicate-mangled-name.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
} }
float foo() { float foo() {
return _ZN2nm3abcE + nm::abc; return _ZN2nm3abcE + nm::abc;
} }
#else #else
#error Unknwon test #error Unknown test
#endif #endif

cfe/trunk/test/CodeGenOpenCL/amdgpu-nullptr.cl

Show First 20 Lines • Show All 192 Lines • ▼ Show 20 Lines
constant char *p3; constant char *p3;
// CHECK: @p4 = common local_unnamed_addr addrspace(1) global i8 addrspace(1)* null, align 8 // CHECK: @p4 = common local_unnamed_addr addrspace(1) global i8 addrspace(1)* null, align 8
global char *p4; global char *p4;
// CHECK: @p5 = common local_unnamed_addr addrspace(1) global i8* null, align 8 // CHECK: @p5 = common local_unnamed_addr addrspace(1) global i8* null, align 8
generic char *p5; generic char *p5;
// Test default initialization of sturcture. // Test default initialization of structure.
// CHECK: @S1 = weak local_unnamed_addr addrspace(1) global %struct.StructTy1 { i8 addrspace(5)* null, i8 addrspace(3)* addrspacecast (i8* null to i8 addrspace(3)*), i8 addrspace(4)* null, i8 addrspace(1)* null, i8* null }, align 8 // CHECK: @S1 = weak local_unnamed_addr addrspace(1) global %struct.StructTy1 { i8 addrspace(5)* null, i8 addrspace(3)* addrspacecast (i8* null to i8 addrspace(3)*), i8 addrspace(4)* null, i8 addrspace(1)* null, i8* null }, align 8
StructTy1 S1; StructTy1 S1;
// CHECK: @S2 = common local_unnamed_addr addrspace(1) global %struct.StructTy2 zeroinitializer, align 8 // CHECK: @S2 = common local_unnamed_addr addrspace(1) global %struct.StructTy2 zeroinitializer, align 8
StructTy2 S2; StructTy2 S2;
// Test default initialization of array. // Test default initialization of array.
▲ Show 20 Lines • Show All 152 Lines • ▼ Show 20 Lines test_cast_null_pointer_to_sizet_calee((size_t)((private char*)0),
(size_t)((generic char*)0)); (size_t)((generic char*)0));
test_cast_null_pointer_to_sizet_calee((size_t)((private char*)NULL), test_cast_null_pointer_to_sizet_calee((size_t)((private char*)NULL),
(size_t)((local char*)NULL), (size_t)((local char*)NULL),
(size_t)((global char*)NULL), (size_t)((global char*)NULL),
(size_t)((constant char*)0), // NULL cannot be casted to constant pointer since it is defined as a generic pointer (size_t)((constant char*)0), // NULL cannot be casted to constant pointer since it is defined as a generic pointer
(size_t)((generic char*)NULL)); (size_t)((generic char*)NULL));
} }
// Test comparision between null pointers. // Test comparison between null pointers.
#define TEST_EQ00(addr1, addr2) int test_eq00_##addr1##_##addr2(void) { return (addr1 char*)0 == (addr2 char*)0; } #define TEST_EQ00(addr1, addr2) int test_eq00_##addr1##_##addr2(void) { return (addr1 char*)0 == (addr2 char*)0; }
#define TEST_EQ0N(addr1, addr2) int test_eq0N_##addr1##_##addr2(void) { return (addr1 char*)0 == (addr2 char*)NULL; } #define TEST_EQ0N(addr1, addr2) int test_eq0N_##addr1##_##addr2(void) { return (addr1 char*)0 == (addr2 char*)NULL; }
#define TEST_EQN0(addr1, addr2) int test_eqN0_##addr1##_##addr2(void) { return (addr1 char*)NULL == (addr2 char*)0; } #define TEST_EQN0(addr1, addr2) int test_eqN0_##addr1##_##addr2(void) { return (addr1 char*)NULL == (addr2 char*)0; }
#define TEST_EQNN(addr1, addr2) int test_eqNN_##addr1##_##addr2(void) { return (addr1 char*)0 == (addr2 char*)NULL; } #define TEST_EQNN(addr1, addr2) int test_eqNN_##addr1##_##addr2(void) { return (addr1 char*)0 == (addr2 char*)NULL; }
#define TEST_NE00(addr1, addr2) int test_ne00_##addr1##_##addr2(void) { return (addr1 char*)0 != (addr2 char*)0; } #define TEST_NE00(addr1, addr2) int test_ne00_##addr1##_##addr2(void) { return (addr1 char*)0 != (addr2 char*)0; }
#define TEST_NE0N(addr1, addr2) int test_ne0N_##addr1##_##addr2(void) { return (addr1 char*)0 != (addr2 char*)NULL; } #define TEST_NE0N(addr1, addr2) int test_ne0N_##addr1##_##addr2(void) { return (addr1 char*)0 != (addr2 char*)NULL; }
#define TEST_NEN0(addr1, addr2) int test_neN0_##addr1##_##addr2(void) { return (addr1 char*)NULL != (addr2 char*)0; } #define TEST_NEN0(addr1, addr2) int test_neN0_##addr1##_##addr2(void) { return (addr1 char*)NULL != (addr2 char*)0; }
#define TEST_NENN(addr1, addr2) int test_neNN_##addr1##_##addr2(void) { return (addr1 char*)0 != (addr2 char*)NULL; } #define TEST_NENN(addr1, addr2) int test_neNN_##addr1##_##addr2(void) { return (addr1 char*)0 != (addr2 char*)NULL; }
▲ Show 20 Lines • Show All 247 Lines • Show Last 20 Lines

cfe/trunk/test/Driver/config-file2.c

Show All 11 Lines
// RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir=%S/Inputs/config2 --config x86_64-qqq2 -m32 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD1 // RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir=%S/Inputs/config2 --config x86_64-qqq2 -m32 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD1
// CHECK-RELOAD1: Target: i386 // CHECK-RELOAD1: Target: i386
// CHECK-RELOAD1: Configuration file: {{.*}}Inputs{{.}}config2{{.}}i386.cfg // CHECK-RELOAD1: Configuration file: {{.*}}Inputs{{.}}config2{{.}}i386.cfg
//--- Invocation `clang --config x86_64-qqq2 -m32` loads `x86_64-qqq2.cfg` if `i386-qqq2.cfg` and `i386.cfg` do not exist. //--- Invocation `clang --config x86_64-qqq2 -m32` loads `x86_64-qqq2.cfg` if `i386-qqq2.cfg` and `i386.cfg` do not exist.
// //
// RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir= --config x86_64-qqq2 -m32 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD2 // RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir= --config x86_64-qqq2 -m32 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD2
// note: target is overriden due to -m32 // note: target is overridden due to -m32
// CHECK-RELOAD2: Target: i386 // CHECK-RELOAD2: Target: i386
// CHECK-RELOAD2: Configuration file: {{.*}}Inputs{{.}}config{{.}}x86_64-qqq2.cfg // CHECK-RELOAD2: Configuration file: {{.*}}Inputs{{.}}config{{.}}x86_64-qqq2.cfg
//--- Invocation `clang --config i386-qqq3 -m64` loads `x86_64.cfg` if `x86_64-qqq3.cfg` does not exist. //--- Invocation `clang --config i386-qqq3 -m64` loads `x86_64.cfg` if `x86_64-qqq3.cfg` does not exist.
// //
// RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir= --config i386-qqq3 -m64 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD3 // RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir= --config i386-qqq3 -m64 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD3
// CHECK-RELOAD3: Target: x86_64 // CHECK-RELOAD3: Target: x86_64
// CHECK-RELOAD3: Configuration file: {{.*}}Inputs{{.}}config{{.}}x86_64.cfg // CHECK-RELOAD3: Configuration file: {{.*}}Inputs{{.}}config{{.}}x86_64.cfg
//--- Invocation `clang --config x86_64-qqq -target i386` loads `i386-qqq.cfg` if the latter exists. //--- Invocation `clang --config x86_64-qqq -target i386` loads `i386-qqq.cfg` if the latter exists.
// //
// RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir= --config x86_64-qqq -target i386 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD4 // RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir= --config x86_64-qqq -target i386 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD4
// CHECK-RELOAD4: Target: i386 // CHECK-RELOAD4: Target: i386
// CHECK-RELOAD4: Configuration file: {{.*}}Inputs{{.}}config{{.}}i386-qqq.cfg // CHECK-RELOAD4: Configuration file: {{.*}}Inputs{{.}}config{{.}}i386-qqq.cfg
//--- Invocation `clang --config x86_64-qqq2 -target i386` loads `x86_64-qqq2.cfg` if `i386-qqq2.cfg` and `i386.cfg` do not exist. //--- Invocation `clang --config x86_64-qqq2 -target i386` loads `x86_64-qqq2.cfg` if `i386-qqq2.cfg` and `i386.cfg` do not exist.
// //
// RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir= --config x86_64-qqq2 -target i386 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD5 // RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir= --config x86_64-qqq2 -target i386 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD5
// note: target is overriden due to -target i386 // note: target is overridden due to -target i386
// CHECK-RELOAD5: Target: i386 // CHECK-RELOAD5: Target: i386
// CHECK-RELOAD5: Configuration file: {{.*}}Inputs{{.}}config{{.}}x86_64-qqq2.cfg // CHECK-RELOAD5: Configuration file: {{.*}}Inputs{{.}}config{{.}}x86_64-qqq2.cfg
//--- Invocation `clang --config x86_64-qqq -target i386 -m64` loads `x86_64-qqq.cfg`. //--- Invocation `clang --config x86_64-qqq -target i386 -m64` loads `x86_64-qqq.cfg`.
// //
// RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir= --config x86_64-qqq -target i386 -m64 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD6 // RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir= --config x86_64-qqq -target i386 -m64 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD6
// CHECK-RELOAD6: Target: x86_64 // CHECK-RELOAD6: Target: x86_64
// CHECK-RELOAD6: Configuration file: {{.*}}Inputs{{.}}config{{.}}x86_64-qqq.cfg // CHECK-RELOAD6: Configuration file: {{.*}}Inputs{{.}}config{{.}}x86_64-qqq.cfg

cfe/trunk/test/Driver/cuda-options.cu

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines
// RUN: -check-prefix LINK %s // RUN: -check-prefix LINK %s
// RUN: %clang -### -target x86_64-linux-gnu --cuda-device-only \ // RUN: %clang -### -target x86_64-linux-gnu --cuda-device-only \
// RUN: --cuda-compile-host-device %s 2>&1 \ // RUN: --cuda-compile-host-device %s 2>&1 \
// RUN: | FileCheck -check-prefix DEVICE -check-prefix DEVICE-NOSAVE \ // RUN: | FileCheck -check-prefix DEVICE -check-prefix DEVICE-NOSAVE \
// RUN: -check-prefix HOST -check-prefix INCLUDES-DEVICE \ // RUN: -check-prefix HOST -check-prefix INCLUDES-DEVICE \
// RUN: -check-prefix LINK %s // RUN: -check-prefix LINK %s
// Verify that --cuda-gpu-arch option passes the correct GPU archtecture to // Verify that --cuda-gpu-arch option passes the correct GPU architecture to
// device compilation. // device compilation.
// RUN: %clang -### -target x86_64-linux-gnu --cuda-gpu-arch=sm_30 -c %s 2>&1 \ // RUN: %clang -### -target x86_64-linux-gnu --cuda-gpu-arch=sm_30 -c %s 2>&1 \
// RUN: | FileCheck -check-prefix DEVICE -check-prefix DEVICE-NOSAVE \ // RUN: | FileCheck -check-prefix DEVICE -check-prefix DEVICE-NOSAVE \
// RUN: -check-prefix DEVICE-SM30 -check-prefix HOST \ // RUN: -check-prefix DEVICE-SM30 -check-prefix HOST \
// RUN: -check-prefix INCLUDES-DEVICE -check-prefix NOLINK %s // RUN: -check-prefix INCLUDES-DEVICE -check-prefix NOLINK %s
// Verify that there is one device-side compilation per --cuda-gpu-arch args // Verify that there is one device-side compilation per --cuda-gpu-arch args
// and that all results are included on the host side. // and that all results are included on the host side.
Show All 13 Lines
// Verify that device-side results are passed to the correct tool when // Verify that device-side results are passed to the correct tool when
// -fno-integrated-as is used. // -fno-integrated-as is used.
// RUN: %clang -### -target x86_64-linux-gnu -fno-integrated-as -c %s 2>&1 \ // RUN: %clang -### -target x86_64-linux-gnu -fno-integrated-as -c %s 2>&1 \
// RUN: | FileCheck -check-prefix DEVICE -check-prefix DEVICE-NOSAVE \ // RUN: | FileCheck -check-prefix DEVICE -check-prefix DEVICE-NOSAVE \
// RUN: -check-prefix HOST -check-prefix HOST-NOSAVE \ // RUN: -check-prefix HOST -check-prefix HOST-NOSAVE \
// RUN: -check-prefix HOST-AS -check-prefix NOLINK %s // RUN: -check-prefix HOST-AS -check-prefix NOLINK %s
// Verify that --[no-]cuda-gpu-arch arguments are handled correctly. // Verify that --[no-]cuda-gpu-arch arguments are handled correctly.
// a) --no-cuda-gpu-arch=X negates preceeding --cuda-gpu-arch=X // a) --no-cuda-gpu-arch=X negates preceding --cuda-gpu-arch=X
// RUN: %clang -### -target x86_64-linux-gnu --cuda-device-only \ // RUN: %clang -### -target x86_64-linux-gnu --cuda-device-only \
// RUN: --cuda-gpu-arch=sm_35 --cuda-gpu-arch=sm_30 \ // RUN: --cuda-gpu-arch=sm_35 --cuda-gpu-arch=sm_30 \
// RUN: --no-cuda-gpu-arch=sm_35 \ // RUN: --no-cuda-gpu-arch=sm_35 \
// RUN: -c %s 2>&1 \ // RUN: -c %s 2>&1 \
// RUN: | FileCheck -check-prefixes NOARCH-SM20,ARCH-SM30,NOARCH-SM35 %s // RUN: | FileCheck -check-prefixes NOARCH-SM20,ARCH-SM30,NOARCH-SM35 %s
// b) --no-cuda-gpu-arch=X negates more than one preceeding --cuda-gpu-arch=X // b) --no-cuda-gpu-arch=X negates more than one preceding --cuda-gpu-arch=X
// RUN: %clang -### -target x86_64-linux-gnu --cuda-device-only \ // RUN: %clang -### -target x86_64-linux-gnu --cuda-device-only \
// RUN: --cuda-gpu-arch=sm_35 --cuda-gpu-arch=sm_35 --cuda-gpu-arch=sm_30 \ // RUN: --cuda-gpu-arch=sm_35 --cuda-gpu-arch=sm_35 --cuda-gpu-arch=sm_30 \
// RUN: --no-cuda-gpu-arch=sm_35 \ // RUN: --no-cuda-gpu-arch=sm_35 \
// RUN: -c %s 2>&1 \ // RUN: -c %s 2>&1 \
// RUN: | FileCheck -check-prefixes NOARCH-SM20,ARCH-SM30,NOARCH-SM35 %s // RUN: | FileCheck -check-prefixes NOARCH-SM20,ARCH-SM30,NOARCH-SM35 %s
// c) if --no-cuda-gpu-arch=X negates all preceeding --cuda-gpu-arch=X // c) if --no-cuda-gpu-arch=X negates all preceding --cuda-gpu-arch=X
// we default to sm_20 -- same as if no --cuda-gpu-arch were passed. // we default to sm_20 -- same as if no --cuda-gpu-arch were passed.
// RUN: %clang -### -target x86_64-linux-gnu --cuda-device-only \ // RUN: %clang -### -target x86_64-linux-gnu --cuda-device-only \
// RUN: --cuda-gpu-arch=sm_35 --cuda-gpu-arch=sm_30 \ // RUN: --cuda-gpu-arch=sm_35 --cuda-gpu-arch=sm_30 \
// RUN: --no-cuda-gpu-arch=sm_35 --no-cuda-gpu-arch=sm_30 \ // RUN: --no-cuda-gpu-arch=sm_35 --no-cuda-gpu-arch=sm_30 \
// RUN: -c %s 2>&1 \ // RUN: -c %s 2>&1 \
// RUN: | FileCheck -check-prefixes ARCH-SM20,NOARCH-SM30,NOARCH-SM35 %s // RUN: | FileCheck -check-prefixes ARCH-SM20,NOARCH-SM30,NOARCH-SM35 %s
// d) --no-cuda-gpu-arch=X is a no-op if there's no preceding --cuda-gpu-arch=X // d) --no-cuda-gpu-arch=X is a no-op if there's no preceding --cuda-gpu-arch=X
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

cfe/trunk/test/Driver/darwin-version.c

Show First 20 Lines • Show All 212 Lines • ▼ Show 20 Lines
// RUN: FileCheck --check-prefix=CHECK-VERSION-TNO-OSV4 %s // RUN: FileCheck --check-prefix=CHECK-VERSION-TNO-OSV4 %s
// CHECK-VERSION-TNO-OSV4: overriding '-miphoneos-version-min=10.1.0.1' option with '--target=arm64-apple-ios10.1.0' // CHECK-VERSION-TNO-OSV4: overriding '-miphoneos-version-min=10.1.0.1' option with '--target=arm64-apple-ios10.1.0'
// RUN: %clang -target x86_64-apple-macos10.6 -mmacos-version-min=10.6 -c %s -### 2>&1 | \ // RUN: %clang -target x86_64-apple-macos10.6 -mmacos-version-min=10.6 -c %s -### 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-TNO-SAME %s // RUN: FileCheck --check-prefix=CHECK-VERSION-TNO-SAME %s
// CHECK-VERSION-TNO-SAME-NOT: overriding // CHECK-VERSION-TNO-SAME-NOT: overriding
// CHECK-VERSION-TNO-SAME-NOT: argument unused during compilation // CHECK-VERSION-TNO-SAME-NOT: argument unused during compilation
// Target with OS version is not overriden by -m<os>-version-min variables: // Target with OS version is not overridden by -m<os>-version-min variables:
// RUN: %clang -target x86_64-apple-macos10.11.2 -mmacos-version-min=10.6 -c %s -### 2>&1 | \ // RUN: %clang -target x86_64-apple-macos10.11.2 -mmacos-version-min=10.6 -c %s -### 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-TIGNORE-OSV1 %s // RUN: FileCheck --check-prefix=CHECK-VERSION-TIGNORE-OSV1 %s
// CHECK-VERSION-TIGNORE-OSV1: "x86_64-apple-macosx10.11.2" // CHECK-VERSION-TIGNORE-OSV1: "x86_64-apple-macosx10.11.2"
// RUN: %clang -target arm64-apple-ios11.0 -mios-version-min=9.0 -c %s -### 2>&1 | \ // RUN: %clang -target arm64-apple-ios11.0 -mios-version-min=9.0 -c %s -### 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-TIGNORE-OSV2 %s // RUN: FileCheck --check-prefix=CHECK-VERSION-TIGNORE-OSV2 %s
// CHECK-VERSION-TIGNORE-OSV2: "arm64-apple-ios11.0.0" // CHECK-VERSION-TIGNORE-OSV2: "arm64-apple-ios11.0.0"
// RUN: %clang -target arm64-apple-tvos11.0 -mtvos-version-min=9.0 -c %s -### 2>&1 | \ // RUN: %clang -target arm64-apple-tvos11.0 -mtvos-version-min=9.0 -c %s -### 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-TIGNORE-OSV3 %s // RUN: FileCheck --check-prefix=CHECK-VERSION-TIGNORE-OSV3 %s
// CHECK-VERSION-TIGNORE-OSV3: "arm64-apple-tvos11.0.0" // CHECK-VERSION-TIGNORE-OSV3: "arm64-apple-tvos11.0.0"
// RUN: %clang -target armv7k-apple-watchos3 -mwatchos-version-min=4 -c %s -### 2>&1 | \ // RUN: %clang -target armv7k-apple-watchos3 -mwatchos-version-min=4 -c %s -### 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-TIGNORE-OSV4 %s // RUN: FileCheck --check-prefix=CHECK-VERSION-TIGNORE-OSV4 %s
// CHECK-VERSION-TIGNORE-OSV4: "thumbv7k-apple-watchos3.0.0" // CHECK-VERSION-TIGNORE-OSV4: "thumbv7k-apple-watchos3.0.0"
// Target without OS version inlcudes the OS given by -m<os>-version-min arguments: // Target without OS version includes the OS given by -m<os>-version-min arguments:
// RUN: %clang -target x86_64-apple-macos -mmacos-version-min=10.11 -c %s -### 2>&1 | \ // RUN: %clang -target x86_64-apple-macos -mmacos-version-min=10.11 -c %s -### 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-USE-OS-ARG1 %s // RUN: FileCheck --check-prefix=CHECK-VERSION-USE-OS-ARG1 %s
// CHECK-VERSION-USE-OS-ARG1: "x86_64-apple-macosx10.11.0" // CHECK-VERSION-USE-OS-ARG1: "x86_64-apple-macosx10.11.0"
// RUN: %clang -target arm64-apple-ios -mios-version-min=9.0 -c %s -### 2>&1 | \ // RUN: %clang -target arm64-apple-ios -mios-version-min=9.0 -c %s -### 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-USE-OS-ARG2 %s // RUN: FileCheck --check-prefix=CHECK-VERSION-USE-OS-ARG2 %s
// CHECK-VERSION-USE-OS-ARG2: "arm64-apple-ios9.0.0" // CHECK-VERSION-USE-OS-ARG2: "arm64-apple-ios9.0.0"
// RUN: %clang -target arm64-apple-tvos -mtvos-version-min=10.0 -c %s -### 2>&1 | \ // RUN: %clang -target arm64-apple-tvos -mtvos-version-min=10.0 -c %s -### 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-USE-OS-ARG3 %s // RUN: FileCheck --check-prefix=CHECK-VERSION-USE-OS-ARG3 %s
// CHECK-VERSION-USE-OS-ARG3: "arm64-apple-tvos10.0.0" // CHECK-VERSION-USE-OS-ARG3: "arm64-apple-tvos10.0.0"
// RUN: %clang -target armv7k-apple-watchos -mwatchos-version-min=4 -c %s -### 2>&1 | \ // RUN: %clang -target armv7k-apple-watchos -mwatchos-version-min=4 -c %s -### 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-USE-OS-ARG4 %s // RUN: FileCheck --check-prefix=CHECK-VERSION-USE-OS-ARG4 %s
// CHECK-VERSION-USE-OS-ARG4: "thumbv7k-apple-watchos4.0.0" // CHECK-VERSION-USE-OS-ARG4: "thumbv7k-apple-watchos4.0.0"
// Target with OS version is not overriden by environment variables: // Target with OS version is not overridden by environment variables:
// RUN: env MACOSX_DEPLOYMENT_TARGET=10.1 \ // RUN: env MACOSX_DEPLOYMENT_TARGET=10.1 \
// RUN: %clang -target i386-apple-macos10.5 -c %s -### 2>&1 | \ // RUN: %clang -target i386-apple-macos10.5 -c %s -### 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-TMACOS-CMD %s // RUN: FileCheck --check-prefix=CHECK-VERSION-TMACOS-CMD %s
// CHECK-VERSION-TMACOS-CMD: "i386-apple-macosx10.5.0" // CHECK-VERSION-TMACOS-CMD: "i386-apple-macosx10.5.0"
// RUN: env IPHONEOS_DEPLOYMENT_TARGET=10.1 \ // RUN: env IPHONEOS_DEPLOYMENT_TARGET=10.1 \
// RUN: %clang -target arm64-apple-ios11 -c %s -### 2>&1 | \ // RUN: %clang -target arm64-apple-ios11 -c %s -### 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-TIOS-CMD %s // RUN: FileCheck --check-prefix=CHECK-VERSION-TIOS-CMD %s
// CHECK-VERSION-TIOS-CMD: "arm64-apple-ios11.0.0" // CHECK-VERSION-TIOS-CMD: "arm64-apple-ios11.0.0"
// RUN: env TVOS_DEPLOYMENT_TARGET=8.3.1 \ // RUN: env TVOS_DEPLOYMENT_TARGET=8.3.1 \
// RUN: %clang -target arm64-apple-tvos9 -c %s -### 2>&1 | \ // RUN: %clang -target arm64-apple-tvos9 -c %s -### 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-TTVOS-CMD %s // RUN: FileCheck --check-prefix=CHECK-VERSION-TTVOS-CMD %s
// CHECK-VERSION-TTVOS-CMD: "arm64-apple-tvos9.0.0" // CHECK-VERSION-TTVOS-CMD: "arm64-apple-tvos9.0.0"
// RUN: env WATCHOS_DEPLOYMENT_TARGET=2 \ // RUN: env WATCHOS_DEPLOYMENT_TARGET=2 \
// RUN: %clang -target armv7k-apple-watchos3 -c %s -### 2>&1 | \ // RUN: %clang -target armv7k-apple-watchos3 -c %s -### 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-TWATCHOS-CMD %s // RUN: FileCheck --check-prefix=CHECK-VERSION-TWATCHOS-CMD %s
// CHECK-VERSION-TWATCHOS-CMD: "thumbv7k-apple-watchos3.0.0" // CHECK-VERSION-TWATCHOS-CMD: "thumbv7k-apple-watchos3.0.0"
// Target with OS version is not overriden by the SDK: // Target with OS version is not overridden by the SDK:
// RUN: %clang -target armv7-apple-ios9 -Wno-missing-sysroot -isysroot SDKs/iPhoneOS11.0.sdk -c -### %s 2>&1 | \ // RUN: %clang -target armv7-apple-ios9 -Wno-missing-sysroot -isysroot SDKs/iPhoneOS11.0.sdk -c -### %s 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-TIOS-SDK %s // RUN: FileCheck --check-prefix=CHECK-VERSION-TIOS-SDK %s
// CHECK-VERSION-TIOS-SDK: thumbv7-apple-ios9 // CHECK-VERSION-TIOS-SDK: thumbv7-apple-ios9
// RUN: %clang -target armv7k-apple-watchos4 -Wno-missing-sysroot -isysroot SDKs/WatchOS3.0.sdk -c -### %s 2>&1 | \ // RUN: %clang -target armv7k-apple-watchos4 -Wno-missing-sysroot -isysroot SDKs/WatchOS3.0.sdk -c -### %s 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-TWATCHOS-SDK %s // RUN: FileCheck --check-prefix=CHECK-VERSION-TWATCHOS-SDK %s
// CHECK-VERSION-TWATCHOS-SDK: thumbv7k-apple-watchos4 // CHECK-VERSION-TWATCHOS-SDK: thumbv7k-apple-watchos4
// RUN: %clang -target armv7-apple-tvos9 -Wno-missing-sysroot -isysroot SDKs/AppleTVOS11.0.sdk -c -### %s 2>&1 | \ // RUN: %clang -target armv7-apple-tvos9 -Wno-missing-sysroot -isysroot SDKs/AppleTVOS11.0.sdk -c -### %s 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-TTVOS-SDK %s // RUN: FileCheck --check-prefix=CHECK-VERSION-TTVOS-SDK %s
// CHECK-VERSION-TTVOS-SDK: thumbv7-apple-tvos9 // CHECK-VERSION-TTVOS-SDK: thumbv7-apple-tvos9
// Target with OS version is not overriden by arch: // Target with OS version is not overridden by arch:
// RUN: %clang -target uknown-apple-macos10.11.2 -arch=armv7k -c %s -### 2>&1 | \ // RUN: %clang -target uknown-apple-macos10.11.2 -arch=armv7k -c %s -### 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-TIGNORE-ARCH1 %s // RUN: FileCheck --check-prefix=CHECK-VERSION-TIGNORE-ARCH1 %s
// CHECK-VERSION-TIGNORE-ARCH1: "unknown-apple-macosx10.11.2" // CHECK-VERSION-TIGNORE-ARCH1: "unknown-apple-macosx10.11.2"
// Target can be used to specify the environment: // Target can be used to specify the environment:
// RUN: %clang -target x86_64-apple-ios11-simulator -c %s -### 2>&1 | \ // RUN: %clang -target x86_64-apple-ios11-simulator -c %s -### 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-TENV-SIM1 %s // RUN: FileCheck --check-prefix=CHECK-VERSION-TENV-SIM1 %s
// CHECK-VERSION-TENV-SIM1: "x86_64-apple-ios11.0.0-simulator" // CHECK-VERSION-TENV-SIM1: "x86_64-apple-ios11.0.0-simulator"
// RUN: %clang -target armv7k-apple-ios10.1-simulator -c %s -### 2>&1 | \ // RUN: %clang -target armv7k-apple-ios10.1-simulator -c %s -### 2>&1 | \
// RUN: FileCheck --check-prefix=CHECK-VERSION-TENV-SIM2 %s // RUN: FileCheck --check-prefix=CHECK-VERSION-TENV-SIM2 %s
// CHECK-VERSION-TENV-SIM2: "thumbv7k-apple-ios10.1.0-simulator" // CHECK-VERSION-TENV-SIM2: "thumbv7k-apple-ios10.1.0-simulator"

cfe/trunk/test/Driver/fsanitize-blacklist.c

Show All 34 Lines
// Check that combining ubsan and another sanitizer results in both blacklists being used. // Check that combining ubsan and another sanitizer results in both blacklists being used.
// RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined,address -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-UBSAN-BLACKLIST --check-prefix=CHECK-DEFAULT-ASAN-BLACKLIST --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blacklist= // RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined,address -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-UBSAN-BLACKLIST --check-prefix=CHECK-DEFAULT-ASAN-BLACKLIST --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blacklist=
// Ignore -fsanitize-blacklist flag if there is no -fsanitize flag. // Ignore -fsanitize-blacklist flag if there is no -fsanitize flag.
// RUN: %clang -target x86_64-linux-gnu -fsanitize-blacklist=%t.good %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-SANITIZE --check-prefix=DELIMITERS // RUN: %clang -target x86_64-linux-gnu -fsanitize-blacklist=%t.good %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-SANITIZE --check-prefix=DELIMITERS
// CHECK-NO-SANITIZE-NOT: -fsanitize-blacklist // CHECK-NO-SANITIZE-NOT: -fsanitize-blacklist
// Ignore -fsanitize-blacklist flag if there is no -fsanitize flag. // Ignore -fsanitize-blacklist flag if there is no -fsanitize flag.
// Now, check for the absense of -fdepfile-entry flags. // Now, check for the absence of -fdepfile-entry flags.
// RUN: %clang -target x86_64-linux-gnu -fsanitize-blacklist=%t.good %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-SANITIZE2 --check-prefix=DELIMITERS // RUN: %clang -target x86_64-linux-gnu -fsanitize-blacklist=%t.good %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-SANITIZE2 --check-prefix=DELIMITERS
// CHECK-NO-SANITIZE2-NOT: -fdepfile-entry // CHECK-NO-SANITIZE2-NOT: -fdepfile-entry
// Flag -fno-sanitize-blacklist wins if it is specified later. // Flag -fno-sanitize-blacklist wins if it is specified later.
// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-blacklist=%t.good -fno-sanitize-blacklist %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-BLACKLIST --check-prefix=DELIMITERS // RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-blacklist=%t.good -fno-sanitize-blacklist %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-BLACKLIST --check-prefix=DELIMITERS
// CHECK-NO-BLACKLIST-NOT: -fsanitize-blacklist // CHECK-NO-BLACKLIST-NOT: -fsanitize-blacklist
// Driver barks on unexisting blacklist files. // Driver barks on unexisting blacklist files.
Show All 14 Lines

cfe/trunk/test/Driver/hexagon-hvx.c

Show All 29 Lines
// No hvx target feature must be added if -mno-hvx occurs last // No hvx target feature must be added if -mno-hvx occurs last
// RUN: %clang -c %s -### -target hexagon-unknown-elf -mv62 -mno-hvx \ // RUN: %clang -c %s -### -target hexagon-unknown-elf -mv62 -mno-hvx \
// RUN: 2>&1 | FileCheck -check-prefix=CHECK-NOHVX %s // RUN: 2>&1 | FileCheck -check-prefix=CHECK-NOHVX %s
// RUN: %clang -c %s -### -target hexagon-unknown-elf -mv62 -mhvx -mno-hvx \ // RUN: %clang -c %s -### -target hexagon-unknown-elf -mv62 -mhvx -mno-hvx \
// RUN: 2>&1 | FileCheck -check-prefix=CHECK-NOHVX %s // RUN: 2>&1 | FileCheck -check-prefix=CHECK-NOHVX %s
// CHECK-NOHVX-NOT: "-target-feature" "+hvx // CHECK-NOHVX-NOT: "-target-feature" "+hvx
// Hvx target feature should be added if -mno-hvx doesnot occur last // Hvx target feature should be added if -mno-hvx doesn't occur last
// RUN: %clang -c %s -### -target hexagon-unknown-elf -mv62 -mno-hvx -mhvx\ // RUN: %clang -c %s -### -target hexagon-unknown-elf -mv62 -mno-hvx -mhvx\
// RUN: 2>&1 | FileCheck -check-prefix=CHECK-HVXFEAT %s // RUN: 2>&1 | FileCheck -check-prefix=CHECK-HVXFEAT %s
// CHECK-HVXFEAT: "-target-feature" "+hvxv62" // CHECK-HVXFEAT: "-target-feature" "+hvxv62"
// With -mhvx, the version of hvx defaults to Cpu // With -mhvx, the version of hvx defaults to Cpu
// RUN: %clang -c %s -### -target hexagon-unknown-elf -mv60 -mhvx \ // RUN: %clang -c %s -### -target hexagon-unknown-elf -mv60 -mhvx \
// RUN: 2>&1 | FileCheck -check-prefix=CHECK-HVX-DEFAULT %s // RUN: 2>&1 | FileCheck -check-prefix=CHECK-HVX-DEFAULT %s
// CHECK-HVX-DEFAULT: "-target-feature" "+hvxv60" // CHECK-HVX-DEFAULT: "-target-feature" "+hvxv60"
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

cfe/trunk/test/Driver/rtti-options.cpp

// Check that we emit warnings/errors for different combinations of // Check that we emit warnings/errors for different combinations of
// exceptions, rtti, and vptr sanitizer flags when targetting the PS4. // exceptions, rtti, and vptr sanitizer flags when targeting the PS4.
// No warnings/errors should be emitted for unknown, except if combining // No warnings/errors should be emitted for unknown, except if combining
// the vptr sanitizer with -fno-rtti // the vptr sanitizer with -fno-rtti
// Special cases: -fcxx-exceptions in C code should warn about unused arguments // Special cases: -fcxx-exceptions in C code should warn about unused arguments
// We should also not have any rtti-related arguments // We should also not have any rtti-related arguments
// RUN: %clang -x c -### -target x86_64-scei-ps4 -c -fcxx-exceptions %s 2>&1 | FileCheck -check-prefix=CHECK-UNUSED -check-prefix=CHECK-RTTI -check-prefix=CHECK-NO-RTTI %s // RUN: %clang -x c -### -target x86_64-scei-ps4 -c -fcxx-exceptions %s 2>&1 | FileCheck -check-prefix=CHECK-UNUSED -check-prefix=CHECK-RTTI -check-prefix=CHECK-NO-RTTI %s
// RUN: %clang -x c -### -target x86_64-unknown-unknown -c -fcxx-exceptions %s 2>&1 | FileCheck -check-prefix=CHECK-UNUSED -check-prefix=CHECK-RTTI -check-prefix=CHECK-NO-RTTI %s // RUN: %clang -x c -### -target x86_64-unknown-unknown -c -fcxx-exceptions %s 2>&1 | FileCheck -check-prefix=CHECK-UNUSED -check-prefix=CHECK-RTTI -check-prefix=CHECK-NO-RTTI %s
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

cfe/trunk/test/Headers/ms-null-ms-header-vs-stddef.cpp

// RUN: %clang_cc1 -fsyntax-only -triple i686-pc-win32 -fms-compatibility -fms-compatibility-version=17.00 %s // RUN: %clang_cc1 -fsyntax-only -triple i686-pc-win32 -fms-compatibility -fms-compatibility-version=17.00 %s
// RUN: %clang_cc1 -fsyntax-only -triple i386-mingw32 %s // RUN: %clang_cc1 -fsyntax-only -triple i386-mingw32 %s
// Something in MSVC's headers (pulled in e.g. by <crtdefs.h>) defines __null // Something in MSVC's headers (pulled in e.g. by <crtdefs.h>) defines __null
// to something, mimick that. // to something, mimic that.
#define __null #define __null
#include <stddef.h> #include <stddef.h>
// __null is used as a type annotation in MS headers, with __null defined to // __null is used as a type annotation in MS headers, with __null defined to
// nothing in regular builds. This should continue to work even with stddef.h // nothing in regular builds. This should continue to work even with stddef.h
// included. // included.
void f(__null void* p) { } void f(__null void* p) { }
// NULL should work fine even with __null defined to nothing. // NULL should work fine even with __null defined to nothing.
void* p = NULL; void* p = NULL;

cfe/trunk/test/Index/headerfile-comment-to-html.m

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines
// CHECK-NEXT: (CXComment_Paragraph // CHECK-NEXT: (CXComment_Paragraph
// CHECK-NEXT: (CXComment_Text Text=[ This is Sensor on the Device.] HasTrailingNewline) // CHECK-NEXT: (CXComment_Text Text=[ This is Sensor on the Device.] HasTrailingNewline)
// CHECK-NEXT: (CXComment_Text Text=[ Its purpose is not to Sense Device's heat.]))))] // CHECK-NEXT: (CXComment_Text Text=[ Its purpose is not to Sense Device's heat.]))))]
/*! /*!
\brief Test that headerfile can come after brief. \brief Test that headerfile can come after brief.
\headerfile VTDevice.h <VTFoundation/VTDevice.h> \headerfile VTDevice.h <VTFoundation/VTDevice.h>
More property decription goes here. More property description goes here.
*/ */
@interface VTDevice : Device @interface VTDevice : Device
@end @end
// CHECK: headerfile-comment-to-html.m:[[@LINE-2]]:12: ObjCInterfaceDecl=VTDevice:{{.*}} FullCommentAsXML=[<Other file="{{[^"]+}}headerfile-comment-to-html.m" line="[[@LINE-2]]" column="12"><Name>VTDevice</Name><USR>c:objc(cs)VTDevice</USR><Headerfile><Para> VTDevice.h &lt;VTFoundation/VTDevice.h&gt;</Para></Headerfile><Declaration>@interface VTDevice : Device\n@end</Declaration><Abstract><Para> Test that headerfile can come after brief. </Para></Abstract><Discussion><Para> More property decription goes here.</Para></Discussion></Other>] // CHECK: headerfile-comment-to-html.m:[[@LINE-2]]:12: ObjCInterfaceDecl=VTDevice:{{.*}} FullCommentAsXML=[<Other file="{{[^"]+}}headerfile-comment-to-html.m" line="[[@LINE-2]]" column="12"><Name>VTDevice</Name><USR>c:objc(cs)VTDevice</USR><Headerfile><Para> VTDevice.h &lt;VTFoundation/VTDevice.h&gt;</Para></Headerfile><Declaration>@interface VTDevice : Device\n@end</Declaration><Abstract><Para> Test that headerfile can come after brief. </Para></Abstract><Discussion><Para> More property description goes here.</Para></Discussion></Other>]
// CHECK-NEXT: CommentAST=[ // CHECK-NEXT: CommentAST=[
// CHECK-NEXT: (CXComment_FullComment // CHECK-NEXT: (CXComment_FullComment
// CHECK-NEXT: (CXComment_Paragraph IsWhitespace // CHECK-NEXT: (CXComment_Paragraph IsWhitespace
// CHECK-NEXT: (CXComment_Text Text=[ ] IsWhitespace)) // CHECK-NEXT: (CXComment_Text Text=[ ] IsWhitespace))
// CHECK-NEXT: (CXComment_BlockCommand CommandName=[brief] // CHECK-NEXT: (CXComment_BlockCommand CommandName=[brief]
// CHECK-NEXT: (CXComment_Paragraph // CHECK-NEXT: (CXComment_Paragraph
// CHECK-NEXT: (CXComment_Text Text=[ Test that headerfile can come after brief.] HasTrailingNewline) // CHECK-NEXT: (CXComment_Text Text=[ Test that headerfile can come after brief.] HasTrailingNewline)
// CHECK-NEXT: (CXComment_Text Text=[ ] IsWhitespace))) // CHECK-NEXT: (CXComment_Text Text=[ ] IsWhitespace)))
// CHECK-NEXT: (CXComment_BlockCommand CommandName=[headerfile] // CHECK-NEXT: (CXComment_BlockCommand CommandName=[headerfile]
// CHECK-NEXT: (CXComment_Paragraph // CHECK-NEXT: (CXComment_Paragraph
// CHECK-NEXT: (CXComment_Text Text=[ VTDevice.h ]) // CHECK-NEXT: (CXComment_Text Text=[ VTDevice.h ])
// CHECK-NEXT: (CXComment_Text Text=[<VTFoundation]) // CHECK-NEXT: (CXComment_Text Text=[<VTFoundation])
// CHECK-NEXT: (CXComment_Text Text=[/VTDevice.h>]))) // CHECK-NEXT: (CXComment_Text Text=[/VTDevice.h>])))
// CHECK-NEXT: (CXComment_Paragraph // CHECK-NEXT: (CXComment_Paragraph
// CHECK-NEXT: (CXComment_Text Text=[ More property decription goes here.])))] // CHECK-NEXT: (CXComment_Text Text=[ More property description goes here.])))]
/*! /*!
\headerfile <stdio.h> \headerfile <stdio.h>
*/ */
extern void uses_stdio_h(); extern void uses_stdio_h();
// CHECK: headerfile-comment-to-html.m:[[@LINE-1]]:13: FunctionDecl=uses_stdio_h:{{.*}} FullCommentAsXML=[<Function file="{{[^"]+}}headerfile-comment-to-html.m" line="[[@LINE-1]]" column="13"><Name>uses_stdio_h</Name><USR>c:@F@uses_stdio_h</USR><Headerfile><Para> &lt;stdio.h&gt;</Para></Headerfile><Declaration>extern void uses_stdio_h()</Declaration></Function>] // CHECK: headerfile-comment-to-html.m:[[@LINE-1]]:13: FunctionDecl=uses_stdio_h:{{.*}} FullCommentAsXML=[<Function file="{{[^"]+}}headerfile-comment-to-html.m" line="[[@LINE-1]]" column="13"><Name>uses_stdio_h</Name><USR>c:@F@uses_stdio_h</USR><Headerfile><Para> &lt;stdio.h&gt;</Para></Headerfile><Declaration>extern void uses_stdio_h()</Declaration></Function>]
// CHECK-NEXT: CommentAST=[ // CHECK-NEXT: CommentAST=[
// CHECK-NEXT: (CXComment_FullComment // CHECK-NEXT: (CXComment_FullComment
Show All 23 Lines

cfe/trunk/test/Misc/ast-print-pragmas-xfail.cpp

// RUN: %clang_cc1 %s -ast-print -o - | FileCheck %s // RUN: %clang_cc1 %s -ast-print -o - | FileCheck %s
// FIXME: Test fails because attribute order is reversed by ParsedAttributes. // FIXME: Test fails because attribute order is reversed by ParsedAttributes.
// XFAIL: * // XFAIL: *
void run1(int *List, int Length) { void run1(int *List, int Length) {
int i = 0; int i = 0;
// CEHCK: #pragma loop vectorize(4) // CHECK: #pragma loop vectorize(4)
// CHECK-NEXT: #pragma loop interleave(8) // CHECK-NEXT: #pragma loop interleave(8)
// CHECK-NEXT: #pragma loop vectorize(enable) // CHECK-NEXT: #pragma loop vectorize(enable)
// CHECK-NEXT: #pragma loop interleave(enable) // CHECK-NEXT: #pragma loop interleave(enable)
#pragma loop vectorize(4) #pragma loop vectorize(4)
#pragma loop interleave(8) #pragma loop interleave(8)
#pragma loop vectorize(enable) #pragma loop vectorize(enable)
#pragma loop interleave(enable) #pragma loop interleave(enable)
// CHECK-NEXT: while (i < Length) // CHECK-NEXT: while (i < Length)
while (i < Length) { while (i < Length) {
List[i] = i; List[i] = i;
i++; i++;
} }
} }

cfe/trunk/test/Misc/warning-flags.c

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
CHECK-NEXT: warn_no_constructor_for_refconst CHECK-NEXT: warn_no_constructor_for_refconst
CHECK-NEXT: warn_not_compound_assign CHECK-NEXT: warn_not_compound_assign
CHECK-NEXT: warn_objc_property_copy_missing_on_block CHECK-NEXT: warn_objc_property_copy_missing_on_block
CHECK-NEXT: warn_objc_protocol_qualifier_missing_id CHECK-NEXT: warn_objc_protocol_qualifier_missing_id
CHECK-NEXT: warn_on_superclass_use CHECK-NEXT: warn_on_superclass_use
CHECK-NEXT: warn_pp_convert_to_positive CHECK-NEXT: warn_pp_convert_to_positive
CHECK-NEXT: warn_pp_expr_overflow CHECK-NEXT: warn_pp_expr_overflow
CHECK-NEXT: warn_pp_line_decimal CHECK-NEXT: warn_pp_line_decimal
CHECK-NEXT: warn_pragma_pack_pop_identifer_and_alignment CHECK-NEXT: warn_pragma_pack_pop_identifier_and_alignment
CHECK-NEXT: warn_pragma_pack_show CHECK-NEXT: warn_pragma_pack_show
CHECK-NEXT: warn_property_getter_owning_mismatch CHECK-NEXT: warn_property_getter_owning_mismatch
CHECK-NEXT: warn_register_objc_catch_parm CHECK-NEXT: warn_register_objc_catch_parm
CHECK-NEXT: warn_related_result_type_compatibility_class CHECK-NEXT: warn_related_result_type_compatibility_class
CHECK-NEXT: warn_related_result_type_compatibility_protocol CHECK-NEXT: warn_related_result_type_compatibility_protocol
CHECK-NEXT: warn_template_export_unsupported CHECK-NEXT: warn_template_export_unsupported
CHECK-NEXT: warn_template_spec_extra_headers CHECK-NEXT: warn_template_spec_extra_headers
CHECK-NEXT: warn_tentative_incomplete_array CHECK-NEXT: warn_tentative_incomplete_array
Show All 10 Lines

cfe/trunk/test/OpenMP/target_codegen_registration.cpp

Show All 28 Lines
// RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc // RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
// RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// SIMD-ONLY1-NOT: {{__kmpc|__tgt}} // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
// Check that no target code is emmitted if no omptests flag was provided. // Check that no target code is emitted if no omptests flag was provided.
// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET // RUN: %clang_cc1 -verify -fopenmp -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
// RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s // RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
// SIMD-ONLY2-NOT: {{__kmpc|__tgt}} // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
// expected-no-diagnostics // expected-no-diagnostics
#ifndef HEADER #ifndef HEADER
#define HEADER #define HEADER
▲ Show 20 Lines • Show All 417 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_parallel_codegen_registration.cpp

Show All 28 Lines
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// SIMD-ONLY1-NOT: {{__kmpc|__tgt}} // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
// Check that no target code is emmitted if no omptests flag was provided. // Check that no target code is emitted if no omptests flag was provided.
// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
// SIMD-ONLY2-NOT: {{__kmpc|__tgt}} // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
// expected-no-diagnostics // expected-no-diagnostics
#ifndef HEADER #ifndef HEADER
#define HEADER #define HEADER
▲ Show 20 Lines • Show All 417 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_parallel_for_codegen_registration.cpp

Show All 28 Lines
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// SIMD-ONLY1-NOT: {{__kmpc|__tgt}} // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
// Check that no target code is emmitted if no omptests flag was provided. // Check that no target code is emitted if no omptests flag was provided.
// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
// SIMD-ONLY2-NOT: {{__kmpc|__tgt}} // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
// expected-no-diagnostics // expected-no-diagnostics
#ifndef HEADER #ifndef HEADER
#define HEADER #define HEADER
▲ Show 20 Lines • Show All 427 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_parallel_for_simd_codegen_registration.cpp

Show All 28 Lines
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// SIMD-ONLY1-NOT: {{__kmpc|__tgt}} // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
// Check that no target code is emmitted if no omptests flag was provided. // Check that no target code is emitted if no omptests flag was provided.
// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
// SIMD-ONLY2-NOT: {{__kmpc|__tgt}} // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
// expected-no-diagnostics // expected-no-diagnostics
#ifndef HEADER #ifndef HEADER
#define HEADER #define HEADER
▲ Show 20 Lines • Show All 427 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_simd_codegen_registration.cpp

Show All 28 Lines
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// SIMD-ONLY1-NOT: {{__kmpc|__tgt}} // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
// Check that no target code is emmitted if no omptests flag was provided. // Check that no target code is emitted if no omptests flag was provided.
// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
// SIMD-ONLY2-NOT: {{__kmpc|__tgt}} // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
// expected-no-diagnostics // expected-no-diagnostics
#ifndef HEADER #ifndef HEADER
#define HEADER #define HEADER
▲ Show 20 Lines • Show All 427 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_teams_codegen_registration.cpp

Show All 28 Lines
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// SIMD-ONLY1-NOT: {{__kmpc|__tgt}} // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
// Check that no target code is emmitted if no omptests flag was provided. // Check that no target code is emitted if no omptests flag was provided.
// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
// SIMD-ONLY2-NOT: {{__kmpc|__tgt}} // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
// expected-no-diagnostics // expected-no-diagnostics
#ifndef HEADER #ifndef HEADER
#define HEADER #define HEADER
▲ Show 20 Lines • Show All 417 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_teams_distribute_codegen_registration.cpp

Show All 28 Lines
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// SIMD-ONLY1-NOT: {{__kmpc|__tgt}} // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
// Check that no target code is emmitted if no omptests flag was provided. // Check that no target code is emitted if no omptests flag was provided.
// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
// SIMD-ONLY2-NOT: {{__kmpc|__tgt}} // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
// expected-no-diagnostics // expected-no-diagnostics
#ifndef HEADER #ifndef HEADER
#define HEADER #define HEADER
▲ Show 20 Lines • Show All 427 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_teams_distribute_parallel_for_simd_codegen_registration.cpp

Show All 28 Lines
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// SIMD-ONLY1-NOT: {{__kmpc|__tgt}} // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
// Check that no target code is emmitted if no omptests flag was provided. // Check that no target code is emitted if no omptests flag was provided.
// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
// SIMD-ONLY2-NOT: {{__kmpc|__tgt}} // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
// expected-no-diagnostics // expected-no-diagnostics
#ifndef HEADER #ifndef HEADER
#define HEADER #define HEADER
▲ Show 20 Lines • Show All 427 Lines • Show Last 20 Lines

cfe/trunk/test/OpenMP/target_teams_distribute_simd_codegen_registration.cpp

Show All 28 Lines
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm-bc %s -o %t-x86-host.bc
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-llvm %s -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -emit-pch -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -o %t %s
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
// SIMD-ONLY1-NOT: {{__kmpc|__tgt}} // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
// Check that no target code is emmitted if no omptests flag was provided. // Check that no target code is emitted if no omptests flag was provided.
// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s
// SIMD-ONLY2-NOT: {{__kmpc|__tgt}} // SIMD-ONLY2-NOT: {{__kmpc|__tgt}}
// expected-no-diagnostics // expected-no-diagnostics
#ifndef HEADER #ifndef HEADER
#define HEADER #define HEADER
▲ Show 20 Lines • Show All 430 Lines • Show Last 20 Lines

cfe/trunk/test/Parser/brackets.c

Show All 9 Linesvoid test1() {
// expected-error@-1{{brackets are not allowed here; to declare an array, place the brackets after the identifier}} // expected-error@-1{{brackets are not allowed here; to declare an array, place the brackets after the identifier}}
// CHECK: {{^}} int []b = {0,1,4,9,16}; // CHECK: {{^}} int []b = {0,1,4,9,16};
// CHECK: {{^}} ~~ ^ // CHECK: {{^}} ~~ ^
// CHECK: {{^}} [] // CHECK: {{^}} []
// CHECK: fix-it:{{.*}}:{[[@LINE-5]]:7-[[@LINE-5]]:9}:"" // CHECK: fix-it:{{.*}}:{[[@LINE-5]]:7-[[@LINE-5]]:9}:""
// CHECK: fix-it:{{.*}}:{[[@LINE-6]]:10-[[@LINE-6]]:10}:"[]" // CHECK: fix-it:{{.*}}:{[[@LINE-6]]:10-[[@LINE-6]]:10}:"[]"
int c = a[0]; int c = a[0];
int d = b[0]; // No undeclared identifer error here. int d = b[0]; // No undeclared identifier error here.
int *e = a; int *e = a;
int *f = b; // No undeclared identifer error here. int *f = b; // No undeclared identifier error here.
} }
struct S { struct S {
int [1][1]x; int [1][1]x;
// expected-error@-1{{brackets are not allowed here; to declare an array, place the brackets after the identifier}} // expected-error@-1{{brackets are not allowed here; to declare an array, place the brackets after the identifier}}
// CHECK: {{^}} int [1][1]x; // CHECK: {{^}} int [1][1]x;
// CHECK: {{^}} ~~~~~~ ^ // CHECK: {{^}} ~~~~~~ ^
// CHECK: {{^}} [1][1] // CHECK: {{^}} [1][1]
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

cfe/trunk/test/Parser/brackets.cpp

Show All 9 Linesvoid test1() {
// expected-error@-1{{brackets are not allowed here; to declare an array, place the brackets after the name}} // expected-error@-1{{brackets are not allowed here; to declare an array, place the brackets after the name}}
// CHECK: {{^}} int []b = {0,1,4,9,16}; // CHECK: {{^}} int []b = {0,1,4,9,16};
// CHECK: {{^}} ~~ ^ // CHECK: {{^}} ~~ ^
// CHECK: {{^}} [] // CHECK: {{^}} []
// CHECK: fix-it:{{.*}}:{[[@LINE-5]]:7-[[@LINE-5]]:9}:"" // CHECK: fix-it:{{.*}}:{[[@LINE-5]]:7-[[@LINE-5]]:9}:""
// CHECK: fix-it:{{.*}}:{[[@LINE-6]]:10-[[@LINE-6]]:10}:"[]" // CHECK: fix-it:{{.*}}:{[[@LINE-6]]:10-[[@LINE-6]]:10}:"[]"
int c = a[0]; int c = a[0];
int d = b[0]; // No undeclared identifer error here. int d = b[0]; // No undeclared identifier error here.
int *e = a; int *e = a;
int *f = b; // No undeclared identifer error here. int *f = b; // No undeclared identifier error here.
int[1] g[2]; int[1] g[2];
// expected-error@-1{{brackets are not allowed here; to declare an array, place the brackets after the name}} // expected-error@-1{{brackets are not allowed here; to declare an array, place the brackets after the name}}
// CHECK: {{^}} int[1] g[2]; // CHECK: {{^}} int[1] g[2];
// CHECK: {{^}} ~~~ ^ // CHECK: {{^}} ~~~ ^
// CHECK: {{^}} [1] // CHECK: {{^}} [1]
// CHECK: fix-it:{{.*}}:{[[@LINE-5]]:6-[[@LINE-5]]:9}:"" // CHECK: fix-it:{{.*}}:{[[@LINE-5]]:6-[[@LINE-5]]:9}:""
// CHECK: fix-it:{{.*}}:{[[@LINE-6]]:14-[[@LINE-6]]:14}:"[1]" // CHECK: fix-it:{{.*}}:{[[@LINE-6]]:14-[[@LINE-6]]:14}:"[1]"
▲ Show 20 Lines • Show All 132 Lines • Show Last 20 Lines

cfe/trunk/test/Preprocessor/macro_paste_commaext.c

// RUN: %clang_cc1 %s -E | FileCheck --strict-whitespace --match-full-lines %s // RUN: %clang_cc1 %s -E | FileCheck --strict-whitespace --match-full-lines %s
// In the following tests, note that the output is sensitive to the // In the following tests, note that the output is sensitive to the
// whitespace *preceeding* the varargs argument, as well as to // whitespace *preceding* the varargs argument, as well as to
// interior whitespace. AFAIK, this is the only case where whitespace // interior whitespace. AFAIK, this is the only case where whitespace
// preceeding an argument matters, and might be considered a bug in // preceding an argument matters, and might be considered a bug in
// GCC. Nevertheless, since this feature is a GCC extension in the // GCC. Nevertheless, since this feature is a GCC extension in the
// first place, we'll follow along. // first place, we'll follow along.
#define debug(format, ...) format, ## __VA_ARGS__) #define debug(format, ...) format, ## __VA_ARGS__)
// CHECK:V); // CHECK:V);
debug(V); debug(V);
// CHECK:W,1, 2); // CHECK:W,1, 2);
debug(W,1, 2); debug(W,1, 2);
// CHECK:X, 1, 2); // CHECK:X, 1, 2);
debug(X, 1, 2 ); debug(X, 1, 2 );
// CHECK:Y,); // CHECK:Y,);
debug(Y, ); debug(Y, );
// CHECK:Z,); // CHECK:Z,);
debug(Z,); debug(Z,);

cfe/trunk/test/Sema/attr-availability-tvos.c

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
void test_tvos() { void test_tvos() {
f0_tvos(0); // expected-warning{{'f0_tvos' is deprecated: first deprecated in tvOS 2.1}} f0_tvos(0); // expected-warning{{'f0_tvos' is deprecated: first deprecated in tvOS 2.1}}
f1_tvos(0); f1_tvos(0);
f2_tvos(0); // expected-warning{{'f2_tvos' is deprecated: first deprecated in tvOS 3.0}} f2_tvos(0); // expected-warning{{'f2_tvos' is deprecated: first deprecated in tvOS 3.0}}
f3_tvos(0); f3_tvos(0);
f4_tvos(0); // expected-error{{'f4_tvos' is unavailable: obsoleted in tvOS 3.0}} f4_tvos(0); // expected-error{{'f4_tvos' is unavailable: obsoleted in tvOS 3.0}}
// We get no warning here because any explicit 'tvos' availability causes // We get no warning here because any explicit 'tvos' availability causes
// the ios availablity to not implicitly become 'tvos' availability. Otherwise we'd get // the ios availability to not implicitly become 'tvos' availability. Otherwise we'd get
// a deprecated warning. // a deprecated warning.
f5_tvos(0); // no-warning f5_tvos(0); // no-warning
f5_attr_reversed_tvos(0); // no-warning f5_attr_reversed_tvos(0); // no-warning
// We get a deprecated warning here because both attributes are explicitly 'tvos'. // We get a deprecated warning here because both attributes are explicitly 'tvos'.
f5b_tvos(0); // expected-warning {{'f5b_tvos' is deprecated: first deprecated in tvOS 3.0}} f5b_tvos(0); // expected-warning {{'f5b_tvos' is deprecated: first deprecated in tvOS 3.0}}
// We get a deprecated warning here because both attributes are 'ios' (both get mapped to 'tvos'). // We get a deprecated warning here because both attributes are 'ios' (both get mapped to 'tvos').
f5c_tvos(0); // expected-warning {{'f5c_tvos' is deprecated: first deprecated in tvOS 3.0}} f5c_tvos(0); // expected-warning {{'f5c_tvos' is deprecated: first deprecated in tvOS 3.0}}
f6_tvos(0); // expected-warning{{'f6_tvos' is deprecated: first deprecated in tvOS 3.0}} f6_tvos(0); // expected-warning{{'f6_tvos' is deprecated: first deprecated in tvOS 3.0}}
} }

cfe/trunk/test/Sema/attr-availability-watchos.c

Show All 36 Lines
void test_watchos() { void test_watchos() {
f0_watchos(0); // expected-warning{{'f0_watchos' is deprecated: first deprecated in watchOS 2.1}} f0_watchos(0); // expected-warning{{'f0_watchos' is deprecated: first deprecated in watchOS 2.1}}
f1_watchos(0); f1_watchos(0);
f2_watchos(0); // expected-warning{{'f2_watchos' is deprecated: first deprecated in watchOS 3.0}} f2_watchos(0); // expected-warning{{'f2_watchos' is deprecated: first deprecated in watchOS 3.0}}
f3_watchos(0); f3_watchos(0);
f4_watchos(0); // expected-error{{'f4_watchos' is unavailable: obsoleted in watchOS 3.0}} f4_watchos(0); // expected-error{{'f4_watchos' is unavailable: obsoleted in watchOS 3.0}}
// We get no warning here because any explicit 'watchos' availability causes // We get no warning here because any explicit 'watchos' availability causes
// the ios availablity to not implicitly become 'watchos' availability. Otherwise we'd get // the ios availability to not implicitly become 'watchos' availability. Otherwise we'd get
// a deprecated warning. // a deprecated warning.
f5_watchos(0); // no-warning f5_watchos(0); // no-warning
f5_attr_reversed_watchos(0); // no-warning f5_attr_reversed_watchos(0); // no-warning
// We get a deprecated warning here because both attributes are explicitly 'watchos'. // We get a deprecated warning here because both attributes are explicitly 'watchos'.
f5b_watchos(0); // expected-warning {{'f5b_watchos' is deprecated: first deprecated in watchOS 3.0}} f5b_watchos(0); // expected-warning {{'f5b_watchos' is deprecated: first deprecated in watchOS 3.0}}
// We get a deprecated warning here because both attributes are 'ios' (both get mapped to 'watchos'). // We get a deprecated warning here because both attributes are 'ios' (both get mapped to 'watchos').
f5c_watchos(0); // expected-warning {{'f5c_watchos' is deprecated: first deprecated in watchOS 2.0}} f5c_watchos(0); // expected-warning {{'f5c_watchos' is deprecated: first deprecated in watchOS 2.0}}
f6_watchos(0); // expected-warning {{'f6_watchos' is deprecated: first deprecated in watchOS 3.0}} f6_watchos(0); // expected-warning {{'f6_watchos' is deprecated: first deprecated in watchOS 3.0}}
} }

cfe/trunk/test/Sema/pr30372.c

// REQUIRES: x86-registered-target // REQUIRES: x86-registered-target
// RUN: %clang_cc1 %s -triple i386-pc-windows-msvc18.0.0 -disable-free -fms-volatile -fms-extensions -fms-compatibility -fms-compatibility-version=18 -std=c++11 -x c++ // RUN: %clang_cc1 %s -triple i386-pc-windows-msvc18.0.0 -disable-free -fms-volatile -fms-extensions -fms-compatibility -fms-compatibility-version=18 -std=c++11 -x c++
// Check that the parser catching an 'error' from forward declaration of "location" does not lexer out it's subsequent declation. // Check that the parser catching an 'error' from forward declaration of "location" does not lexer out it's subsequent declaration.
void foo() { void foo() {
__asm { __asm {
jl location jl location
location: location:
ret ret
} }
} }

cfe/trunk/test/Sema/self-comparison.c

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Linesint array_comparisons() {
return array1 == array1; // expected-warning{{self-comparison always evaluates to true}} return array1 == array1; // expected-warning{{self-comparison always evaluates to true}}
return array1 != array1; // expected-warning{{self-comparison always evaluates to false}} return array1 != array1; // expected-warning{{self-comparison always evaluates to false}}
return array1 < array1; // expected-warning{{self-comparison always evaluates to false}} return array1 < array1; // expected-warning{{self-comparison always evaluates to false}}
return array1 <= array1; // expected-warning{{self-comparison always evaluates to true}} return array1 <= array1; // expected-warning{{self-comparison always evaluates to true}}
return array1 > array1; // expected-warning{{self-comparison always evaluates to false}} return array1 > array1; // expected-warning{{self-comparison always evaluates to false}}
return array1 >= array1; // expected-warning{{self-comparison always evaluates to true}} return array1 >= array1; // expected-warning{{self-comparison always evaluates to true}}
// //
// compare differrent arrays // compare different arrays
// //
return array1 == array2; // expected-warning{{array comparison always evaluates to false}} return array1 == array2; // expected-warning{{array comparison always evaluates to false}}
return array1 != array2; // expected-warning{{array comparison always evaluates to true}} return array1 != array2; // expected-warning{{array comparison always evaluates to true}}
// //
// we don't know what these are going to be // we don't know what these are going to be
// //
return array1 < array2; // expected-warning{{array comparison always evaluates to a constant}} return array1 < array2; // expected-warning{{array comparison always evaluates to a constant}}
Show All 22 Lines

cfe/trunk/test/Sema/tls.c

// Test that TLS is correctly considered supported or unsupported for the // Test that TLS is correctly considered supported or unsupported for the
// different targets. // different targets.
// Linux supports TLS. // Linux supports TLS.
// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fsyntax-only %s // RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fsyntax-only %s
// RUN: %clang_cc1 -triple i386-pc-linux-gnu -fsyntax-only %s // RUN: %clang_cc1 -triple i386-pc-linux-gnu -fsyntax-only %s
// Darwin supports TLS since 10.7. // Darwin supports TLS since 10.7.
// RUN: not %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only %s // RUN: not %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only %s
// RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -fsyntax-only %s // RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -fsyntax-only %s
// RUN: %clang_cc1 -triple x86_64-pc-win32 -fsyntax-only %s // RUN: %clang_cc1 -triple x86_64-pc-win32 -fsyntax-only %s
// RUN: %clang_cc1 -triple i386-pc-win32 -fsyntax-only %s // RUN: %clang_cc1 -triple i386-pc-win32 -fsyntax-only %s
// OpenBSD suppports TLS. // OpenBSD supports TLS.
// RUN: %clang_cc1 -triple x86_64-pc-openbsd -fsyntax-only %s // RUN: %clang_cc1 -triple x86_64-pc-openbsd -fsyntax-only %s
// RUN: %clang_cc1 -triple i386-pc-openbsd -fsyntax-only %s // RUN: %clang_cc1 -triple i386-pc-openbsd -fsyntax-only %s
// Haiku does not suppport TLS. // Haiku does not support TLS.
// RUN: not %clang_cc1 -triple i586-pc-haiku -fsyntax-only %s // RUN: not %clang_cc1 -triple i586-pc-haiku -fsyntax-only %s
__thread int x; __thread int x;

cfe/trunk/test/Sema/uninit-variables.c

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Lines
} }
void test15() { void test15() {
int x = x; // no-warning: signals intended lack of initialization. int x = x; // no-warning: signals intended lack of initialization.
} }
int test15b() { int test15b() {
// Warn here with the self-init, since it does result in a use of // Warn here with the self-init, since it does result in a use of
// an unintialized variable and this is the root cause. // an uninitialized variable and this is the root cause.
int x = x; // expected-warning {{variable 'x' is uninitialized when used within its own initialization}} int x = x; // expected-warning {{variable 'x' is uninitialized when used within its own initialization}}
return x; return x;
} }
// Don't warn in the following example; shows dataflow confluence. // Don't warn in the following example; shows dataflow confluence.
char *test16_aux(); char *test16_aux();
void test16() { void test16() {
char *p = test16_aux(); char *p = test16_aux();
▲ Show 20 Lines • Show All 411 Lines • Show Last 20 Lines

cfe/trunk/test/Sema/vector-gcc-compat.c

Show First 20 Lines • Show All 108 Lines • ▼ Show 20 Linesvoid logicTest(void) {
v2i64_r = 1 << v2i64_a; v2i64_r = 1 << v2i64_a;
v2i64_r = 1 >> v2i64_a; v2i64_r = 1 >> v2i64_a;
v2i64_a <<= 1; v2i64_a <<= 1;
v2i64_a >>= 1; v2i64_a >>= 1;
} }
// For operations with floating point types, we check that interger constants // For operations with floating point types, we check that integer constants
// can be respresented, or failing that checking based on the integer types. // can be respresented, or failing that checking based on the integer types.
void floatTestConstant(void) { void floatTestConstant(void) {
// Test that constants added to floats must be expressible as floating point // Test that constants added to floats must be expressible as floating point
// numbers. // numbers.
v4f32 v4f32_a = {0.4f, 0.4f, 0.4f, 0.4f}; v4f32 v4f32_a = {0.4f, 0.4f, 0.4f, 0.4f};
v4f32_a = v4f32_a + 1; v4f32_a = v4f32_a + 1;
v4f32_a = v4f32_a + 0xFFFFFF; v4f32_a = v4f32_a + 0xFFFFFF;
v4f32_a = v4f32_a + (-1567563LL); v4f32_a = v4f32_a + (-1567563LL);
▲ Show 20 Lines • Show All 205 Lines • Show Last 20 Lines

cfe/trunk/test/Sema/vector-gcc-compat.cpp

Show First 20 Lines • Show All 106 Lines • ▼ Show 20 Linesvoid logicTest(void) {
v2i64_r = 1 << v2i64_a; v2i64_r = 1 << v2i64_a;
v2i64_r = 1 >> v2i64_a; v2i64_r = 1 >> v2i64_a;
v2i64_a <<= 1; v2i64_a <<= 1;
v2i64_a >>= 1; v2i64_a >>= 1;
} }
// For operations with floating point types, we check that interger constants // For operations with floating point types, we check that integer constants
// can be respresented, or failing that checking based on the integer types. // can be respresented, or failing that checking based on the integer types.
void floatTestConstant(void) { void floatTestConstant(void) {
// Test that constants added to floats must be expressible as floating point // Test that constants added to floats must be expressible as floating point
// numbers. // numbers.
v4f32 v4f32_a = {0.4f, 0.4f, 0.4f, 0.4f}; v4f32 v4f32_a = {0.4f, 0.4f, 0.4f, 0.4f};
v4f32_a = v4f32_a + 1; v4f32_a = v4f32_a + 1;
v4f32_a = v4f32_a + 0xFFFFFF; v4f32_a = v4f32_a + 0xFFFFFF;
v4f32_a = v4f32_a + (-1567563LL); // expected-warning {{'long long' is incompatible with C++98}} v4f32_a = v4f32_a + (-1567563LL); // expected-warning {{'long long' is incompatible with C++98}}
▲ Show 20 Lines • Show All 205 Lines • Show Last 20 Lines

cfe/trunk/test/Sema/warn-documentation.m

Show First 20 Lines • Show All 212 Lines • ▼ Show 20 Lines
@implementation rdar14024851 // expected-error {{reimplementation}} @implementation rdar14024851 // expected-error {{reimplementation}}
/// \brief comment /// \brief comment
-(void)meth {} -(void)meth {}
@end @end
// rdar://14124644 // rdar://14124644
@interface test_vararg1 @interface test_vararg1
/// @param[in] arg somthing /// @param[in] arg something
/// @param[in] ... This is vararg /// @param[in] ... This is vararg
- (void) VarArgMeth : (id)arg, ...; - (void) VarArgMeth : (id)arg, ...;
@end @end
@implementation test_vararg1 @implementation test_vararg1
/// @param[in] arg somthing /// @param[in] arg something
/// @param[in] ... This is vararg /// @param[in] ... This is vararg
- (void) VarArgMeth : (id)arg, ... {} - (void) VarArgMeth : (id)arg, ... {}
@end @end
/** /**
* blockPointerVariable * blockPointerVariable
* *
* @param i is integer. * @param i is integer.
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

cfe/trunk/test/Sema/warn-string-conversion.c

// RUN: %clang_cc1 -verify -fsyntax-only -Wstring-conversion %s // RUN: %clang_cc1 -verify -fsyntax-only -Wstring-conversion %s
void do_nothing(); void do_nothing();
void assert_error(); void assert_error();
#define assert1(expr) \ #define assert1(expr) \
if (expr) \ if (expr) \
do_nothing(); \ do_nothing(); \
else \ else \
assert_error() assert_error()
#define assert2(expr) \ #define assert2(expr) \
((expr) ? do_nothing() : assert_error()) ((expr) ? do_nothing() : assert_error())
// Expection for common assert form. // Exception for common assert form.
void test1() { void test1() {
assert1(0 && "foo"); assert1(0 && "foo");
assert1("foo" && 0); assert1("foo" && 0);
assert1(0 || "foo"); // expected-warning {{string literal}} assert1(0 || "foo"); // expected-warning {{string literal}}
assert1("foo"); // expected-warning {{string literal}} assert1("foo"); // expected-warning {{string literal}}
assert2(0 && "foo"); assert2(0 && "foo");
assert2("foo" && 0); assert2("foo" && 0);
Show All 11 Lines

cfe/trunk/test/SemaCUDA/function-template-overload.cu

Show All 35 Lines
template <typename T> __host__ __device__ HDType overload_hd(T a) { return HDType(); } template <typename T> __host__ __device__ HDType overload_hd(T a) { return HDType(); }
// expected-note@-1 {{previous declaration is here}} // expected-note@-1 {{previous declaration is here}}
// expected-note@-2 2 {{candidate template ignored: could not match 'HDType' against 'HType'}} // expected-note@-2 2 {{candidate template ignored: could not match 'HDType' against 'HType'}}
template <typename T> __device__ HDType overload_hd(T a); template <typename T> __device__ HDType overload_hd(T a);
// expected-error@-1 {{__device__ function 'overload_hd' cannot overload __host__ __device__ function 'overload_hd'}} // expected-error@-1 {{__device__ function 'overload_hd' cannot overload __host__ __device__ function 'overload_hd'}}
__device__ HDType overload_hd(int a); // OK. __device__ HDType overload_hd(int a); // OK.
// Verify that target attributes are taken into account when we // Verify that target attributes are taken into account when we
// explicitly specialize or instantiate function tempaltes. // explicitly specialize or instantiate function templates.
template <> __host__ HType overload_hd(int a); template <> __host__ HType overload_hd(int a);
// expected-error@-1 {{no function template matches function template specialization 'overload_hd'}} // expected-error@-1 {{no function template matches function template specialization 'overload_hd'}}
template __host__ HType overload_hd(long a); template __host__ HType overload_hd(long a);
// expected-error@-1 {{explicit instantiation of 'overload_hd' does not refer to a function template, variable template, member function, member class, or static data member}} // expected-error@-1 {{explicit instantiation of 'overload_hd' does not refer to a function template, variable template, member function, member class, or static data member}}
__host__ HType overload_hd(int a); // OK __host__ HType overload_hd(int a); // OK
template <typename T> __host__ T overload_h(T a); // expected-note {{previous declaration is here}} template <typename T> __host__ T overload_h(T a); // expected-note {{previous declaration is here}}
template <typename T> __host__ __device__ T overload_h(T a); template <typename T> __host__ __device__ T overload_h(T a);
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

cfe/trunk/test/SemaCXX/conditional-expr.cpp

Show First 20 Lines • Show All 143 Lines • ▼ Show 20 Linesvoid test()
(void)(i1 ? base : fin); // expected-error {{ambiguous conversion from derived class 'Fin' to base class 'Base':}} (void)(i1 ? base : fin); // expected-error {{ambiguous conversion from derived class 'Fin' to base class 'Base':}}
(void)(i1 ? fin : base); // expected-error {{ambiguous conversion from derived class 'Fin' to base class 'Base':}} (void)(i1 ? fin : base); // expected-error {{ambiguous conversion from derived class 'Fin' to base class 'Base':}}
// b2.2 (non-hierarchy) // b2.2 (non-hierarchy)
i1 = i1 ? I() : i1; i1 = i1 ? I() : i1;
i1 = i1 ? i1 : I(); i1 = i1 ? i1 : I();
I i2(i1 ? I() : J()); I i2(i1 ? I() : J());
I i3(i1 ? J() : I()); I i3(i1 ? J() : I());
// "the type [it] woud have if E2 were converted to an rvalue" // "the type [it] would have if E2 were converted to an rvalue"
vfn pfn = i1 ? F() : test; vfn pfn = i1 ? F() : test;
pfn = i1 ? test : F(); pfn = i1 ? test : F();
(void)(i1 ? A() : B()); // expected-error {{conversion from 'B' to 'A' is ambiguous}} (void)(i1 ? A() : B()); // expected-error {{conversion from 'B' to 'A' is ambiguous}}
(void)(i1 ? B() : A()); // expected-error {{conversion from 'B' to 'A' is ambiguous}} (void)(i1 ? B() : A()); // expected-error {{conversion from 'B' to 'A' is ambiguous}}
(void)(i1 ? 1 : Ambig()); // expected-error {{conversion from 'Ambig' to 'int' is ambiguous}} (void)(i1 ? 1 : Ambig()); // expected-error {{conversion from 'Ambig' to 'int' is ambiguous}}
(void)(i1 ? Ambig() : 1); // expected-error {{conversion from 'Ambig' to 'int' is ambiguous}} (void)(i1 ? Ambig() : 1); // expected-error {{conversion from 'Ambig' to 'int' is ambiguous}}
// By the way, this isn't an lvalue: // By the way, this isn't an lvalue:
&(i1 ? i1 : i2); // expected-error {{cannot take the address of an rvalue}} &(i1 ? i1 : i2); // expected-error {{cannot take the address of an rvalue}}
▲ Show 20 Lines • Show All 235 Lines • Show Last 20 Lines

cfe/trunk/test/SemaCXX/err_typecheck_assign_const_filecheck.cpp

Show First 20 Lines • Show All 214 Lines • ▼ Show 20 Linesvoid test4(const A Ca) {
Ca.CSb.Sc.d.e.num = 5; Ca.CSb.Sc.d.e.num = 5;
Ca.getCB().Sc.d.e.num = 5; Ca.getCB().Sc.d.e.num = 5;
Ca.getSCB().Sc.d.e.num = 5; Ca.getSCB().Sc.d.e.num = 5;
// CHECK-NOT: error: // CHECK-NOT: error:
// CHECK-NOT: note: // CHECK-NOT: note:
} }
// Only display notes for relavent cases. // Only display notes for relevant cases.
void test5(const A Ca) { void test5(const A Ca) {
Ca.Mb.c.d.Ce.num = 5; Ca.Mb.c.d.Ce.num = 5;
// CHECK-NOT: error: // CHECK-NOT: error:
// CHECK: error:{{.*}} 'Ce' // CHECK: error:{{.*}} 'Ce'
// CHECK-NOT: note: // CHECK-NOT: note:
// CHECK: note:{{.*}} 'Ce' // CHECK: note:{{.*}} 'Ce'
// CHECK-NOT: note: // CHECK-NOT: note:
Show All 21 Lines

cfe/trunk/test/SemaCXX/type-traits.cpp

Show First 20 Lines • Show All 2,529 Lines • ▼ Show 20 Lines
static_assert(has_unique_object_representations<InheritsFromNoPadding>::value, "types without padding are"); static_assert(has_unique_object_representations<InheritsFromNoPadding>::value, "types without padding are");
struct VirtuallyInheritsFromNoPadding : virtual NoPadding { struct VirtuallyInheritsFromNoPadding : virtual NoPadding {
int c; int c;
int d; int d;
}; };
static_assert(!has_unique_object_representations<VirtuallyInheritsFromNoPadding>::value, "No virtual inheritence"); static_assert(!has_unique_object_representations<VirtuallyInheritsFromNoPadding>::value, "No virtual inheritance");
struct Padding { struct Padding {
char a; char a;
int b; int b;
}; };
//static_assert(!has_unique_object_representations<Padding>::value, "but not with padding"); //static_assert(!has_unique_object_representations<Padding>::value, "but not with padding");
▲ Show 20 Lines • Show All 221 Lines • Show Last 20 Lines

cfe/trunk/test/SemaCXX/uninitialized.cpp

Show All 20 Lines
// Test self-references within initializers which are guaranteed to be // Test self-references within initializers which are guaranteed to be
// uninitialized. // uninitialized.
int a = a; // no-warning: used to signal intended lack of initialization. int a = a; // no-warning: used to signal intended lack of initialization.
int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}} int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
int c = (c + c); // expected-warning 2 {{variable 'c' is uninitialized when used within its own initialization}} int c = (c + c); // expected-warning 2 {{variable 'c' is uninitialized when used within its own initialization}}
int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}} int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}} int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
// Thes don't warn as they don't require the value. // These don't warn as they don't require the value.
int g = sizeof(g); int g = sizeof(g);
void* ptr = &ptr; void* ptr = &ptr;
int h = bar(&h); int h = bar(&h);
int i = boo(i); int i = boo(i);
int j = far(j); int j = far(j);
int k = __alignof__(k); int k = __alignof__(k);
int l = k ? l : l; // expected-warning 2{{variable 'l' is uninitialized when used within its own initialization}} int l = k ? l : l; // expected-warning 2{{variable 'l' is uninitialized when used within its own initialization}}
Show All 17 Lines
void test_stuff () { void test_stuff () {
int a = a; // no-warning: used to signal intended lack of initialization. int a = a; // no-warning: used to signal intended lack of initialization.
int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}} int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
int c = (c + c); // expected-warning {{variable 'c' is uninitialized when used within its own initialization}} int c = (c + c); // expected-warning {{variable 'c' is uninitialized when used within its own initialization}}
int d = ({ d + d ;}); // expected-warning {{variable 'd' is uninitialized when used within its own initialization}} int d = ({ d + d ;}); // expected-warning {{variable 'd' is uninitialized when used within its own initialization}}
int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}} int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}} int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
// Thes don't warn as they don't require the value. // These don't warn as they don't require the value.
int g = sizeof(g); int g = sizeof(g);
void* ptr = &ptr; void* ptr = &ptr;
int h = bar(&h); int h = bar(&h);
int i = boo(i); int i = boo(i);
int j = far(j); int j = far(j);
int k = __alignof__(k); int k = __alignof__(k);
int l = k ? l : l; // expected-warning {{variable 'l' is uninitialized when used within its own initialization}} int l = k ? l : l; // expected-warning {{variable 'l' is uninitialized when used within its own initialization}}
Show All 17 Linesvoid test_stuff () {
for (;;) { for (;;) {
int a = a; // no-warning: used to signal intended lack of initialization. int a = a; // no-warning: used to signal intended lack of initialization.
int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}} int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
int c = (c + c); // expected-warning {{variable 'c' is uninitialized when used within its own initialization}} int c = (c + c); // expected-warning {{variable 'c' is uninitialized when used within its own initialization}}
int d = ({ d + d ;}); // expected-warning {{variable 'd' is uninitialized when used within its own initialization}} int d = ({ d + d ;}); // expected-warning {{variable 'd' is uninitialized when used within its own initialization}}
int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}} int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}} int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
// Thes don't warn as they don't require the value. // These don't warn as they don't require the value.
int g = sizeof(g); int g = sizeof(g);
void* ptr = &ptr; void* ptr = &ptr;
int h = bar(&h); int h = bar(&h);
int i = boo(i); int i = boo(i);
int j = far(j); int j = far(j);
int k = __alignof__(k); int k = __alignof__(k);
int l = k ? l : l; // expected-warning {{variable 'l' is uninitialized when used within its own initialization}} int l = k ? l : l; // expected-warning {{variable 'l' is uninitialized when used within its own initialization}}
▲ Show 20 Lines • Show All 593 Lines • ▼ Show 20 Lines
namespace statics { namespace statics {
static int a = a; // no-warning: used to signal intended lack of initialization. static int a = a; // no-warning: used to signal intended lack of initialization.
static int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}} static int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
static int c = (c + c); // expected-warning 2{{variable 'c' is uninitialized when used within its own initialization}} static int c = (c + c); // expected-warning 2{{variable 'c' is uninitialized when used within its own initialization}}
static int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}} static int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
static int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}} static int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
// Thes don't warn as they don't require the value. // These don't warn as they don't require the value.
static int g = sizeof(g); static int g = sizeof(g);
int gg = g; // Silence unneeded warning int gg = g; // Silence unneeded warning
static void* ptr = &ptr; static void* ptr = &ptr;
static int h = bar(&h); static int h = bar(&h);
static int i = boo(i); static int i = boo(i);
static int j = far(j); static int j = far(j);
static int k = __alignof__(k); static int k = __alignof__(k);
Show All 19 Linesnamespace statics {
void test() { void test() {
static int a = a; // no-warning: used to signal intended lack of initialization. static int a = a; // no-warning: used to signal intended lack of initialization.
static int b = b + 1; // expected-warning {{static variable 'b' is suspiciously used within its own initialization}} static int b = b + 1; // expected-warning {{static variable 'b' is suspiciously used within its own initialization}}
static int c = (c + c); // expected-warning 2{{static variable 'c' is suspiciously used within its own initialization}} static int c = (c + c); // expected-warning 2{{static variable 'c' is suspiciously used within its own initialization}}
static int d = ({ d + d ;}); // expected-warning 2{{static variable 'd' is suspiciously used within its own initialization}} static int d = ({ d + d ;}); // expected-warning 2{{static variable 'd' is suspiciously used within its own initialization}}
static int e = static_cast<long>(e) + 1; // expected-warning {{static variable 'e' is suspiciously used within its own initialization}} static int e = static_cast<long>(e) + 1; // expected-warning {{static variable 'e' is suspiciously used within its own initialization}}
static int f = foo(f); // expected-warning {{static variable 'f' is suspiciously used within its own initialization}} static int f = foo(f); // expected-warning {{static variable 'f' is suspiciously used within its own initialization}}
// Thes don't warn as they don't require the value. // These don't warn as they don't require the value.
static int g = sizeof(g); static int g = sizeof(g);
static void* ptr = &ptr; static void* ptr = &ptr;
static int h = bar(&h); static int h = bar(&h);
static int i = boo(i); static int i = boo(i);
static int j = far(j); static int j = far(j);
static int k = __alignof__(k); static int k = __alignof__(k);
static int l = k ? l : l; // expected-warning 2{{static variable 'l' is suspiciously used within its own initialization}} static int l = k ? l : l; // expected-warning 2{{static variable 'l' is suspiciously used within its own initialization}}
Show All 17 Lines void test() {
for (;;) { for (;;) {
static int a = a; // no-warning: used to signal intended lack of initialization. static int a = a; // no-warning: used to signal intended lack of initialization.
static int b = b + 1; // expected-warning {{static variable 'b' is suspiciously used within its own initialization}} static int b = b + 1; // expected-warning {{static variable 'b' is suspiciously used within its own initialization}}
static int c = (c + c); // expected-warning 2{{static variable 'c' is suspiciously used within its own initialization}} static int c = (c + c); // expected-warning 2{{static variable 'c' is suspiciously used within its own initialization}}
static int d = ({ d + d ;}); // expected-warning 2{{static variable 'd' is suspiciously used within its own initialization}} static int d = ({ d + d ;}); // expected-warning 2{{static variable 'd' is suspiciously used within its own initialization}}
static int e = static_cast<long>(e) + 1; // expected-warning {{static variable 'e' is suspiciously used within its own initialization}} static int e = static_cast<long>(e) + 1; // expected-warning {{static variable 'e' is suspiciously used within its own initialization}}
static int f = foo(f); // expected-warning {{static variable 'f' is suspiciously used within its own initialization}} static int f = foo(f); // expected-warning {{static variable 'f' is suspiciously used within its own initialization}}
// Thes don't warn as they don't require the value. // These don't warn as they don't require the value.
static int g = sizeof(g); static int g = sizeof(g);
static void* ptr = &ptr; static void* ptr = &ptr;
static int h = bar(&h); static int h = bar(&h);
static int i = boo(i); static int i = boo(i);
static int j = far(j); static int j = far(j);
static int k = __alignof__(k); static int k = __alignof__(k);
static int l = k ? l : l; // expected-warning 2{{static variable 'l' is suspiciously used within its own initialization}} static int l = k ? l : l; // expected-warning 2{{static variable 'l' is suspiciously used within its own initialization}}
▲ Show 20 Lines • Show All 664 Lines • Show Last 20 Lines

cfe/trunk/test/SemaCXX/vector.cpp

Show First 20 Lines • Show All 184 Lines • ▼ Show 20 Linesvoid test_implicit_conversions(bool Cond, char16 c16, longlong16 ll16,
(void)(rto_c16 += to_c16e); (void)(rto_c16 += to_c16e);
(void)(rto_c16 -= to_c16e); (void)(rto_c16 -= to_c16e);
(void)(rto_c16 *= to_c16e); (void)(rto_c16 *= to_c16e);
(void)(rto_c16 /= to_c16e); (void)(rto_c16 /= to_c16e);
(void)(Cond? to_c16 : to_c16e); (void)(Cond? to_c16 : to_c16e);
(void)(Cond? to_ll16e : to_ll16); (void)(Cond? to_ll16e : to_ll16);
// These 2 are convertable with -flax-vector-conversions (default) // These 2 are convertible with -flax-vector-conversions (default)
(void)(Cond? to_c16 : to_ll16); (void)(Cond? to_c16 : to_ll16);
(void)(Cond? to_c16e : to_ll16e); (void)(Cond? to_c16e : to_ll16e);
} }
typedef float fltx2 __attribute__((__vector_size__(8))); typedef float fltx2 __attribute__((__vector_size__(8)));
typedef float fltx4 __attribute__((__vector_size__(16))); typedef float fltx4 __attribute__((__vector_size__(16)));
typedef double dblx2 __attribute__((__vector_size__(16))); typedef double dblx2 __attribute__((__vector_size__(16)));
typedef double dblx4 __attribute__((__vector_size__(32))); typedef double dblx4 __attribute__((__vector_size__(32)));
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

cfe/trunk/test/SemaCXX/warn-thread-safety-analysis.cpp

Show First 20 Lines • Show All 1,042 Lines • ▼ Show 20 Linesvoid main() {
Bar bar; Bar bar;
bar.Test1(); bar.Test1();
} }
} // end namespace thread_annot_lock_49 } // end namespace thread_annot_lock_49
namespace thread_annot_lock_61_modified { namespace thread_annot_lock_61_modified {
// Modified to fix the compiler errors // Modified to fix the compiler errors
// Test the fix for a bug introduced by the support of pass-by-reference // Test the fix for a bug introduced by the support of pass-by-reference
// paramters. // parameters.
struct Foo { Foo &operator<< (bool) {return *this;} }; struct Foo { Foo &operator<< (bool) {return *this;} };
Foo &getFoo(); Foo &getFoo();
struct Bar { Foo &func () {return getFoo();} }; struct Bar { Foo &func () {return getFoo();} };
struct Bas { void operator& (Foo &) {} }; struct Bas { void operator& (Foo &) {} };
void mumble() void mumble()
{ {
Bas() & Bar().func() << "" << ""; Bas() & Bar().func() << "" << "";
Bas() & Bar().func() << ""; Bas() & Bar().func() << "";
▲ Show 20 Lines • Show All 739 Lines • ▼ Show 20 Lines void foo9() {
} }
} }
// Test use-def chains: back edges // Test use-def chains: back edges
void foo10() { void foo10() {
bool b = mu.TryLock(); bool b = mu.TryLock();
while (cond) { while (cond) {
if (b) { // b should be uknown at this point b/c of the loop if (b) { // b should be unknown at this point b/c of the loop
a = 10; // expected-warning {{writing variable 'a' requires holding mutex 'mu' exclusively}} a = 10; // expected-warning {{writing variable 'a' requires holding mutex 'mu' exclusively}}
} }
b = !b; b = !b;
} }
} }
// Test merge of exclusive trylock // Test merge of exclusive trylock
void foo11() { void foo11() {
▲ Show 20 Lines • Show All 3,461 Lines • Show Last 20 Lines

cfe/trunk/test/SemaCXX/warn-unreachable.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Linesstruct TestUnreachableB {
static void foo(); static void foo();
}; };
void test_unreachable_templates_harness() { void test_unreachable_templates_harness() {
test_unreachable_templates<TestUnreachableA>(); test_unreachable_templates<TestUnreachableA>();
test_unreachable_templates<TestUnreachableB>(); test_unreachable_templates<TestUnreachableB>();
} }
// Do warn about explict template specializations, as they represent // Do warn about explicit template specializations, as they represent
// actual concrete functions that somebody wrote. // actual concrete functions that somebody wrote.
template <typename T> void funcToSpecialize() {} template <typename T> void funcToSpecialize() {}
template <> void funcToSpecialize<int>() { template <> void funcToSpecialize<int>() {
halt(); halt();
dead(); // expected-warning {{will never be executed}} dead(); // expected-warning {{will never be executed}}
} }
▲ Show 20 Lines • Show All 300 Lines • Show Last 20 Lines

cfe/trunk/test/SemaObjC/arc-peformselector.m

Show All 30 Lines- (id) Meth {
return [self performSelector : @selector(init)]; return [self performSelector : @selector(init)];
return [self performSelector : sel1]; // expected-warning {{performSelector may cause a leak because its selector is unknown}} \ return [self performSelector : sel1]; // expected-warning {{performSelector may cause a leak because its selector is unknown}} \
// expected-note {{used here}} // expected-note {{used here}}
return [self performSelector: (@selector(PlusZero))]; return [self performSelector: (@selector(PlusZero))];
return [self performSelector : @selector(PlusZero)]; return [self performSelector : @selector(PlusZero)];
return [self performSelector : @selector(PlusOne)]; // expected-error {{performSelector names a selector which retains the object}} return [self performSelector : @selector(PlusOne)]; // expected-error {{performSelector names a selector which retains the object}}
// Avoid the unkown selector warning for more complicated performSelector // Avoid the unknown selector warning for more complicated performSelector
// variations because it produces too many false positives. // variations because it produces too many false positives.
[self performSelector: sel1 withObject:0 afterDelay:0 inModes:0]; [self performSelector: sel1 withObject:0 afterDelay:0 inModes:0];
return [self performSelector: @selector(self)]; // No error, -self is not +1! return [self performSelector: @selector(self)]; // No error, -self is not +1!
} }
- (id)performSelector:(SEL)aSelector { return 0; } - (id)performSelector:(SEL)aSelector { return 0; }
- (id)performSelector:(SEL)aSelector withObject:(id)object { return 0; } - (id)performSelector:(SEL)aSelector withObject:(id)object { return 0; }
- (id)performSelector:(SEL)aSelector withObject:(id)object1 withObject:(id)object2 { return 0; } - (id)performSelector:(SEL)aSelector withObject:(id)object1 withObject:(id)object2 { return 0; }
- (void)performSelector:(SEL)aSelector withObject:(id)anArgument afterDelay:(double)delay inModes:(I *)modes { } - (void)performSelector:(SEL)aSelector withObject:(id)anArgument afterDelay:(double)delay inModes:(I *)modes { }
@end @end

cfe/trunk/test/SemaObjC/compare-qualified-class.m

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
@property (nonatomic, copy) ClassB<ProtocolX> *aProperty; @property (nonatomic, copy) ClassB<ProtocolX> *aProperty;
- (ClassA<ProtocolY> *)aMethod; - (ClassA<ProtocolY> *)aMethod;
- (ClassA<ProtocolY> *)anotherMethod; - (ClassA<ProtocolY> *)anotherMethod;
@end @end
@implementation OtherClass @implementation OtherClass
- (ClassA<ProtocolY> *)aMethod { - (ClassA<ProtocolY> *)aMethod {
// This does not work, even though ClassB subclasses from A and conforms to Y // This does not work, even though ClassB subclasses from A and conforms to Y
// because the property type explicity adds ProtocolX conformance // because the property type explicitly adds ProtocolX conformance
// even though ClassB already conforms to ProtocolX // even though ClassB already conforms to ProtocolX
return self.aProperty; return self.aProperty;
} }
- (ClassA<ProtocolY> *)anotherMethod { - (ClassA<ProtocolY> *)anotherMethod {
// This works, even though all it is doing is removing an explicit // This works, even though all it is doing is removing an explicit
// protocol conformance that ClassB already conforms to // protocol conformance that ClassB already conforms to
return (ClassB *)self.aProperty; return (ClassB *)self.aProperty;
} }
@end @end

cfe/trunk/test/SemaObjC/property-ivar-mismatch.m

// RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s // RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
// Test that arithmatic types on property and its ivar have exact match. // Test that arithmetic types on property and its ivar have exact match.
@interface Test4 @interface Test4
{ {
char ivar; // expected-note{{instance variable is declared here}} char ivar; // expected-note{{instance variable is declared here}}
} }
@property int prop; @property int prop;
@end @end
Show All 16 Lines

cfe/trunk/tools/c-index-test/c-index-test.c

Show First 20 Lines • Show All 656 Lines • ▼ Show 20 Lines#ifdef CLANG_HAVE_LIBXML
} }
ValidationCtxt = xmlRelaxNGNewValidCtxt(Schema); ValidationCtxt = xmlRelaxNGNewValidCtxt(Schema);
status = xmlRelaxNGValidateDoc(ValidationCtxt, Doc); status = xmlRelaxNGValidateDoc(ValidationCtxt, Doc);
if (!status) if (!status)
printf(" CommentXMLValid"); printf(" CommentXMLValid");
else if (status > 0) { else if (status > 0) {
xmlErrorPtr Error = xmlGetLastError(); xmlErrorPtr Error = xmlGetLastError();
printf(" CommentXMLInvalid [not vaild XML: %s]", Error->message); printf(" CommentXMLInvalid [not valid XML: %s]", Error->message);
} else } else
printf(" libXMLError"); printf(" libXMLError");
xmlRelaxNGFreeValidCtxt(ValidationCtxt); xmlRelaxNGFreeValidCtxt(ValidationCtxt);
xmlFreeDoc(Doc); xmlFreeDoc(Doc);
xmlRelaxNGFree(Schema); xmlRelaxNGFree(Schema);
xmlRelaxNGFreeParserCtxt(RNGParser); xmlRelaxNGFreeParserCtxt(RNGParser);
#endif #endif
▲ Show 20 Lines • Show All 4,092 Lines • Show Last 20 Lines

cfe/trunk/tools/clang-format/clang-format.el

Show First 20 Lines • Show All 147 Lines • ▼ Show 20 Lines (let ((file-start (clang-format--bufferpos-to-filepos start 'approximate
;; otherwise the offsets calculated above are off. For simplicity, we ;; otherwise the offsets calculated above are off. For simplicity, we
;; always use ‘utf-8-unix’ and ignore the buffer coding system. ;; always use ‘utf-8-unix’ and ignore the buffer coding system.
(default-process-coding-system '(utf-8-unix . utf-8-unix))) (default-process-coding-system '(utf-8-unix . utf-8-unix)))
(unwind-protect (unwind-protect
(let ((status (apply #'call-process-region (let ((status (apply #'call-process-region
nil nil clang-format-executable nil nil clang-format-executable
nil `(,temp-buffer ,temp-file) nil nil `(,temp-buffer ,temp-file) nil
`("-output-replacements-xml" `("-output-replacements-xml"
;; Gaurd against a nil assume-file-name. ;; Guard against a nil assume-file-name.
;; If the clang-format option -assume-filename ;; If the clang-format option -assume-filename
;; is given a blank string it will crash as per ;; is given a blank string it will crash as per
;; the following bug report ;; the following bug report
;; https://bugs.llvm.org/show_bug.cgi?id=34667 ;; https://bugs.llvm.org/show_bug.cgi?id=34667
,@(and assume-file-name ,@(and assume-file-name
(list "-assume-filename" assume-file-name)) (list "-assume-filename" assume-file-name))
"-style" ,style "-style" ,style
"-offset" ,(number-to-string file-start) "-offset" ,(number-to-string file-start)
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

cfe/trunk/tools/libclang/CIndex.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,587 Lines • ▼ Show 20 Linesvoid EnqueueVisitor::VisitMemberExpr(const MemberExpr *M) {
// If the base of the member access expression is an implicit 'this', don't // If the base of the member access expression is an implicit 'this', don't
// visit it. // visit it.
// FIXME: If we ever want to show these implicit accesses, this will be // FIXME: If we ever want to show these implicit accesses, this will be
// unfortunate. However, clang_getCursor() relies on this behavior. // unfortunate. However, clang_getCursor() relies on this behavior.
if (M->isImplicitAccess()) if (M->isImplicitAccess())
return; return;
// Ignore base anonymous struct/union fields, otherwise they will shadow the // Ignore base anonymous struct/union fields, otherwise they will shadow the
// real field that that we are interested in. // real field that we are interested in.
if (auto *SubME = dyn_cast<MemberExpr>(M->getBase())) { if (auto *SubME = dyn_cast<MemberExpr>(M->getBase())) {
if (auto *FD = dyn_cast_or_null<FieldDecl>(SubME->getMemberDecl())) { if (auto *FD = dyn_cast_or_null<FieldDecl>(SubME->getMemberDecl())) {
if (FD->isAnonymousStructOrUnion()) { if (FD->isAnonymousStructOrUnion()) {
AddStmt(SubME->getBase()); AddStmt(SubME->getBase());
return; return;
} }
} }
} }
▲ Show 20 Lines • Show All 5,085 Lines • ▼ Show 20 Lines case VarDecl::TLS_Static:
return CXTLS_Static; return CXTLS_Static;
} }
} }
return CXTLS_None; return CXTLS_None;
} }
/// \brief If the given cursor is the "templated" declaration /// \brief If the given cursor is the "templated" declaration
/// descibing a class or function template, return the class or /// describing a class or function template, return the class or
/// function template. /// function template.
static const Decl *maybeGetTemplateCursor(const Decl *D) { static const Decl *maybeGetTemplateCursor(const Decl *D) {
if (!D) if (!D)
return nullptr; return nullptr;
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
if (FunctionTemplateDecl *FunTmpl = FD->getDescribedFunctionTemplate()) if (FunctionTemplateDecl *FunTmpl = FD->getDescribedFunctionTemplate())
return FunTmpl; return FunTmpl;
▲ Show 20 Lines • Show All 978 Lines • Show Last 20 Lines

cfe/trunk/tools/libclang/CXCursor.h

Show First 20 Lines • Show All 245 Lines • ▼ Show 20 Lines
ASTContext &getCursorContext(CXCursor Cursor); ASTContext &getCursorContext(CXCursor Cursor);
ASTUnit *getCursorASTUnit(CXCursor Cursor); ASTUnit *getCursorASTUnit(CXCursor Cursor);
CXTranslationUnit getCursorTU(CXCursor Cursor); CXTranslationUnit getCursorTU(CXCursor Cursor);
void getOverriddenCursors(CXCursor cursor, void getOverriddenCursors(CXCursor cursor,
SmallVectorImpl<CXCursor> &overridden); SmallVectorImpl<CXCursor> &overridden);
/// \brief Create an opaque pool used for fast generation of overriden /// \brief Create an opaque pool used for fast generation of overridden
/// CXCursor arrays. /// CXCursor arrays.
void *createOverridenCXCursorsPool(); void *createOverridenCXCursorsPool();
/// \brief Dispose of the overriden CXCursors pool. /// \brief Dispose of the overridden CXCursors pool.
void disposeOverridenCXCursorsPool(void *pool); void disposeOverridenCXCursorsPool(void *pool);
/// \brief Returns a index/location pair for a selector identifier if the cursor /// \brief Returns a index/location pair for a selector identifier if the cursor
/// points to one. /// points to one.
std::pair<int, SourceLocation> getSelectorIdentifierIndexAndLoc(CXCursor); std::pair<int, SourceLocation> getSelectorIdentifierIndexAndLoc(CXCursor);
static inline int getSelectorIdentifierIndex(CXCursor cursor) { static inline int getSelectorIdentifierIndex(CXCursor cursor) {
return getSelectorIdentifierIndexAndLoc(cursor).first; return getSelectorIdentifierIndexAndLoc(cursor).first;
} }
Show All 33 Lines

cfe/trunk/tools/libclang/CXCursor.cpp

Show First 20 Lines • Show All 1,463 Lines • ▼ Show 20 Linesvoid clang_getOverriddenCursors(CXCursor cursor,
// Use the first entry to contain a back reference to the vector. // Use the first entry to contain a back reference to the vector.
// This is a complete hack. // This is a complete hack.
CXCursor backRefCursor = MakeCXCursorInvalid(CXCursor_InvalidFile, TU); CXCursor backRefCursor = MakeCXCursorInvalid(CXCursor_InvalidFile, TU);
backRefCursor.data[0] = Vec; backRefCursor.data[0] = Vec;
assert(cxcursor::getCursorTU(backRefCursor) == TU); assert(cxcursor::getCursorTU(backRefCursor) == TU);
Vec->push_back(backRefCursor); Vec->push_back(backRefCursor);
// Get the overriden cursors. // Get the overridden cursors.
cxcursor::getOverriddenCursors(cursor, *Vec); cxcursor::getOverriddenCursors(cursor, *Vec);
// Did we get any overriden cursors? If not, return Vec to the pool // Did we get any overridden cursors? If not, return Vec to the pool
// of available cursor vectors. // of available cursor vectors.
if (Vec->size() == 1) { if (Vec->size() == 1) {
pool.AvailableCursors.push_back(Vec); pool.AvailableCursors.push_back(Vec);
return; return;
} }
// Now tell the caller about the overriden cursors. // Now tell the caller about the overridden cursors.
assert(Vec->size() > 1); assert(Vec->size() > 1);
*overridden = &((*Vec)[1]); *overridden = &((*Vec)[1]);
*num_overridden = Vec->size() - 1; *num_overridden = Vec->size() - 1;
} }
void clang_disposeOverriddenCursors(CXCursor *overridden) { void clang_disposeOverriddenCursors(CXCursor *overridden) {
if (!overridden) if (!overridden)
return; return;
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

cfe/trunk/tools/scan-build-py/README.md

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Lines
The major difference is how and when the analyzer is run. The `scan-build` The major difference is how and when the analyzer is run. The `scan-build`
tool has three distinct model to run the analyzer: tool has three distinct model to run the analyzer:
1. Use compiler wrappers to make actions. 1. Use compiler wrappers to make actions.
The compiler wrappers does run the real compiler and the analyzer. The compiler wrappers does run the real compiler and the analyzer.
This is the default behaviour, can be enforced with `--override-compiler` This is the default behaviour, can be enforced with `--override-compiler`
flag. flag.
2. Use special library to intercept compiler calls durring the build process. 2. Use special library to intercept compiler calls during the build process.
The analyzer run against each modules after the build finished. The analyzer run against each modules after the build finished.
Use `--intercept-first` flag to get this model. Use `--intercept-first` flag to get this model.
3. Use compiler wrappers to intercept compiler calls durring the build process. 3. Use compiler wrappers to intercept compiler calls during the build process.
The analyzer run against each modules after the build finished. The analyzer run against each modules after the build finished.
Use `--intercept-first` and `--override-compiler` flags together to get Use `--intercept-first` and `--override-compiler` flags together to get
this model. this model.
The 1. and 3. are using compiler wrappers, which works only if the build The 1. and 3. are using compiler wrappers, which works only if the build
process respects the `CC` and `CXX` environment variables. (Some build process respects the `CC` and `CXX` environment variables. (Some build
process can override these variable as command line parameter only. This case process can override these variable as command line parameter only. This case
you need to pass the compiler wrappers manually. eg.: `intercept-build you need to pass the compiler wrappers manually. eg.: `intercept-build
--override-compiler make CC=intercept-cc CXX=intercept-c++ all` where the --override-compiler make CC=intercept-cc CXX=intercept-c++ all` where the
original build command would have been `make all` only.) original build command would have been `make all` only.)
The 1. runs the analyzer right after the real compilation. So, if the build The 1. runs the analyzer right after the real compilation. So, if the build
process removes removes intermediate modules (generated sources) the analyzer process removes removes intermediate modules (generated sources) the analyzer
output still kept. output still kept.
The 2. and 3. generate the compilation database first, and filters out those The 2. and 3. generate the compilation database first, and filters out those
modules which are not exists. So, it's suitable for incremental analysis durring modules which are not exists. So, it's suitable for incremental analysis during
the development. the development.
The 2. mode is available only on FreeBSD and Linux. Where library preload The 2. mode is available only on FreeBSD and Linux. Where library preload
is available from the dynamic loader. Not supported on OS X (unless System is available from the dynamic loader. Not supported on OS X (unless System
Integrity Protection feature is turned off). Integrity Protection feature is turned off).
`intercept-build` command uses only the 2. and 3. mode to generate the `intercept-build` command uses only the 2. and 3. mode to generate the
compilation database. `analyze-build` does only run the analyzer against the compilation database. `analyze-build` does only run the analyzer against the
Show All 30 Lines

cfe/trunk/tools/scan-build-py/libscanbuild/analyze.py

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Lines
def need_analyzer(args): def need_analyzer(args):
""" Check the intent of the build command. """ Check the intent of the build command.
When static analyzer run against project configure step, it should be When static analyzer run against project configure step, it should be
silent and no need to run the analyzer or generate report. silent and no need to run the analyzer or generate report.
To run `scan-build` against the configure step might be neccessary, To run `scan-build` against the configure step might be necessary,
when compiler wrappers are used. That's the moment when build setup when compiler wrappers are used. That's the moment when build setup
check the compiler and capture the location for the build process. """ check the compiler and capture the location for the build process. """
return len(args) and not re.search('configure|autogen', args[0]) return len(args) and not re.search('configure|autogen', args[0])
def prefix_with(constant, pieces): def prefix_with(constant, pieces):
""" From a sequence create another sequence where every second element """ From a sequence create another sequence where every second element
▲ Show 20 Lines • Show All 326 Lines • ▼ Show 20 Lines@require(['command', # entry from compilation database
'output_format', # it's 'plist', 'html', both or plist-multi-file 'output_format', # it's 'plist', 'html', both or plist-multi-file
'output_failures', # generate crash reports or not 'output_failures', # generate crash reports or not
'ctu']) # ctu control options 'ctu']) # ctu control options
def run(opts): def run(opts):
""" Entry point to run (or not) static analyzer against a single entry """ Entry point to run (or not) static analyzer against a single entry
of the compilation database. of the compilation database.
This complex task is decomposed into smaller methods which are calling This complex task is decomposed into smaller methods which are calling
each other in chain. If the analyzis is not possibe the given method each other in chain. If the analyzis is not possible the given method
just return and break the chain. just return and break the chain.
The passed parameter is a python dictionary. Each method first check The passed parameter is a python dictionary. Each method first check
that the needed parameters received. (This is done by the 'require' that the needed parameters received. (This is done by the 'require'
decorator. It's like an 'assert' to check the contract between the decorator. It's like an 'assert' to check the contract between the
caller and the called method.) """ caller and the called method.) """
try: try:
▲ Show 20 Lines • Show All 333 Lines • Show Last 20 Lines

cfe/trunk/tools/scan-build-py/libscanbuild/arguments.py

Show First 20 Lines • Show All 275 Lines • ▼ Show 20 Lines advanced.add_argument(
'--internal-stats', '--internal-stats',
action='store_true', action='store_true',
help="""Generate internal analyzer statistics.""") help="""Generate internal analyzer statistics.""")
advanced.add_argument( advanced.add_argument(
'--maxloop', '--maxloop',
'-maxloop', '-maxloop',
metavar='<loop count>', metavar='<loop count>',
type=int, type=int,
help="""Specifiy the number of times a block can be visited before help="""Specify the number of times a block can be visited before
giving up. Increase for more comprehensive coverage at a cost of giving up. Increase for more comprehensive coverage at a cost of
speed.""") speed.""")
advanced.add_argument( advanced.add_argument(
'--store', '--store',
'-store', '-store',
metavar='<model>', metavar='<model>',
dest='store_model', dest='store_model',
choices=['region', 'basic'], choices=['region', 'basic'],
▲ Show 20 Lines • Show All 209 Lines • Show Last 20 Lines

cfe/trunk/tools/scan-build/bin/scan-build

Show First 20 Lines • Show All 1,007 Lines • ▼ Show 20 Lines if (/^Xcode (.+)$/) {
$oldBehavior = 0; $oldBehavior = 0;
last; last;
} }
} }
} }
} }
close(DETECT_XCODE); close(DETECT_XCODE);
# If --override-compiler is explicitely requested, resort to the old # If --override-compiler is explicitly requested, resort to the old
# behavior regardless of Xcode version. # behavior regardless of Xcode version.
if ($Options{OverrideCompiler}) { if ($Options{OverrideCompiler}) {
$oldBehavior = 1; $oldBehavior = 1;
} }
if ($oldBehavior == 0) { if ($oldBehavior == 0) {
my $OutputDir = $EnvVars->{"OUTPUT_DIR"}; my $OutputDir = $EnvVars->{"OUTPUT_DIR"};
my $CLANG = $EnvVars->{"CLANG"}; my $CLANG = $EnvVars->{"CLANG"};
▲ Show 20 Lines • Show All 216 Lines • ▼ Show 20 Lines -no-failure-reports
and preprocessed source files. and preprocessed source files.
-stats -stats
Generates visitation statistics for the project being analyzed. Generates visitation statistics for the project being analyzed.
-maxloop <loop count> -maxloop <loop count>
Specifiy the number of times a block can be visited before giving up. Specify the number of times a block can be visited before giving up.
Default is 4. Increase for more comprehensive coverage at a cost of speed. Default is 4. Increase for more comprehensive coverage at a cost of speed.
-internal-stats -internal-stats
Generate internal analyzer statistics. Generate internal analyzer statistics.
--use-analyzer [Xcode|path to clang] --use-analyzer [Xcode|path to clang]
--use-analyzer=[Xcode|path to clang] --use-analyzer=[Xcode|path to clang]
▲ Show 20 Lines • Show All 629 Lines • Show Last 20 Lines

cfe/trunk/tools/scan-build/man/scan-build.1

Show First 20 Lines • Show All 110 Lines • ▼ Show 20 Lines
.It Fl constraints Op Ar model .It Fl constraints Op Ar model
Specify the contraint engine used by the analyzer. By default the Specify the contraint engine used by the analyzer. By default the
.Ql range .Ql range
model is used. Specifying model is used. Specifying
.Ql basic .Ql basic
uses a simpler, less powerful constraint model used by checker-0.160 uses a simpler, less powerful constraint model used by checker-0.160
and earlier. and earlier.
.It Fl maxloop Ar N .It Fl maxloop Ar N
Specifiy the number of times a block can be visited before giving Specify the number of times a block can be visited before giving
up. Default is 4. Increase for more comprehensive coverage at a up. Default is 4. Increase for more comprehensive coverage at a
cost of speed. cost of speed.
.It Fl no-failure-reports .It Fl no-failure-reports
Do not create a Do not create a
.Ql failures .Ql failures
subdirectory that includes analyzer crash reports and preprocessed subdirectory that includes analyzer crash reports and preprocessed
source files. source files.
.It Fl stats .It Fl stats
▲ Show 20 Lines • Show All 222 Lines • Show Last 20 Lines

cfe/trunk/tools/scan-view/share/startfile.py

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines def _invoke(self, cmdline):
if not setsid: if not setsid:
setsid = getattr(os, 'setpgrp', None) setsid = getattr(os, 'setpgrp', None)
pipe = subprocess.Popen(cmdline, stdin=inout, stdout=inout, pipe = subprocess.Popen(cmdline, stdin=inout, stdout=inout,
stderr=inout, close_fds=closefds, stderr=inout, close_fds=closefds,
preexec_fn=setsid, startupinfo=startupinfo) preexec_fn=setsid, startupinfo=startupinfo)
# It is assumed that this kind of tools (gnome-open, kfmclient, # It is assumed that this kind of tools (gnome-open, kfmclient,
# exo-open, xdg-open and open for OSX) immediately exit after lauching # exo-open, xdg-open and open for OSX) immediately exit after launching
# the specific application # the specific application
returncode = pipe.wait() returncode = pipe.wait()
if hasattr(self, 'fixreturncode'): if hasattr(self, 'fixreturncode'):
returncode = self.fixreturncode(returncode) returncode = self.fixreturncode(returncode)
return not returncode return not returncode
def open(self, filename): def open(self, filename):
if isinstance(filename, basestring): if isinstance(filename, basestring):
cmdline = self.args + [filename] cmdline = self.args + [filename]
else: else:
# assume it is a sequence # assume it is a sequence
cmdline = self.args + filename cmdline = self.args + filename
try: try:
return self._invoke(cmdline) return self._invoke(cmdline)
except OSError: except OSError:
return False return False
# Platform support for Windows # Platform support for Windows
if sys.platform[:3] == 'win': if sys.platform[:3] == 'win':
class Start(BaseController): class Start(BaseController):
'''Controller for the win32 start progam through os.startfile.''' '''Controller for the win32 start program through os.startfile.'''
def open(self, filename): def open(self, filename):
try: try:
os.startfile(filename) os.startfile(filename)
except WindowsError: except WindowsError:
# [Error 22] No application is associated with the specified # [Error 22] No application is associated with the specified
# file for this operation: '<URL>' # file for this operation: '<URL>'
return False return False
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lineselse:
if os.environ.get("DISPLAY"): if os.environ.get("DISPLAY"):
register_X_controllers() register_X_controllers()
_open = get() _open = get()
def open(filename): def open(filename):
'''Open a file or an URL in the registered default application.''' '''Open a file or a URL in the registered default application.'''
return _open(filename) return _open(filename)

cfe/trunk/utils/TableGen/NeonEmitter.cpp

Show First 20 Lines • Show All 298 Lines • ▼ Show 20 Linesclass Intrinsic {
/// signedness (i32), while some (ClassB) have no type at all, only a width /// signedness (i32), while some (ClassB) have no type at all, only a width
/// (32). /// (32).
ClassKind CK; ClassKind CK;
/// The list of DAGs for the body. May be empty, in which case we should /// The list of DAGs for the body. May be empty, in which case we should
/// emit a builtin call. /// emit a builtin call.
ListInit *Body; ListInit *Body;
/// The architectural #ifdef guard. /// The architectural #ifdef guard.
std::string Guard; std::string Guard;
/// Set if the Unvailable bit is 1. This means we don't generate a body, /// Set if the Unavailable bit is 1. This means we don't generate a body,
/// just an "unavailable" attribute on a declaration. /// just an "unavailable" attribute on a declaration.
bool IsUnavailable; bool IsUnavailable;
/// Is this intrinsic safe for big-endian? or does it need its arguments /// Is this intrinsic safe for big-endian? or does it need its arguments
/// reversing? /// reversing?
bool BigEndianSafe; bool BigEndianSafe;
/// The types of return value [0] and parameters [1..]. /// The types of return value [0] and parameters [1..].
std::vector<Type> Types; std::vector<Type> Types;
▲ Show 20 Lines • Show All 2,268 Lines • Show Last 20 Lines

cfe/trunk/utils/bash-autocomplete.sh

# Please add "source /path/to/bash-autocomplete.sh" to your .bashrc to use this. # Please add "source /path/to/bash-autocomplete.sh" to your .bashrc to use this.
_clang_filedir() _clang_filedir()
{ {
# _filedir function provided by recent versions of bash-completion package is # _filedir function provided by recent versions of bash-completion package is
# better than "compgen -f" because the former honors spaces in pathnames while # better than "compgen -f" because the former honors spaces in pathnames while
# the latter doesn't. So we use compgen only when _filedir is not provided. # the latter doesn't. So we use compgen only when _filedir is not provided.
_filedir 2> /dev/null || COMPREPLY=( $( compgen -f ) ) _filedir 2> /dev/null || COMPREPLY=( $( compgen -f ) )
} }
_clang() _clang()
{ {
local cur prev words cword arg flags w1 w2 local cur prev words cword arg flags w1 w2
# If latest bash-completion is not supported just initialize COMPREPLY and # If latest bash-completion is not supported just initialize COMPREPLY and
# initialize variables by setting manualy. # initialize variables by setting manually.
_init_completion -n 2> /dev/null _init_completion -n 2> /dev/null
if [[ "$?" != 0 ]]; then if [[ "$?" != 0 ]]; then
COMPREPLY=() COMPREPLY=()
cword=$COMP_CWORD cword=$COMP_CWORD
cur="${COMP_WORDS[$cword]}" cur="${COMP_WORDS[$cword]}"
fi fi
w1="${COMP_WORDS[$cword - 1]}" w1="${COMP_WORDS[$cword - 1]}"
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

cfe/trunk/utils/check_cfc/check_cfc.py

Show First 20 Lines • Show All 231 Lines • ▼ Show 20 Linesdef run_step(command, my_env, error_on_failure):
p = subprocess.Popen(command, stdout=subprocess.PIPE, p = subprocess.Popen(command, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, env=my_env, shell=is_windows()) stderr=subprocess.PIPE, env=my_env, shell=is_windows())
(stdout, stderr) = p.communicate() (stdout, stderr) = p.communicate()
if p.returncode != 0: if p.returncode != 0:
raise WrapperStepException(error_on_failure, stdout, stderr) raise WrapperStepException(error_on_failure, stdout, stderr)
def get_temp_file_name(suffix): def get_temp_file_name(suffix):
"""Get a temporary file name with a particular suffix. Let the caller be """Get a temporary file name with a particular suffix. Let the caller be
reponsible for deleting it.""" responsible for deleting it."""
tf = tempfile.NamedTemporaryFile(suffix=suffix, delete=False) tf = tempfile.NamedTemporaryFile(suffix=suffix, delete=False)
tf.close() tf.close()
return tf.name return tf.name
class WrapperCheck(object): class WrapperCheck(object):
"""Base class for a check. Subclass this to add a check.""" """Base class for a check. Subclass this to add a check."""
def __init__(self, output_file_a): def __init__(self, output_file_a):
"""Record the base output file that will be compared against.""" """Record the base output file that will be compared against."""
▲ Show 20 Lines • Show All 154 Lines • Show Last 20 Lines

cfe/trunk/utils/clangdiag.py

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Linesdef setDiagBreakpoint(frame, bp_loc, dict):
if id is None: if id is None:
print('clangdiag: id is None') print('clangdiag: id is None')
return False return False
# Don't need to test this time, since we did that in enable. # Don't need to test this time, since we did that in enable.
target = frame.GetThread().GetProcess().GetTarget() target = frame.GetThread().GetProcess().GetTarget()
diagtool = getDiagtool(target) diagtool = getDiagtool(target)
name = subprocess.check_output([diagtool, "find-diagnostic-id", id]).rstrip(); name = subprocess.check_output([diagtool, "find-diagnostic-id", id]).rstrip();
# Make sure we only consider errors, warnings, and extentions. # Make sure we only consider errors, warnings, and extensions.
# FIXME: Make this configurable? # FIXME: Make this configurable?
prefixes = ['err_', 'warn_', 'exp_'] prefixes = ['err_', 'warn_', 'exp_']
if len([prefix for prefix in prefixes+[''] if name.startswith(prefix)][0]): if len([prefix for prefix in prefixes+[''] if name.startswith(prefix)][0]):
bp = target.BreakpointCreateBySourceRegex(name, lldb.SBFileSpec()) bp = target.BreakpointCreateBySourceRegex(name, lldb.SBFileSpec())
bp.AddName("clang::Diagnostic") bp.AddName("clang::Diagnostic")
return False return False
def enable(exe_ctx, args): def enable(exe_ctx, args):
# Always disable existing breakpoints # Always disable existing breakpoints
disable(exe_ctx) disable(exe_ctx)
target = exe_ctx.GetTarget() target = exe_ctx.GetTarget()
numOfBreakpoints = target.GetNumBreakpoints() numOfBreakpoints = target.GetNumBreakpoints()
if args.id: if args.id:
# Make sure we only consider errors, warnings, and extentions. # Make sure we only consider errors, warnings, and extensions.
# FIXME: Make this configurable? # FIXME: Make this configurable?
prefixes = ['err_', 'warn_', 'exp_'] prefixes = ['err_', 'warn_', 'exp_']
if len([prefix for prefix in prefixes+[''] if args.id.startswith(prefix)][0]): if len([prefix for prefix in prefixes+[''] if args.id.startswith(prefix)][0]):
bp = target.BreakpointCreateBySourceRegex(args.id, lldb.SBFileSpec()) bp = target.BreakpointCreateBySourceRegex(args.id, lldb.SBFileSpec())
bp.AddName("clang::Diagnostic") bp.AddName("clang::Diagnostic")
else: else:
diagtool = getDiagtool(target) diagtool = getDiagtool(target)
list = subprocess.check_output([diagtool, "list-warnings"]).rstrip(); list = subprocess.check_output([diagtool, "list-warnings"]).rstrip();
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

cfe/trunk/www/OpenProjects.html

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Lines<li><b>XML Representation of ASTs</b>: Clang maintains a rich Abstract Syntax Tree that describes the program. Clang could emit an XML document that describes the program, which others tools could consume rather than being tied directly to the Clang binary.The XML representation needs to meet several requirements:
<ul> <ul>
<li><i>General</i>, so that it's able to represent C/C++/Objective-C abstractly, and isn't tied to the specific internal ASTs that Clang uses.</li> <li><i>General</i>, so that it's able to represent C/C++/Objective-C abstractly, and isn't tied to the specific internal ASTs that Clang uses.</li>
<li><i>Documented</i>, with appropriate Schema against which the output of Clang's XML formatter can be verified.</li> <li><i>Documented</i>, with appropriate Schema against which the output of Clang's XML formatter can be verified.</li>
<li><i>Stable</i> across Clang versions.</li> <li><i>Stable</i> across Clang versions.</li>
</ul></li> </ul></li>
<li><b>Configuration Manager</b>: Clang/LLVM works on a large number of <li><b>Configuration Manager</b>: Clang/LLVM works on a large number of
architectures and operating systems and can cross-compile to a similarly large architectures and operating systems and can cross-compile to a similarly large
number of configurations, but the pitfalls of chosing the command-line number of configurations, but the pitfalls of choosing the command-line
options, making sure the right sub-architecture is chosen and that the correct options, making sure the right sub-architecture is chosen and that the correct
optional elements of your particular system can be a pain. optional elements of your particular system can be a pain.
<p>A tool that would investigate hosts and targets, and store the configuration <p>A tool that would investigate hosts and targets, and store the configuration
in files that can later be used by Clang itself to avoid command-line options, in files that can later be used by Clang itself to avoid command-line options,
especially the ones regarding which target options to use, would greatle alleviate especially the ones regarding which target options to use, would greatle alleviate
this problem. A simple tool, with little or no dependency on LLVM itself, that this problem. A simple tool, with little or no dependency on LLVM itself, that
will investigate a target architecture by probing hardware, software, libraries will investigate a target architecture by probing hardware, software, libraries
Show All 19 Lines

cfe/trunk/www/analyzer/alpha_checks.html

Show First 20 Lines • Show All 545 Lines • ▼ Show 20 Lines
Warns against using one vs. many plural pattern in code Warns against using one vs. many plural pattern in code
when generating localized strings. when generating localized strings.
</div></div></td> </div></div></td>
<td><div class="exampleContainer expandable"> <td><div class="exampleContainer expandable">
<div class="example"><pre> <div class="example"><pre>
NSString *reminderText = NSString *reminderText =
NSLocalizedString(@"None", @"Indicates no reminders"); NSLocalizedString(@"None", @"Indicates no reminders");
if (reminderCount == 1) { if (reminderCount == 1) {
// Warning: Plural cases are not supported accross all languages. // Warning: Plural cases are not supported across all languages.
// Use a .stringsdict file instead // Use a .stringsdict file instead
reminderText = reminderText =
NSLocalizedString(@"1 Reminder", @"Indicates single reminder"); NSLocalizedString(@"1 Reminder", @"Indicates single reminder");
} else if (reminderCount >= 2) { } else if (reminderCount >= 2) {
// Warning: Plural cases are not supported accross all languages. // Warning: Plural cases are not supported across all languages.
// Use a .stringsdict file instead // Use a .stringsdict file instead
reminderText = reminderText =
[NSString stringWithFormat: [NSString stringWithFormat:
NSLocalizedString(@"%@ Reminders", @"Indicates multiple reminders"), NSLocalizedString(@"%@ Reminders", @"Indicates multiple reminders"),
reminderCount]; reminderCount];
} }
</pre></div></div></td></tr> </pre></div></div></td></tr>
▲ Show 20 Lines • Show All 139 Lines • ▼ Show 20 Linesvoid test() {
sprintf(buf, s); // warn: untrusted data as a format string sprintf(buf, s); // warn: untrusted data as a format string
} }
</pre></div><div class="separator"></div> </pre></div><div class="separator"></div>
<div class="example"><pre> <div class="example"><pre>
void test() { void test() {
size_t ts; size_t ts;
scanf("%zd", &ts); // 'ts' marked as tainted scanf("%zd", &ts); // 'ts' marked as tainted
int *p = (int *)malloc(ts * sizeof(int)); int *p = (int *)malloc(ts * sizeof(int));
// warn: untrusted data as bufer size // warn: untrusted data as buffer size
} }
</pre></div></div></td></tr> </pre></div></div></td></tr>
</tbody></table> </tbody></table>
<!-- ============================= unix alpha ============================= --> <!-- ============================= unix alpha ============================= -->
<h3 id="unix_alpha_checkers">Unix Alpha Checkers</h3> <h3 id="unix_alpha_checkers">Unix Alpha Checkers</h3>
<table class="checkers"> <table class="checkers">
▲ Show 20 Lines • Show All 213 Lines • Show Last 20 Lines

cfe/trunk/www/analyzer/available_checks.html

Show First 20 Lines • Show All 310 Lines • ▼ Show 20 Lines
<tr><td><div class="namedescr expandable"><span class="name"> <tr><td><div class="namedescr expandable"><span class="name">
core.uninitialized.Assign</span><span class="lang"> core.uninitialized.Assign</span><span class="lang">
(C)</span><div class="descr"> (C)</span><div class="descr">
Check for assigning uninitialized values.</div></div></td> Check for assigning uninitialized values.</div></div></td>
<td><div class="exampleContainer expandable"> <td><div class="exampleContainer expandable">
<div class="example"><pre> <div class="example"><pre>
void test() { void test() {
int x; int x;
x |= 1; // warn: left expression is unitialized x |= 1; // warn: left expression is uninitialized
} }
</pre></div></div></td></tr> </pre></div></div></td></tr>
<tr><td><div class="namedescr expandable"><span class="name"> <tr><td><div class="namedescr expandable"><span class="name">
core.uninitialized.Branch</span><span class="lang"> core.uninitialized.Branch</span><span class="lang">
(C)</span><div class="descr"> (C)</span><div class="descr">
Check for uninitialized values used as branch conditions.</div></div></td> Check for uninitialized values used as branch conditions.</div></div></td>
▲ Show 20 Lines • Show All 1,216 Lines • Show Last 20 Lines

cfe/trunk/www/diagnostics.html

Show First 20 Lines • Show All 225 Lines • ▼ Show 20 Lines<pre>
<span class="loc">t.cpp:9:3:</span> <span class="err">error:</span> <span class="msg">template specialization requires 'template&lt;&gt;'</span> <span class="loc">t.cpp:9:3:</span> <span class="err">error:</span> <span class="msg">template specialization requires 'template&lt;&gt;'</span>
struct iterator_traits&lt;file_iterator&gt; { struct iterator_traits&lt;file_iterator&gt; {
<span class="point">^</span> <span class="point">^</span>
<span class="snip">template&lt;&gt; </span> <span class="snip">template&lt;&gt; </span>
</pre> </pre>
<h2>Template Type Diffing</h2> <h2>Template Type Diffing</h2>
<p>Templates types can be long and difficult to read. Moreso when part of an <p>Templates types can be long and difficult to read. More so when part of an
error message. Instead of just printing out the type name, Clang has enough error message. Instead of just printing out the type name, Clang has enough
information to remove the common elements and highlight the differences. To information to remove the common elements and highlight the differences. To
show the template structure more clearly, the templated type can also be show the template structure more clearly, the templated type can also be
printed as an indented text tree.</p> printed as an indented text tree.</p>
Default: template diff with type elision Default: template diff with type elision
<pre> <pre>
<span class="loc">t.cc:4:5:</span> <span class="note">note:</span> candidate function not viable: no known conversion from 'vector&lt;map&lt;[...], <span class="template-highlight">float</span>&gt;&gt;' to 'vector&lt;map&lt;[...], <span class="template-highlight">double</span>&gt;&gt;' for 1st argument; <span class="loc">t.cc:4:5:</span> <span class="note">note:</span> candidate function not viable: no known conversion from 'vector&lt;map&lt;[...], <span class="template-highlight">float</span>&gt;&gt;' to 'vector&lt;map&lt;[...], <span class="template-highlight">double</span>&gt;&gt;' for 1st argument;
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

cfe/trunk/www/features.html

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
<!--=======================================================================--> <!--=======================================================================-->
<p>A major focus of our work on clang is to make it fast, light and scalable. <p>A major focus of our work on clang is to make it fast, light and scalable.
The library-based architecture of clang makes it straight-forward to time and The library-based architecture of clang makes it straight-forward to time and
profile the cost of each layer of the stack, and the driver has a number of profile the cost of each layer of the stack, and the driver has a number of
options for performance analysis. Many detailed benchmarks can be found online.</p> options for performance analysis. Many detailed benchmarks can be found online.</p>
<p>Compile time performance is important, but when using clang as an API, often <p>Compile time performance is important, but when using clang as an API, often
memory use is even moreso: the less memory the code takes the more code you can memory use is even more so: the less memory the code takes the more code you can
fit into memory at a time (useful for whole program analysis tools, for fit into memory at a time (useful for whole program analysis tools, for
example).</p> example).</p>
<p>In addition to being efficient when pitted head-to-head against GCC in batch <p>In addition to being efficient when pitted head-to-head against GCC in batch
mode, clang is built with a <a href="#libraryarch">library based mode, clang is built with a <a href="#libraryarch">library based
architecture</a> that makes it relatively easy to adapt it and build new tools architecture</a> that makes it relatively easy to adapt it and build new tools
with it. This means that it is often possible to apply out-of-the-box thinking with it. This means that it is often possible to apply out-of-the-box thinking
and novel techniques to improve compilation in various ways.</p> and novel techniques to improve compilation in various ways.</p>
▲ Show 20 Lines • Show All 296 Lines • Show Last 20 Lines

cfe/trunk/www/get_involved.html

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
<p>Clang has always been designed as a platform for experimentation, <p>Clang has always been designed as a platform for experimentation,
allowing programmers to easily extend the compiler to support great allowing programmers to easily extend the compiler to support great
new language features and tools. At some point, the authors of these new language features and tools. At some point, the authors of these
extensions may propose that the extensions become a part of Clang extensions may propose that the extensions become a part of Clang
itself, to benefit the whole Clang community. But not every idea--not itself, to benefit the whole Clang community. But not every idea--not
even every great idea--should become part of Clang. Extensions even every great idea--should become part of Clang. Extensions
(particularly language extensions) pose a long-term maintenance burden (particularly language extensions) pose a long-term maintenance burden
on Clang, and therefore the benefits of the extension must outweight on Clang, and therefore the benefits of the extension must outweigh
those costs. Hence, these are the seven criteria used to evaluate the those costs. Hence, these are the seven criteria used to evaluate the
merits of a proposed extension:</p> merits of a proposed extension:</p>
<ol> <ol>
<li>Evidence of a significant user community: This is based on a number of factors, including an actual, existing user community, the perceived likelihood that users would adopt such a feature if it were available, and any "trickle-down" effects that come from, e.g., a library adopting the feature and providing benefits to its users.</li> <li>Evidence of a significant user community: This is based on a number of factors, including an actual, existing user community, the perceived likelihood that users would adopt such a feature if it were available, and any "trickle-down" effects that come from, e.g., a library adopting the feature and providing benefits to its users.</li>
<li>A specific need to reside within the Clang tree: There are some extensions that would be better expressed as a separate tool, and should remain as separate tools even if they end up being hosted as part of the LLVM umbrella project.</li> <li>A specific need to reside within the Clang tree: There are some extensions that would be better expressed as a separate tool, and should remain as separate tools even if they end up being hosted as part of the LLVM umbrella project.</li>
Show All 14 Lines